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

jpl: 提交


Commit MetaInfo

修订版1001 (tree)
时间2020-05-02 06:05:33
作者jakobthomsen

Log Message

tag produce-version

更改概述

差异

--- tags/produce/jpl_compiler.c (nonexistent)
+++ tags/produce/jpl_compiler.c (revision 1001)
@@ -0,0 +1,99271 @@
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+
9+uint64_t max(uint64_t x, uint64_t y)
10+{
11+ return x > y ? x : y;
12+}
13+
14+uint64_t min(uint64_t x, uint64_t y)
15+{
16+ return x < y ? x : y;
17+}
18+
19+void MATCHID(const char *id)
20+{
21+ uint64_t c = 0;
22+ while(*id)
23+ {
24+ c = getchar();
25+ if(*id != c)
26+ {
27+ fprintf(stderr, "failed to match %s at char %c\n", id, (char)c);
28+ exit(-1);
29+ }
30+ id++;
31+ }
32+}
33+
34+void matchid(const char *id, uint64_t *lookahead)
35+{
36+ while(*id)
37+ {
38+ if(*id != *lookahead)
39+ {
40+ fprintf(stderr, "failed to match %s at char %c\n", id, (char)*lookahead);
41+ exit(-1);
42+ }
43+ *lookahead = getchar();
44+ id++;
45+ }
46+}
47+
48+uint64_t PARSENR()
49+{
50+ uint64_t nr = 0;
51+ while(isdigit(ungetc(getchar(), stdin)))
52+ {
53+ nr = 10 * nr + ((uint64_t)getchar() - '0');
54+ }
55+ return nr;
56+}
57+
58+uint64_t parsenr(uint64_t *lookahead)
59+{
60+ ungetc((int)*lookahead, stdin);
61+ uint64_t nr = PARSENR();
62+ *lookahead = (uint64_t)getchar();
63+ return nr;
64+}
65+
66+uint64_t PARSEID()
67+{
68+
69+ uint64_t lookahead = 0;
70+ uint64_t id = 0;
71+ uint64_t n = 10;
72+ while(n > 0)
73+ {
74+ --n;
75+ lookahead = (uint32_t)ungetc(getchar(), stdin);
76+ if('_' == lookahead) id |= (lookahead - '_' + 0) << (n * 6);
77+ else if(isupper((uint32_t)lookahead)) id |= (lookahead - 'A' + 1) << (n * 6);
78+ else if('$' == lookahead) id |= (lookahead - '$' + 27) << (n * 6);
79+ else if(islower((uint32_t)lookahead)) id |= (lookahead - 'a' + 28) << (n * 6);
80+ else if(isdigit((uint32_t)lookahead)) id |= (lookahead - '0' + 54) << (n * 6);
81+ else
82+ {
83+ break;
84+ }
85+ (void)getchar();
86+ }
87+ return id;
88+}
89+
90+uint64_t parseid(uint64_t *lookahead)
91+{
92+
93+ ungetc((int)*lookahead, stdin);
94+ uint64_t id = PARSEID();
95+ *lookahead = (uint64_t)getchar();
96+ return id;
97+}
98+
99+void printid(FILE *const f, uint64_t id)
100+{
101+ uint64_t i = 10;
102+ while(i)
103+ {
104+ --i;
105+ uint64_t c = (id >> (i * 6llu)) & 63llu;
106+ if(c < 1) fprintf(f, "_");
107+ else if(c < 27) fprintf(f, "%c", (char)(c + 'A' - 1));
108+ else if(c < 28) fprintf(f, "$");
109+ else if(c < 54) fprintf(f, "%c", (char)(c + 'a' - 28));
110+ else /*if(c < 64)*/ fprintf(f, "%c", (char)(c + '0' - 54));
111+ }
112+ for(id = (id >> 60LLU) & 0xF; id > 0; id--)
113+ {
114+ fprintf(f, "'");
115+ }
116+}
117+
118+struct heap
119+{
120+ struct pair *data;
121+ uint64_t freelist;
122+ uint64_t availilable_size_for_dynamic_objects;
123+};
124+
125+struct state
126+{
127+ uint64_t addr;
128+};
129+
130+struct all
131+{
132+ struct heap heap;
133+ struct state state;
134+};
135+
136+
137+uint64_t compare(uint64_t left, uint64_t right)
138+{
139+ return left > right ? 1LLU : left < right ? ~0LLU : 0LLU;
140+}
141+
142+void swap(uint64_t *left, uint64_t *right)
143+{
144+ if(!left)
145+ {
146+ fprintf(stderr, "swap: left empty\n");
147+ exit(-1);
148+ }
149+ if(!right)
150+ {
151+ fprintf(stderr, "swap: right empty\n");
152+ exit(-1);
153+ }
154+ uint64_t tmp = *right;
155+ *right = *left;
156+ *left = tmp;
157+}
158+
159+uint64_t countsetbits(uint64_t value)
160+{
161+ uint64_t count;
162+ for (count = 0; value; count++)
163+ value &= value - 1LLU;
164+ return count;
165+}
166+
167+uint64_t highestsetbit(uint64_t value)
168+{
169+ uint64_t count = 0;
170+ while (value >>= 1LLU)
171+ {;
172+ count++;
173+ };
174+ return count;
175+}
176+
177+uint64_t encodeaddr(uint64_t root, uint64_t elem)
178+{
179+ return (root << 32) | (elem << 0);
180+}
181+
182+uint64_t decoderoot(uint64_t addr)
183+{
184+ return (addr >> 32);
185+}
186+
187+uint64_t decodeelem(uint64_t addr)
188+{
189+ return (addr & 0xFFFFFFFF);
190+}
191+
192+struct pair
193+{
194+ uint64_t elem0;
195+ uint64_t elem1;
196+};
197+
198+uint64_t *access_heap(struct pair *const heap, uint64_t addr)
199+{
200+ return (addr & 1) ? &heap[addr >> 1].elem1 : &heap[addr >> 1].elem0;
201+}
202+
203+uint64_t pair_move(struct heap *const heap, uint64_t *elem0, uint64_t *elem1)
204+{
205+ if(!heap)
206+ {
207+ fprintf(stderr, "pair_move: internal error - no heap!\n");
208+ exit(-1);
209+ }
210+ uint64_t new_addr = heap->freelist;
211+ if(!new_addr)
212+ {
213+ fprintf(stderr, "pair_move: out of heap\n");
214+ exit(-1);
215+ }
216+ heap->freelist = heap->data[new_addr].elem0;
217+ heap->data[new_addr].elem0 = *elem0;
218+ heap->data[new_addr].elem1 = *elem1;
219+ *elem0 = 0;
220+ *elem1 = 0;
221+ return new_addr;
222+}
223+
224+struct pair unpair(struct heap *const heap, uint64_t *pair)
225+{
226+ if(!heap)
227+ {
228+ fprintf(stderr, "unpair: internal error - no heap!\n");
229+ exit(-1);
230+ }
231+ if(!*pair)
232+ {
233+ fprintf(stderr, "unpair: null-reference!\n");
234+ exit(-1);
235+ }
236+ struct pair result = heap->data[*pair];
237+ heap->data[*pair].elem0 = heap->freelist;
238+ heap->data[*pair].elem1 = 0;
239+ heap->freelist = *pair;
240+ *pair = 0;
241+ return result;
242+}
243+
244+bool list_push_move(struct heap *const heap, uint64_t *const elem, uint64_t *const list, uint64_t weight)
245+{
246+ if(!heap)
247+ {
248+ fprintf(stderr, "list_push_move: internal error - no heap!\n");
249+ exit(-1);
250+ }
251+ if(weight > heap->availilable_size_for_dynamic_objects)
252+ {
253+ return false;
254+ }
255+ heap->availilable_size_for_dynamic_objects -= weight;
256+ *list = pair_move(heap, list, elem);
257+ return true;
258+}
259+
260+uint64_t list_pop_move(struct heap *const heap, uint64_t *const list, uint64_t weight)
261+{
262+ if(!heap)
263+ {
264+ fprintf(stderr, "list_pop_move: internal error - no heap!\n");
265+ exit(-1);
266+ }
267+ if(!*list)
268+ {
269+ fprintf(stderr, "list_pop_move: empty list!\n");
270+ exit(-1);
271+ }
272+ heap->availilable_size_for_dynamic_objects += weight;
273+ struct pair top = unpair(heap, list);
274+ *list = top.elem0;
275+ return top.elem1;
276+}
277+
278+void list_size(struct pair *const heapdata, uint64_t *const size, uint64_t list)
279+{
280+ if(!size)
281+ {
282+ fprintf(stderr, "list_size: no size\n");
283+ exit(-1);
284+ }
285+ for(*size = 0; list; ++*size)
286+ {
287+ list = heapdata[list].elem0;
288+ }
289+}
290+
291+void list_reverse(struct pair *const heapdata, uint64_t *root)
292+{
293+ uint64_t new_root = 0;
294+ while(*root)
295+ {
296+ uint64_t next = heapdata[*root].elem0;
297+ heapdata[*root].elem0 = new_root;
298+ new_root = *root;
299+ *root = next;
300+ }
301+ *root = new_root;
302+}
303+
304+void tree_push_move(struct heap *const heap, uint64_t size, uint64_t *const root, uint64_t *const elem)
305+{
306+ if(!heap)
307+ {
308+ fprintf(stderr, "tree_push_move: internal error - no heap!\n");
309+ exit(-1);
310+ }
311+ uint64_t spine = countsetbits(size++);
312+ if(!spine)
313+ {
314+ if(*root)
315+ {
316+ fprintf(stderr, "tree_push_move: destination uninitialized (at size = 0)!\n");
317+ exit(-1);
318+ }
319+ *root = *elem;
320+ *elem = 0;
321+ }
322+ else
323+ {
324+ uint64_t *ptr = root;
325+ while(spine > 1)
326+ {
327+ --spine;
328+ ptr = &heap->data[*ptr].elem1;
329+ }
330+ uint64_t new_addr = pair_move(heap, ptr, elem);
331+ *ptr = new_addr;
332+ }
333+}
334+
335+uint64_t tree_pop_move(struct heap *const heap, uint64_t size, uint64_t *const root)
336+{
337+ if(!heap)
338+ {
339+ fprintf(stderr, "tree_pop_move: internal error - no heap!\n");
340+ exit(-1);
341+ }
342+ uint64_t elem = 0;
343+ if(!size)
344+ {
345+ fprintf(stderr, "tree_pop_move: empty tree (size = 0)!\n");
346+ exit(-1);
347+ }
348+ uint64_t spine = countsetbits(--size);
349+ if(!*root && size > 0)
350+ {
351+ fprintf(stderr, "tree_pop_move: tree empty!\n");
352+ exit(-1);
353+ }
354+ if(!spine)
355+ {
356+ elem = *root;
357+ *root = 0;
358+ }
359+ else
360+ {
361+ uint64_t *ptr = root;
362+ while(spine > 1)
363+ {
364+ --spine;
365+ ptr = &heap->data[*ptr].elem1;
366+ }
367+ struct pair top = unpair(heap, ptr);
368+ elem = top.elem1;
369+ *ptr = top.elem0;
370+ }
371+ return elem;
372+}
373+
374+uint64_t *tree_elem_ref(struct pair *const heap, uint64_t size, uint64_t *const root, uint64_t index)
375+{
376+ uint64_t *node = root;
377+ if(index < size) // NOTE: this implies size > 0
378+ {
379+ uint64_t last = size - 1LLU;
380+ uint64_t height = highestsetbit(last) + 1LLU;
381+ while(height > 0)
382+ {
383+ height--;
384+ uint64_t mask = 1llu << height;
385+ if(last & mask)
386+ {
387+ if(index & mask)
388+ {
389+ node = &heap[*node].elem1;
390+ }
391+ else
392+ {
393+ node = &heap[*node].elem0;
394+ break;
395+ }
396+ }
397+
398+ }
399+ while(height > 0)
400+ {
401+ height--;
402+ uint64_t mask = 1LLU << height;
403+ if(index & mask)
404+ {
405+ node = &heap[*node].elem1;
406+ }
407+ else
408+ {
409+ node = &heap[*node].elem0;
410+ }
411+ }
412+ }
413+ else
414+ {
415+ fprintf(stderr, "tree_elem_access: index %llu out of range 0..%llu\n", (unsigned long long)index, (unsigned long long)size);
416+ exit(-1);
417+ }
418+ return node;
419+}
420+
421+uint64_t tree_elem_addr_internal(struct pair *const heap, uint64_t size, uint64_t const root, uint64_t index)
422+{
423+ bool flag = (root & 1);
424+ uint64_t addr = (root >> 1);
425+ if(index < size) // NOTE: this implies size > 0
426+ {
427+ uint64_t last = size - 1LLU;
428+ bool searchfulltree = true;
429+ uint64_t height = highestsetbit(last) + 1LLU;
430+ while(height > 0)
431+ {
432+ height--;
433+ uint64_t mask = 1llu << height;
434+ if(searchfulltree)
435+ {
436+ if(last & mask)
437+ {
438+ addr = flag ? heap[addr].elem1 : heap[addr].elem0;
439+ flag = index & mask;
440+ searchfulltree = flag;
441+ }
442+ }
443+ else
444+ {
445+ addr = flag ? heap[addr].elem1 : heap[addr].elem0;
446+ flag = index & mask;
447+ }
448+ }
449+ }
450+ else
451+ {
452+ fprintf(stderr, "tree_elem_access: index %llu out of range 0..%llu\n", (unsigned long long)index, (unsigned long long)size);
453+ exit(-1);
454+ }
455+ addr = ((addr << 1) | flag);
456+ return addr;
457+}
458+
459+uint64_t tree_elem_addr(struct pair *const heap, uint64_t size, uint64_t const root, uint64_t index)
460+{
461+ if(!root)
462+ {
463+ fprintf(stderr, "ERROR: null-addr in tree_elem_addr");
464+ exit(-1);
465+ }
466+ return tree_elem_addr_internal(heap, size, root, index);
467+}
468+
469+uint64_t tree_init(struct heap *const heap, uint64_t req_size)
470+{
471+ uint64_t root = 0;
472+ uint64_t elem = 0;
473+ for(uint64_t actual_size = 0; actual_size < req_size; actual_size++)
474+ {
475+ tree_push_move(heap, actual_size, &root, &elem);
476+ }
477+ return root;
478+}
479+
480+void tree_free(struct heap *const heap, uint64_t size, uint64_t *const root)
481+{
482+ for(; size > 0; size--)
483+ {
484+ (void)tree_pop_move(heap, size, root);
485+ }
486+ *root = 0;
487+}
488+
489+uint64_t move(uint64_t *const src)
490+{
491+ uint64_t dst = *src;
492+ *src = 0;
493+ return dst;
494+}
495+
496+uint64_t LOCAL_ACCESS_ADDR(struct pair *const heap, uint64_t size, uint64_t index)
497+{
498+ return tree_elem_addr(heap, /*skip baseinfo*/1llu + size, 1/*contains memroot*/, /*skip baseinfo*/1llu + index);
499+}
500+
501+uint64_t *LOCAL_ACCESS(struct pair *const heap, uint64_t size, uint64_t index)
502+{
503+ return access_heap(heap, LOCAL_ACCESS_ADDR(heap, size, index));
504+}
505+
506+void LOCAL_PUSH_MOVE(struct heap *const heap, uint64_t size, uint64_t *const root, uint64_t *const elem)
507+{
508+ tree_push_move(heap, /*skip baseinfo*/1llu + size, root, elem);
509+}
510+
511+uint64_t LOCAL_POP_MOVE(struct heap *const heap, uint64_t size, uint64_t *const root)
512+{
513+ return tree_pop_move(heap, /*skip baseinfo*/1llu + size, root);
514+}
515+
516+uint64_t countheap(struct heap *const heap)
517+{
518+ uint64_t node = heap->freelist;
519+ uint64_t heapcount = 0;
520+ for(heapcount = 0; node; node = heap->data[node].elem0)
521+ {
522+ heapcount++;
523+ }
524+ return heapcount;
525+}
526+
527+struct all init(struct pair *heapraw);
528+
529+int main(int argc, char **args)
530+{
531+ #define MEMSIZE (408LLU + 1)
532+ struct pair heapraw[33177LLU + 1];
533+ struct all all = init(heapraw);
534+ struct heap heap = all.heap;
535+ struct state state = all.state;
536+ while(state.addr)
537+ {
538+ switch(state.addr)
539+ {
540+ case 552446646280519680LLU: // copyu64___
541+ {
542+ {
543+ uint64_t arg = 0;
544+ LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
545+ }
546+ *LOCAL_ACCESS(heap.data, 3LLU, 2LLU) = /*value_____*/*LOCAL_ACCESS(heap.data, 3LLU, 1LLU);
547+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU)) = /*value_____*/*LOCAL_ACCESS(heap.data, 3LLU, 1LLU);
548+ // variable u64 tmp_______ goes out of scope
549+ // emitted destructur for type u64
550+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference tmp_______ at 3
551+ // parameter u64 value_____ goes out of scope
552+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference value_____ at 2
553+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
554+ {
555+ uint64_t baseinfo = heap.data[0].elem1;
556+ struct pair pair = unpair(&heap, &baseinfo);
557+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
558+ state.addr = pair.elem1;
559+ }
560+ break;
561+ }
562+ case 819847183515949359LLU: // reportinit
563+ {
564+ fprintf(stderr, "%s", "in function ");
565+ printid(stderr, /*def_id____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
566+ fprintf(stderr, "%s", ": ");
567+ // parameter-reference u64 def_id____ goes out of scope
568+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference def_id____ at 1
569+ {
570+ uint64_t baseinfo = heap.data[0].elem1;
571+ struct pair pair = unpair(&heap, &baseinfo);
572+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
573+ state.addr = pair.elem1;
574+ }
575+ break;
576+ }
577+ case 517555828430096990LLU: // assign_inc
578+ {
579+ ++/*value_____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU));
580+ {
581+ uint64_t arg = 0;
582+ LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
583+ }
584+ *LOCAL_ACCESS(heap.data, 3LLU, 2LLU) = /*value_____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU));
585+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU)) = /*result____*/*LOCAL_ACCESS(heap.data, 3LLU, 2LLU);
586+ // variable u64 result____ goes out of scope
587+ // emitted destructur for type u64
588+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference result____ at 3
589+ // parameter-reference u64 value_____ goes out of scope
590+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference value_____ at 2
591+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
592+ {
593+ uint64_t baseinfo = heap.data[0].elem1;
594+ struct pair pair = unpair(&heap, &baseinfo);
595+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
596+ state.addr = pair.elem1;
597+ }
598+ break;
599+ }
600+ case 517555828430075934LLU: // assign_dec
601+ {
602+ --/*value_____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU));
603+ {
604+ uint64_t arg = 0;
605+ LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
606+ }
607+ *LOCAL_ACCESS(heap.data, 3LLU, 2LLU) = /*value_____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU));
608+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU)) = /*result____*/*LOCAL_ACCESS(heap.data, 3LLU, 2LLU);
609+ // variable u64 result____ goes out of scope
610+ // emitted destructur for type u64
611+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference result____ at 3
612+ // parameter-reference u64 value_____ goes out of scope
613+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference value_____ at 2
614+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
615+ {
616+ uint64_t baseinfo = heap.data[0].elem1;
617+ struct pair pair = unpair(&heap, &baseinfo);
618+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
619+ state.addr = pair.elem1;
620+ }
621+ break;
622+ }
623+ case 787446708198178816LLU: // printnr___
624+ {
625+ fprintf(stdout, "%llu", (unsigned long long)/*nr________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
626+ fprintf(stdout, "%s", "LLU");
627+ // parameter-reference u64 nr________ goes out of scope
628+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference nr________ at 1
629+ {
630+ uint64_t baseinfo = heap.data[0].elem1;
631+ struct pair pair = unpair(&heap, &baseinfo);
632+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
633+ state.addr = pair.elem1;
634+ }
635+ break;
636+ }
637+ case 819847183517274112LLU: // reportnr__
638+ {
639+ fprintf(stderr, "%llu", (unsigned long long)/*nr________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
640+ // parameter-reference u64 nr________ goes out of scope
641+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference nr________ at 1
642+ {
643+ uint64_t baseinfo = heap.data[0].elem1;
644+ struct pair pair = unpair(&heap, &baseinfo);
645+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
646+ state.addr = pair.elem1;
647+ }
648+ break;
649+ }
650+ case 661609854409900032LLU: // iseof_____
651+ {
652+ {
653+ uint64_t arg = 0;
654+ LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
655+ }
656+ *LOCAL_ACCESS(heap.data, 3LLU, 2LLU) = 255;
657+ *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);
658+ // variable u64 result____ goes out of scope
659+ // emitted destructur for type u64
660+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference result____ at 3
661+ // parameter-reference u64 lookahead_ goes out of scope
662+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference lookahead_ at 2
663+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
664+ {
665+ uint64_t baseinfo = heap.data[0].elem1;
666+ struct pair pair = unpair(&heap, &baseinfo);
667+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
668+ state.addr = pair.elem1;
669+ }
670+ break;
671+ }
672+ case 661649452408901632LLU: // isnoteof__
673+ {
674+ {
675+ uint64_t arg = 0;
676+ LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
677+ }
678+ *LOCAL_ACCESS(heap.data, 3LLU, 2LLU) = 255;
679+ *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);
680+ // variable u64 result____ goes out of scope
681+ // emitted destructur for type u64
682+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference result____ at 3
683+ // parameter-reference u64 lookahead_ goes out of scope
684+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference lookahead_ at 2
685+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
686+ {
687+ uint64_t baseinfo = heap.data[0].elem1;
688+ struct pair pair = unpair(&heap, &baseinfo);
689+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
690+ state.addr = pair.elem1;
691+ }
692+ break;
693+ }
694+ case 661648768551262208LLU: // isnewline_
695+ {
696+ if(*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU)) != 10)
697+ {
698+ state.addr = 18446744073709551614LLU; // 9999999998'''''''''''''''
699+ break;
700+ }
701+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 0LLU)) = 1LLU;
702+ // parameter-reference u64 __________ goes out of scope
703+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
704+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
705+ {
706+ uint64_t baseinfo = heap.data[0].elem1;
707+ struct pair pair = unpair(&heap, &baseinfo);
708+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
709+ state.addr = pair.elem1;
710+ }
711+ break;
712+ }
713+ case 18446744073709551614LLU: // 9999999998'''''''''''''''
714+ {
715+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 0LLU)) = 0LLU;
716+ // parameter-reference u64 __________ goes out of scope
717+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
718+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
719+ {
720+ uint64_t baseinfo = heap.data[0].elem1;
721+ struct pair pair = unpair(&heap, &baseinfo);
722+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
723+ state.addr = pair.elem1;
724+ }
725+ break;
726+ }
727+ case 661671490923528192LLU: // isspace___
728+ {
729+ if(*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU)) != 9)
730+ {
731+ state.addr = 18446744073709551612LLU; // 9999999996'''''''''''''''
732+ break;
733+ }
734+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 0LLU)) = 1LLU;
735+ // parameter-reference u64 __________ goes out of scope
736+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
737+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
738+ {
739+ uint64_t baseinfo = heap.data[0].elem1;
740+ struct pair pair = unpair(&heap, &baseinfo);
741+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
742+ state.addr = pair.elem1;
743+ }
744+ break;
745+ }
746+ case 18446744073709551612LLU: // 9999999996'''''''''''''''
747+ {
748+ if(*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU)) != 10)
749+ {
750+ state.addr = 18446744073709551611LLU; // 9999999995'''''''''''''''
751+ break;
752+ }
753+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 0LLU)) = 1LLU;
754+ // parameter-reference u64 __________ goes out of scope
755+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
756+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
757+ {
758+ uint64_t baseinfo = heap.data[0].elem1;
759+ struct pair pair = unpair(&heap, &baseinfo);
760+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
761+ state.addr = pair.elem1;
762+ }
763+ break;
764+ }
765+ case 18446744073709551611LLU: // 9999999995'''''''''''''''
766+ {
767+ if(*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU)) != 11)
768+ {
769+ state.addr = 18446744073709551610LLU; // 9999999994'''''''''''''''
770+ break;
771+ }
772+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 0LLU)) = 1LLU;
773+ // parameter-reference u64 __________ goes out of scope
774+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
775+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
776+ {
777+ uint64_t baseinfo = heap.data[0].elem1;
778+ struct pair pair = unpair(&heap, &baseinfo);
779+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
780+ state.addr = pair.elem1;
781+ }
782+ break;
783+ }
784+ case 18446744073709551610LLU: // 9999999994'''''''''''''''
785+ {
786+ if(*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU)) != 12)
787+ {
788+ state.addr = 18446744073709551609LLU; // 9999999993'''''''''''''''
789+ break;
790+ }
791+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 0LLU)) = 1LLU;
792+ // parameter-reference u64 __________ goes out of scope
793+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
794+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
795+ {
796+ uint64_t baseinfo = heap.data[0].elem1;
797+ struct pair pair = unpair(&heap, &baseinfo);
798+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
799+ state.addr = pair.elem1;
800+ }
801+ break;
802+ }
803+ case 18446744073709551609LLU: // 9999999993'''''''''''''''
804+ {
805+ if(*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU)) != 13)
806+ {
807+ state.addr = 18446744073709551608LLU; // 9999999992'''''''''''''''
808+ break;
809+ }
810+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 0LLU)) = 1LLU;
811+ // parameter-reference u64 __________ goes out of scope
812+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
813+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
814+ {
815+ uint64_t baseinfo = heap.data[0].elem1;
816+ struct pair pair = unpair(&heap, &baseinfo);
817+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
818+ state.addr = pair.elem1;
819+ }
820+ break;
821+ }
822+ case 18446744073709551608LLU: // 9999999992'''''''''''''''
823+ {
824+ if(*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU)) != 32)
825+ {
826+ state.addr = 18446744073709551607LLU; // 9999999991'''''''''''''''
827+ break;
828+ }
829+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 0LLU)) = 1LLU;
830+ // parameter-reference u64 __________ goes out of scope
831+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
832+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
833+ {
834+ uint64_t baseinfo = heap.data[0].elem1;
835+ struct pair pair = unpair(&heap, &baseinfo);
836+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
837+ state.addr = pair.elem1;
838+ }
839+ break;
840+ }
841+ case 18446744073709551607LLU: // 9999999991'''''''''''''''
842+ {
843+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 0LLU)) = 0LLU;
844+ // parameter-reference u64 __________ goes out of scope
845+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
846+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
847+ {
848+ uint64_t baseinfo = heap.data[0].elem1;
849+ struct pair pair = unpair(&heap, &baseinfo);
850+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
851+ state.addr = pair.elem1;
852+ }
853+ break;
854+ }
855+ case 661680303159640064LLU: // isupper___
856+ {
857+ {
858+ uint64_t arg = 0;
859+ LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
860+ }
861+ *LOCAL_ACCESS(heap.data, 3LLU, 2LLU) = 65;
862+ {
863+ uint64_t arg = 0;
864+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
865+ }
866+ *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = 0;
867+ {
868+ uint64_t arg = 0;
869+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
870+ }
871+ *LOCAL_ACCESS(heap.data, 5LLU, 4LLU) = /*lookahead_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 1LLU)) >= /*sym_______*/*LOCAL_ACCESS(heap.data, 5LLU, 2LLU);
872+ state.addr = *LOCAL_ACCESS(heap.data, 5LLU, 4LLU) ? 18446744073709551605LLU : 18446744073709551604LLU;
873+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 5
874+ break;
875+ }
876+ case 18446744073709551605LLU: // 999999999z'''''''''''''''
877+ {
878+
879+ *LOCAL_ACCESS(heap.data, 4LLU, 2LLU) = 90;
880+ {
881+ uint64_t arg = 0;
882+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
883+ }
884+ *LOCAL_ACCESS(heap.data, 5LLU, 4LLU) = /*lookahead_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 1LLU)) <= /*sym_______*/*LOCAL_ACCESS(heap.data, 5LLU, 2LLU);
885+ state.addr = *LOCAL_ACCESS(heap.data, 5LLU, 4LLU) ? 18446744073709551603LLU : 18446744073709551602LLU;
886+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 5
887+ break;
888+ }
889+ case 18446744073709551603LLU: // 999999999x'''''''''''''''
890+ {
891+
892+ *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = 1;
893+ state.addr = 18446744073709551602LLU; // 999999999w'''''''''''''''
894+ break;
895+ }
896+ case 18446744073709551602LLU: // 999999999w'''''''''''''''
897+ {
898+ state.addr = 18446744073709551604LLU; // 999999999y'''''''''''''''
899+ break;
900+ }
901+ case 18446744073709551604LLU: // 999999999y'''''''''''''''
902+ {
903+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU)) = /*result____*/*LOCAL_ACCESS(heap.data, 4LLU, 3LLU);
904+ // variable u64 result____ goes out of scope
905+ // emitted destructur for type u64
906+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference result____ at 4
907+ // variable u64 sym_______ goes out of scope
908+ // emitted destructur for type u64
909+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference sym_______ at 3
910+ // parameter-reference u64 lookahead_ goes out of scope
911+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference lookahead_ at 2
912+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
913+ {
914+ uint64_t baseinfo = heap.data[0].elem1;
915+ struct pair pair = unpair(&heap, &baseinfo);
916+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
917+ state.addr = pair.elem1;
918+ }
919+ break;
920+ }
921+ case 661640659537756160LLU: // islower___
922+ {
923+ {
924+ uint64_t arg = 0;
925+ LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
926+ }
927+ *LOCAL_ACCESS(heap.data, 3LLU, 2LLU) = 97;
928+ {
929+ uint64_t arg = 0;
930+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
931+ }
932+ *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = 0;
933+ {
934+ uint64_t arg = 0;
935+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
936+ }
937+ *LOCAL_ACCESS(heap.data, 5LLU, 4LLU) = /*lookahead_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 1LLU)) >= /*sym_______*/*LOCAL_ACCESS(heap.data, 5LLU, 2LLU);
938+ state.addr = *LOCAL_ACCESS(heap.data, 5LLU, 4LLU) ? 18446744073709551601LLU : 18446744073709551600LLU;
939+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 5
940+ break;
941+ }
942+ case 18446744073709551601LLU: // 999999999v'''''''''''''''
943+ {
944+
945+ *LOCAL_ACCESS(heap.data, 4LLU, 2LLU) = 122;
946+ {
947+ uint64_t arg = 0;
948+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
949+ }
950+ *LOCAL_ACCESS(heap.data, 5LLU, 4LLU) = /*lookahead_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 1LLU)) <= /*sym_______*/*LOCAL_ACCESS(heap.data, 5LLU, 2LLU);
951+ state.addr = *LOCAL_ACCESS(heap.data, 5LLU, 4LLU) ? 18446744073709551599LLU : 18446744073709551598LLU;
952+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 5
953+ break;
954+ }
955+ case 18446744073709551599LLU: // 999999999t'''''''''''''''
956+ {
957+
958+ *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = 1;
959+ state.addr = 18446744073709551598LLU; // 999999999s'''''''''''''''
960+ break;
961+ }
962+ case 18446744073709551598LLU: // 999999999s'''''''''''''''
963+ {
964+ state.addr = 18446744073709551600LLU; // 999999999u'''''''''''''''
965+ break;
966+ }
967+ case 18446744073709551600LLU: // 999999999u'''''''''''''''
968+ {
969+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU)) = /*result____*/*LOCAL_ACCESS(heap.data, 4LLU, 3LLU);
970+ // variable u64 result____ goes out of scope
971+ // emitted destructur for type u64
972+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference result____ at 4
973+ // variable u64 sym_______ goes out of scope
974+ // emitted destructur for type u64
975+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference sym_______ at 3
976+ // parameter-reference u64 lookahead_ goes out of scope
977+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference lookahead_ at 2
978+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
979+ {
980+ uint64_t baseinfo = heap.data[0].elem1;
981+ struct pair pair = unpair(&heap, &baseinfo);
982+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
983+ state.addr = pair.elem1;
984+ }
985+ break;
986+ }
987+ case 661592067397386240LLU: // isalpha___
988+ {
989+ {
990+ uint64_t arg = 0;
991+ LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
992+ }
993+ // ACCUMULATE ARGUMENTS - BEGIN
994+ {
995+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 3LLU, 2LLU);
996+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
997+ }
998+ {
999+ uint64_t arg = /*lookahead_*/*LOCAL_ACCESS(heap.data, 3LLU, 1LLU);
1000+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
1001+ }
1002+ // ACCUMULATE ARGUMENTS - END
1003+ uint64_t return_to = 18446744073709551594LLU;
1004+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
1005+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
1006+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
1007+ heap.data[0].elem1 = heap.data[0].elem0;
1008+ heap.data[0].elem0 = restore;
1009+ state.addr = 661680303159640064LLU; // isupper___
1010+ break;
1011+ }
1012+ case 18446744073709551594LLU: // 999999999o'''''''''''''''
1013+ {
1014+ state.addr = *LOCAL_ACCESS(heap.data, 3LLU, 2LLU) ? 18446744073709551597LLU : 18446744073709551596LLU;
1015+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 3
1016+ break;
1017+ }
1018+ case 18446744073709551597LLU: // 999999999r'''''''''''''''
1019+ {
1020+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 0LLU)) = 1LLU;
1021+ state.addr = 18446744073709551595LLU; // 999999999p'''''''''''''''
1022+ break;
1023+ }
1024+ case 18446744073709551596LLU: // 999999999q'''''''''''''''
1025+ {
1026+ // ACCUMULATE ARGUMENTS - BEGIN
1027+ {
1028+ uint64_t arg = *LOCAL_ACCESS(heap.data, 2LLU, 0LLU);
1029+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
1030+ }
1031+ {
1032+ uint64_t arg = /*lookahead_*/*LOCAL_ACCESS(heap.data, 2LLU, 1LLU);
1033+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
1034+ }
1035+ // ACCUMULATE ARGUMENTS - END
1036+ uint64_t return_to = 18446744073709551593LLU;
1037+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
1038+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
1039+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
1040+ heap.data[0].elem1 = heap.data[0].elem0;
1041+ heap.data[0].elem0 = restore;
1042+ state.addr = 661640659537756160LLU; // islower___
1043+ break;
1044+ }
1045+ case 18446744073709551593LLU: // 999999999n'''''''''''''''
1046+ {
1047+ state.addr = 18446744073709551595LLU; // 999999999p'''''''''''''''
1048+ break;
1049+ }
1050+ case 18446744073709551595LLU: // 999999999p'''''''''''''''
1051+ {
1052+ // parameter-reference u64 lookahead_ goes out of scope
1053+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference lookahead_ at 2
1054+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
1055+ {
1056+ uint64_t baseinfo = heap.data[0].elem1;
1057+ struct pair pair = unpair(&heap, &baseinfo);
1058+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
1059+ state.addr = pair.elem1;
1060+ }
1061+ break;
1062+ }
1063+ case 661605045736570880LLU: // isdigit___
1064+ {
1065+ {
1066+ uint64_t arg = 0;
1067+ LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1068+ }
1069+ *LOCAL_ACCESS(heap.data, 3LLU, 2LLU) = 48;
1070+ {
1071+ uint64_t arg = 0;
1072+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1073+ }
1074+ *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /*lookahead_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 1LLU)) >= /*result____*/*LOCAL_ACCESS(heap.data, 4LLU, 2LLU);
1075+ state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551592LLU : 18446744073709551591LLU;
1076+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
1077+ break;
1078+ }
1079+ case 18446744073709551592LLU: // 999999999m'''''''''''''''
1080+ {
1081+
1082+ *LOCAL_ACCESS(heap.data, 3LLU, 2LLU) = 57;
1083+
1084+ *LOCAL_ACCESS(heap.data, 3LLU, 2LLU) = /*lookahead_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU)) <= /*result____*/*LOCAL_ACCESS(heap.data, 3LLU, 2LLU);
1085+ state.addr = 18446744073709551591LLU; // 999999999l'''''''''''''''
1086+ break;
1087+ }
1088+ case 18446744073709551591LLU: // 999999999l'''''''''''''''
1089+ {
1090+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU)) = /*result____*/*LOCAL_ACCESS(heap.data, 3LLU, 2LLU);
1091+ // variable u64 result____ goes out of scope
1092+ // emitted destructur for type u64
1093+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference result____ at 3
1094+ // parameter-reference u64 lookahead_ goes out of scope
1095+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference lookahead_ at 2
1096+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
1097+ {
1098+ uint64_t baseinfo = heap.data[0].elem1;
1099+ struct pair pair = unpair(&heap, &baseinfo);
1100+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
1101+ state.addr = pair.elem1;
1102+ }
1103+ break;
1104+ }
1105+ case 839519719621918720LLU: // skipws____
1106+ {
1107+ {
1108+ uint64_t arg = 0;
1109+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1110+ }
1111+ // ACCUMULATE ARGUMENTS - BEGIN
1112+ {
1113+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 2LLU, 1LLU);
1114+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
1115+ }
1116+ {
1117+ uint64_t arg = /*lookahead_*/*LOCAL_ACCESS(heap.data, 2LLU, 0LLU);
1118+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
1119+ }
1120+ // ACCUMULATE ARGUMENTS - END
1121+ uint64_t return_to = 18446744073709551588LLU;
1122+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
1123+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
1124+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
1125+ heap.data[0].elem1 = heap.data[0].elem0;
1126+ heap.data[0].elem0 = restore;
1127+ state.addr = 661671490923528192LLU; // isspace___
1128+ break;
1129+ }
1130+ case 18446744073709551588LLU: // 999999999i'''''''''''''''
1131+ {
1132+ state.addr = *LOCAL_ACCESS(heap.data, 2LLU, 1LLU) ? 18446744073709551590LLU : 18446744073709551589LLU;
1133+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
1134+ break;
1135+ }
1136+ case 18446744073709551590LLU: // 999999999k'''''''''''''''
1137+ {
1138+ {
1139+ uint64_t arg = 0;
1140+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1141+ }
1142+ *LOCAL_ACCESS(heap.data, 2LLU, 1LLU) = 0;
1143+ state.addr = 18446744073709551587LLU; // 999999999h'''''''''''''''
1144+ break;
1145+ }
1146+ case 18446744073709551587LLU: // 999999999h'''''''''''''''
1147+ {
1148+ *LOCAL_ACCESS(heap.data, 2LLU, 1LLU) = (uint64_t)getchar();
1149+ if(!*LOCAL_ACCESS(heap.data, 2LLU, 1LLU) || *LOCAL_ACCESS(heap.data, 2LLU, 1LLU) > 255)
1150+ {
1151+ state.addr = 18446744073709551586LLU; // 999999999g'''''''''''''''
1152+ break;
1153+ }
1154+ {
1155+ uint64_t arg = 0;
1156+ LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1157+ }
1158+ // ACCUMULATE ARGUMENTS - BEGIN
1159+ {
1160+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 3LLU, 2LLU);
1161+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
1162+ }
1163+ {
1164+ uint64_t arg = /*c_________*/LOCAL_ACCESS_ADDR(heap.data, 3LLU, 1LLU);
1165+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
1166+ }
1167+ // ACCUMULATE ARGUMENTS - END
1168+ uint64_t return_to = 18446744073709551582LLU;
1169+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
1170+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
1171+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
1172+ heap.data[0].elem1 = heap.data[0].elem0;
1173+ heap.data[0].elem0 = restore;
1174+ state.addr = 661671490923528192LLU; // isspace___
1175+ break;
1176+ }
1177+ case 18446744073709551582LLU: // 999999999c'''''''''''''''
1178+ {
1179+ state.addr = *LOCAL_ACCESS(heap.data, 3LLU, 2LLU) ? 18446744073709551585LLU : 18446744073709551584LLU;
1180+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 3
1181+ break;
1182+ }
1183+ case 18446744073709551585LLU: // 999999999f'''''''''''''''
1184+ {
1185+ state.addr = 18446744073709551583LLU; // 999999999d'''''''''''''''
1186+ break;
1187+ }
1188+ case 18446744073709551584LLU: // 999999999e'''''''''''''''
1189+ {
1190+
1191+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 0LLU)) = /*c_________*/*LOCAL_ACCESS(heap.data, 2LLU, 1LLU);
1192+ ungetc(0, stdin);
1193+ state.addr = 18446744073709551583LLU; // 999999999d'''''''''''''''
1194+ break;
1195+ }
1196+ case 18446744073709551583LLU: // 999999999d'''''''''''''''
1197+ {
1198+ state.addr = 18446744073709551587LLU; // 999999999h'''''''''''''''
1199+ break;
1200+ }
1201+ case 18446744073709551586LLU: // 999999999g'''''''''''''''
1202+ {
1203+ // variable u64 c_________ goes out of scope
1204+ // emitted destructur for type u64
1205+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference c_________ at 2
1206+ state.addr = 18446744073709551589LLU; // 999999999j'''''''''''''''
1207+ break;
1208+ }
1209+ case 18446744073709551589LLU: // 999999999j'''''''''''''''
1210+ {
1211+ // parameter-reference u64 lookahead_ goes out of scope
1212+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference lookahead_ at 1
1213+ {
1214+ uint64_t baseinfo = heap.data[0].elem1;
1215+ struct pair pair = unpair(&heap, &baseinfo);
1216+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
1217+ state.addr = pair.elem1;
1218+ }
1219+ break;
1220+ }
1221+ case 242277287585575139LLU: // MatchOptCh
1222+ {
1223+ {
1224+ uint64_t arg = 0;
1225+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1226+ }
1227+ *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));
1228+ state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551581LLU : 18446744073709551580LLU;
1229+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
1230+ break;
1231+ }
1232+ case 18446744073709551581LLU: // 999999999b'''''''''''''''
1233+ {
1234+
1235+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 2LLU)) = (uint64_t)getchar();
1236+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU)) = 1LLU;
1237+ state.addr = 18446744073709551579LLU; // 999999999$'''''''''''''''
1238+ break;
1239+ }
1240+ case 18446744073709551580LLU: // 999999999a'''''''''''''''
1241+ {
1242+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU)) = 0LLU;
1243+ state.addr = 18446744073709551579LLU; // 999999999$'''''''''''''''
1244+ break;
1245+ }
1246+ case 18446744073709551579LLU: // 999999999$'''''''''''''''
1247+ {
1248+ // parameter-reference u64 lookahead_ goes out of scope
1249+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference lookahead_ at 3
1250+ // parameter-reference u64 expected__ goes out of scope
1251+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference expected__ at 2
1252+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
1253+ {
1254+ uint64_t baseinfo = heap.data[0].elem1;
1255+ struct pair pair = unpair(&heap, &baseinfo);
1256+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
1257+ state.addr = pair.elem1;
1258+ }
1259+ break;
1260+ }
1261+ case 891913148528723755LLU: // verifyheap
1262+ {
1263+ fprintf(stdout, "%s", "\n uint64_t node = heap.freelist;");
1264+ fprintf(stdout, "%s", "\n for(uint64_t count = 0; count < ");
1265+ // ACCUMULATE ARGUMENTS - BEGIN
1266+ {
1267+ uint64_t arg = /*heapsize__*/*LOCAL_ACCESS(heap.data, 1LLU, 0LLU);
1268+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
1269+ }
1270+ // ACCUMULATE ARGUMENTS - END
1271+ uint64_t return_to = 18446744073709551578LLU;
1272+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
1273+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
1274+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
1275+ heap.data[0].elem1 = heap.data[0].elem0;
1276+ heap.data[0].elem0 = restore;
1277+ state.addr = 787446708198178816LLU; // printnr___
1278+ break;
1279+ }
1280+ case 18446744073709551578LLU: // 999999999Z'''''''''''''''
1281+ {
1282+ fprintf(stdout, "%s", "; count++)");
1283+ fprintf(stdout, "%s", "\n {");
1284+ fprintf(stdout, "%s", "\n if(0 == node)");
1285+ fprintf(stdout, "%s", "\n {");
1286+ fprintf(stdout, "%s", "\n for(uint64_t i = ");
1287+ // ACCUMULATE ARGUMENTS - BEGIN
1288+ {
1289+ uint64_t arg = /*heapsize__*/*LOCAL_ACCESS(heap.data, 1LLU, 0LLU);
1290+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
1291+ }
1292+ // ACCUMULATE ARGUMENTS - END
1293+ uint64_t return_to = 18446744073709551577LLU;
1294+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
1295+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
1296+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
1297+ heap.data[0].elem1 = heap.data[0].elem0;
1298+ heap.data[0].elem0 = restore;
1299+ state.addr = 787446708198178816LLU; // printnr___
1300+ break;
1301+ }
1302+ case 18446744073709551577LLU: // 999999999Y'''''''''''''''
1303+ {
1304+ fprintf(stdout, "%s", "; i > 0; i--)");
1305+ fprintf(stdout, "%s", "\n {");
1306+ 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);");
1307+ fprintf(stdout, "%s", "\n }");
1308+ fprintf(stdout, "%s", "\n fprintf(stderr, \"FREE-LIST TRUNCATED (memory-leak?): zero-entry at length %llu\\n\", (unsigned long long)count);");
1309+ fprintf(stdout, "%s", "\n exit(-1);");
1310+ fprintf(stdout, "%s", "\n }");
1311+ fprintf(stdout, "%s", "\n node = heap.data[node].elem0;");
1312+ fprintf(stdout, "%s", "\n if(node > ");
1313+ // ACCUMULATE ARGUMENTS - BEGIN
1314+ {
1315+ uint64_t arg = /*heapsize__*/*LOCAL_ACCESS(heap.data, 1LLU, 0LLU);
1316+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
1317+ }
1318+ // ACCUMULATE ARGUMENTS - END
1319+ uint64_t return_to = 18446744073709551576LLU;
1320+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
1321+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
1322+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
1323+ heap.data[0].elem1 = heap.data[0].elem0;
1324+ heap.data[0].elem0 = restore;
1325+ state.addr = 787446708198178816LLU; // printnr___
1326+ break;
1327+ }
1328+ case 18446744073709551576LLU: // 999999999X'''''''''''''''
1329+ {
1330+ fprintf(stdout, "%s", ")");
1331+ fprintf(stdout, "%s", "\n {");
1332+ fprintf(stdout, "%s", "\n for(uint64_t i = ");
1333+ // ACCUMULATE ARGUMENTS - BEGIN
1334+ {
1335+ uint64_t arg = /*heapsize__*/*LOCAL_ACCESS(heap.data, 1LLU, 0LLU);
1336+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
1337+ }
1338+ // ACCUMULATE ARGUMENTS - END
1339+ uint64_t return_to = 18446744073709551575LLU;
1340+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
1341+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
1342+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
1343+ heap.data[0].elem1 = heap.data[0].elem0;
1344+ heap.data[0].elem0 = restore;
1345+ state.addr = 787446708198178816LLU; // printnr___
1346+ break;
1347+ }
1348+ case 18446744073709551575LLU: // 999999999W'''''''''''''''
1349+ {
1350+ fprintf(stdout, "%s", "; i > 0; i--)");
1351+ fprintf(stdout, "%s", "\n {");
1352+ 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);");
1353+ fprintf(stdout, "%s", "\n }");
1354+ fprintf(stdout, "%s", "\n fprintf(stderr, \"FREE-LIST CORRUPTED: entry %llu at length %llu exceeds bounds ");
1355+ fprintf(stdout, "%llu", (unsigned long long)/*heapsize__*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
1356+ fprintf(stdout, "%s", "\\n\", (unsigned long long)node, (unsigned long long)count);");
1357+ fprintf(stdout, "%s", "\n exit(-1);");
1358+ fprintf(stdout, "%s", "\n }");
1359+ fprintf(stdout, "%s", "\n }");
1360+ fprintf(stdout, "%s", "\n if(node)");
1361+ fprintf(stdout, "%s", "\n {");
1362+ fprintf(stdout, "%s", "\n for(uint64_t i = ");
1363+ // ACCUMULATE ARGUMENTS - BEGIN
1364+ {
1365+ uint64_t arg = /*heapsize__*/*LOCAL_ACCESS(heap.data, 1LLU, 0LLU);
1366+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
1367+ }
1368+ // ACCUMULATE ARGUMENTS - END
1369+ uint64_t return_to = 18446744073709551574LLU;
1370+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
1371+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
1372+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
1373+ heap.data[0].elem1 = heap.data[0].elem0;
1374+ heap.data[0].elem0 = restore;
1375+ state.addr = 787446708198178816LLU; // printnr___
1376+ break;
1377+ }
1378+ case 18446744073709551574LLU: // 999999999V'''''''''''''''
1379+ {
1380+ fprintf(stdout, "%s", "; i > 0; i--)");
1381+ fprintf(stdout, "%s", "\n {");
1382+ 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);");
1383+ fprintf(stdout, "%s", "\n }");
1384+ fprintf(stdout, "%s", "\n fprintf(stderr, \"FREE-LIST CIRCULAR\\n\");");
1385+ fprintf(stdout, "%s", "\n exit(-1);");
1386+ fprintf(stdout, "%s", "\n }");
1387+ fprintf(stdout, "%s", "\n");
1388+ // parameter-reference u64 heapsize__ goes out of scope
1389+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference heapsize__ at 1
1390+ {
1391+ uint64_t baseinfo = heap.data[0].elem1;
1392+ struct pair pair = unpair(&heap, &baseinfo);
1393+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
1394+ state.addr = pair.elem1;
1395+ }
1396+ break;
1397+ }
1398+ case 18446744073709551572LLU: // 999999999T'''''''''''''''
1399+ {
1400+ // destructor for variant typelist__
1401+ {
1402+ uint64_t arg = tree_pop_move(&heap, 1LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
1403+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1404+ }
1405+ // emitted destructur for type u64
1406+ // RELEASE temporary destructor-variable
1407+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
1408+ // RELEASE destructor-argument
1409+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 1
1410+ {
1411+ uint64_t baseinfo = heap.data[0].elem1;
1412+ struct pair pair = unpair(&heap, &baseinfo);
1413+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
1414+ state.addr = pair.elem1;
1415+ }
1416+ break;
1417+ }
1418+ case 18446744073709551571LLU: // 999999999S'''''''''''''''
1419+ {
1420+ // destructor for variant typename__
1421+ {
1422+ uint64_t arg = tree_pop_move(&heap, 1LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
1423+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1424+ }
1425+ // emitted destructur for type u64
1426+ // RELEASE temporary destructor-variable
1427+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
1428+ // RELEASE destructor-argument
1429+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 1
1430+ {
1431+ uint64_t baseinfo = heap.data[0].elem1;
1432+ struct pair pair = unpair(&heap, &baseinfo);
1433+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
1434+ state.addr = pair.elem1;
1435+ }
1436+ break;
1437+ }
1438+ case 18446744073709551570LLU: // 999999999R'''''''''''''''
1439+ {
1440+ // destructor for variant typeu64___
1441+ // RELEASE destructor-argument
1442+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 1
1443+ {
1444+ uint64_t baseinfo = heap.data[0].elem1;
1445+ struct pair pair = unpair(&heap, &baseinfo);
1446+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
1447+ state.addr = pair.elem1;
1448+ }
1449+ break;
1450+ }
1451+ case 18446744073709551573LLU: // 999999999U'''''''''''''''
1452+ {
1453+ struct pair type_data = unpair(&heap, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
1454+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)) = type_data.elem1;
1455+ state.addr = 18446744073709551570LLU + type_data.elem0;
1456+ break;
1457+ }
1458+ case 861504786250002432LLU: // typelist__
1459+ {
1460+ // union-constructor typelist__
1461+ {
1462+ uint64_t result_tuple = 0;
1463+ // copy references
1464+ {
1465+ uint64_t elem = *LOCAL_ACCESS(heap.data, 1LLU + 1, 0LLU + 1);
1466+ tree_push_move(&heap, 0LLU, &result_tuple, &elem);
1467+ }
1468+ // release parameters
1469+ {
1470+ (void)LOCAL_POP_MOVE(&heap, 1LLU + 1, &(heap.data[0].elem1)/*memory root*/);
1471+ }
1472+ {
1473+ uint64_t constridx = 2LLU;
1474+ uint64_t root = pair_move(&heap, &constridx, &result_tuple);
1475+ *access_heap(heap.data, LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*memory root*/)) = root;
1476+ }
1477+ }
1478+ {
1479+ uint64_t baseinfo = heap.data[0].elem1;
1480+ struct pair pair = unpair(&heap, &baseinfo);
1481+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
1482+ state.addr = pair.elem1;
1483+ }
1484+ break;
1485+ }
1486+ case 861504788261634048LLU: // typename__
1487+ {
1488+ // union-constructor typename__
1489+ {
1490+ uint64_t result_tuple = 0;
1491+ // copy references
1492+ {
1493+ uint64_t elem = *LOCAL_ACCESS(heap.data, 1LLU + 1, 0LLU + 1);
1494+ tree_push_move(&heap, 0LLU, &result_tuple, &elem);
1495+ }
1496+ // release parameters
1497+ {
1498+ (void)LOCAL_POP_MOVE(&heap, 1LLU + 1, &(heap.data[0].elem1)/*memory root*/);
1499+ }
1500+ {
1501+ uint64_t constridx = 1LLU;
1502+ uint64_t root = pair_move(&heap, &constridx, &result_tuple);
1503+ *access_heap(heap.data, LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*memory root*/)) = root;
1504+ }
1505+ }
1506+ {
1507+ uint64_t baseinfo = heap.data[0].elem1;
1508+ struct pair pair = unpair(&heap, &baseinfo);
1509+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
1510+ state.addr = pair.elem1;
1511+ }
1512+ break;
1513+ }
1514+ case 861504796319285248LLU: // typeu64___
1515+ {
1516+ // union-constructor typeu64___
1517+ {
1518+ uint64_t result_tuple = 0;
1519+ // copy references
1520+ // release parameters
1521+ {
1522+ uint64_t constridx = 0LLU;
1523+ uint64_t root = pair_move(&heap, &constridx, &result_tuple);
1524+ *access_heap(heap.data, LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*memory root*/)) = root;
1525+ }
1526+ }
1527+ {
1528+ uint64_t baseinfo = heap.data[0].elem1;
1529+ struct pair pair = unpair(&heap, &baseinfo);
1530+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
1531+ state.addr = pair.elem1;
1532+ }
1533+ break;
1534+ }
1535+ case 589060043891015680LLU: // equtype___
1536+ {
1537+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU))].elem0 != 0/*typeu64___*/)
1538+ {
1539+ state.addr = 18446744073709551569LLU; // 999999999Q'''''''''''''''
1540+ break;
1541+ }
1542+ {
1543+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 1LLU);
1544+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1545+ }
1546+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU))].elem0 != 0/*typeu64___*/)
1547+ {
1548+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
1549+ state.addr = 18446744073709551569LLU; // 999999999Q'''''''''''''''
1550+ break;
1551+ }
1552+ {
1553+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU), 1LLU);
1554+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1555+ }
1556+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 0LLU)) = 1LLU;
1557+ // parameter-reference type______ __________ goes out of scope
1558+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 5
1559+ // parameter type______ __________ goes out of scope
1560+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 4
1561+ // parameter-reference type______ __________ goes out of scope
1562+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3
1563+ // parameter type______ __________ goes out of scope
1564+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
1565+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
1566+ {
1567+ uint64_t baseinfo = heap.data[0].elem1;
1568+ struct pair pair = unpair(&heap, &baseinfo);
1569+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
1570+ state.addr = pair.elem1;
1571+ }
1572+ break;
1573+ }
1574+ case 18446744073709551569LLU: // 999999999Q'''''''''''''''
1575+ {
1576+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU))].elem0 != 1/*typename__*/)
1577+ {
1578+ state.addr = 18446744073709551568LLU; // 999999999P'''''''''''''''
1579+ break;
1580+ }
1581+ {
1582+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 1LLU);
1583+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1584+ }
1585+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU))].elem0 != 0/*typeu64___*/)
1586+ {
1587+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
1588+ state.addr = 18446744073709551568LLU; // 999999999P'''''''''''''''
1589+ break;
1590+ }
1591+ {
1592+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU), 1LLU);
1593+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1594+ }
1595+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 0LLU)) = 0LLU;
1596+ // parameter-reference type______ __________ goes out of scope
1597+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 5
1598+ // parameter type______ __________ goes out of scope
1599+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 4
1600+ // parameter-reference type______ __________ goes out of scope
1601+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3
1602+ // parameter type______ __________ goes out of scope
1603+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
1604+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
1605+ {
1606+ uint64_t baseinfo = heap.data[0].elem1;
1607+ struct pair pair = unpair(&heap, &baseinfo);
1608+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
1609+ state.addr = pair.elem1;
1610+ }
1611+ break;
1612+ }
1613+ case 18446744073709551568LLU: // 999999999P'''''''''''''''
1614+ {
1615+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU))].elem0 != 2/*typelist__*/)
1616+ {
1617+ state.addr = 18446744073709551567LLU; // 999999999O'''''''''''''''
1618+ break;
1619+ }
1620+ {
1621+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 1LLU);
1622+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1623+ }
1624+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU))].elem0 != 0/*typeu64___*/)
1625+ {
1626+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
1627+ state.addr = 18446744073709551567LLU; // 999999999O'''''''''''''''
1628+ break;
1629+ }
1630+ {
1631+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU), 1LLU);
1632+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1633+ }
1634+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 0LLU)) = 0LLU;
1635+ // parameter-reference type______ __________ goes out of scope
1636+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 5
1637+ // parameter type______ __________ goes out of scope
1638+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 4
1639+ // parameter-reference type______ __________ goes out of scope
1640+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3
1641+ // parameter type______ __________ goes out of scope
1642+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
1643+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
1644+ {
1645+ uint64_t baseinfo = heap.data[0].elem1;
1646+ struct pair pair = unpair(&heap, &baseinfo);
1647+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
1648+ state.addr = pair.elem1;
1649+ }
1650+ break;
1651+ }
1652+ case 18446744073709551567LLU: // 999999999O'''''''''''''''
1653+ {
1654+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU))].elem0 != 0/*typeu64___*/)
1655+ {
1656+ state.addr = 18446744073709551566LLU; // 999999999N'''''''''''''''
1657+ break;
1658+ }
1659+ {
1660+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 1LLU);
1661+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1662+ }
1663+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU))].elem0 != 1/*typename__*/)
1664+ {
1665+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
1666+ state.addr = 18446744073709551566LLU; // 999999999N'''''''''''''''
1667+ break;
1668+ }
1669+ {
1670+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU), 1LLU);
1671+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1672+ }
1673+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 0LLU)) = 0LLU;
1674+ // parameter-reference type______ __________ goes out of scope
1675+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 5
1676+ // parameter type______ __________ goes out of scope
1677+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 4
1678+ // parameter-reference type______ __________ goes out of scope
1679+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3
1680+ // parameter type______ __________ goes out of scope
1681+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
1682+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
1683+ {
1684+ uint64_t baseinfo = heap.data[0].elem1;
1685+ struct pair pair = unpair(&heap, &baseinfo);
1686+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
1687+ state.addr = pair.elem1;
1688+ }
1689+ break;
1690+ }
1691+ case 18446744073709551566LLU: // 999999999N'''''''''''''''
1692+ {
1693+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU))].elem0 != 1/*typename__*/)
1694+ {
1695+ state.addr = 18446744073709551565LLU; // 999999999M'''''''''''''''
1696+ break;
1697+ }
1698+ {
1699+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 1LLU);
1700+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1701+ }
1702+ {
1703+ uint64_t arg = tree_elem_addr(heap.data, 1LLU, *LOCAL_ACCESS(heap.data, 4LLU, 3LLU), 0LLU);
1704+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1705+ }
1706+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 2LLU))].elem0 != 1/*typename__*/)
1707+ {
1708+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 5
1709+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
1710+ state.addr = 18446744073709551565LLU; // 999999999M'''''''''''''''
1711+ break;
1712+ }
1713+ {
1714+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 5LLU, 2LLU), 1LLU);
1715+ LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1716+ }
1717+ {
1718+ uint64_t arg = tree_elem_addr(heap.data, 1LLU, *LOCAL_ACCESS(heap.data, 6LLU, 5LLU), 0LLU);
1719+ LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1720+ }
1721+ *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));
1722+ // parameter-reference u64 y_________ goes out of scope
1723+ (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference y_________ at 7
1724+ // parameter-reference type______ __________ goes out of scope
1725+ (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 6
1726+ // parameter type______ __________ goes out of scope
1727+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 5
1728+ // parameter-reference u64 x_________ goes out of scope
1729+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference x_________ at 4
1730+ // parameter-reference type______ __________ goes out of scope
1731+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3
1732+ // parameter type______ __________ goes out of scope
1733+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
1734+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
1735+ {
1736+ uint64_t baseinfo = heap.data[0].elem1;
1737+ struct pair pair = unpair(&heap, &baseinfo);
1738+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
1739+ state.addr = pair.elem1;
1740+ }
1741+ break;
1742+ }
1743+ case 18446744073709551565LLU: // 999999999M'''''''''''''''
1744+ {
1745+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU))].elem0 != 2/*typelist__*/)
1746+ {
1747+ state.addr = 18446744073709551564LLU; // 999999999L'''''''''''''''
1748+ break;
1749+ }
1750+ {
1751+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 1LLU);
1752+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1753+ }
1754+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU))].elem0 != 1/*typename__*/)
1755+ {
1756+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
1757+ state.addr = 18446744073709551564LLU; // 999999999L'''''''''''''''
1758+ break;
1759+ }
1760+ {
1761+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU), 1LLU);
1762+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1763+ }
1764+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 0LLU)) = 0LLU;
1765+ // parameter-reference type______ __________ goes out of scope
1766+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 5
1767+ // parameter type______ __________ goes out of scope
1768+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 4
1769+ // parameter-reference type______ __________ goes out of scope
1770+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3
1771+ // parameter type______ __________ goes out of scope
1772+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
1773+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
1774+ {
1775+ uint64_t baseinfo = heap.data[0].elem1;
1776+ struct pair pair = unpair(&heap, &baseinfo);
1777+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
1778+ state.addr = pair.elem1;
1779+ }
1780+ break;
1781+ }
1782+ case 18446744073709551564LLU: // 999999999L'''''''''''''''
1783+ {
1784+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU))].elem0 != 0/*typeu64___*/)
1785+ {
1786+ state.addr = 18446744073709551563LLU; // 999999999K'''''''''''''''
1787+ break;
1788+ }
1789+ {
1790+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 1LLU);
1791+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1792+ }
1793+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU))].elem0 != 2/*typelist__*/)
1794+ {
1795+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
1796+ state.addr = 18446744073709551563LLU; // 999999999K'''''''''''''''
1797+ break;
1798+ }
1799+ {
1800+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU), 1LLU);
1801+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1802+ }
1803+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 0LLU)) = 0LLU;
1804+ // parameter-reference type______ __________ goes out of scope
1805+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 5
1806+ // parameter type______ __________ goes out of scope
1807+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 4
1808+ // parameter-reference type______ __________ goes out of scope
1809+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3
1810+ // parameter type______ __________ goes out of scope
1811+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
1812+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
1813+ {
1814+ uint64_t baseinfo = heap.data[0].elem1;
1815+ struct pair pair = unpair(&heap, &baseinfo);
1816+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
1817+ state.addr = pair.elem1;
1818+ }
1819+ break;
1820+ }
1821+ case 18446744073709551563LLU: // 999999999K'''''''''''''''
1822+ {
1823+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU))].elem0 != 1/*typename__*/)
1824+ {
1825+ state.addr = 18446744073709551562LLU; // 999999999J'''''''''''''''
1826+ break;
1827+ }
1828+ {
1829+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 1LLU);
1830+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1831+ }
1832+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU))].elem0 != 2/*typelist__*/)
1833+ {
1834+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
1835+ state.addr = 18446744073709551562LLU; // 999999999J'''''''''''''''
1836+ break;
1837+ }
1838+ {
1839+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU), 1LLU);
1840+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1841+ }
1842+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 0LLU)) = 0LLU;
1843+ // parameter-reference type______ __________ goes out of scope
1844+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 5
1845+ // parameter type______ __________ goes out of scope
1846+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 4
1847+ // parameter-reference type______ __________ goes out of scope
1848+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3
1849+ // parameter type______ __________ goes out of scope
1850+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
1851+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
1852+ {
1853+ uint64_t baseinfo = heap.data[0].elem1;
1854+ struct pair pair = unpair(&heap, &baseinfo);
1855+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
1856+ state.addr = pair.elem1;
1857+ }
1858+ break;
1859+ }
1860+ case 18446744073709551562LLU: // 999999999J'''''''''''''''
1861+ {
1862+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU))].elem0 != 2/*typelist__*/)
1863+ {
1864+ state.addr = 18446744073709551561LLU; // 999999999I'''''''''''''''
1865+ break;
1866+ }
1867+ {
1868+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 1LLU);
1869+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1870+ }
1871+ {
1872+ uint64_t arg = tree_elem_addr(heap.data, 1LLU, *LOCAL_ACCESS(heap.data, 4LLU, 3LLU), 0LLU);
1873+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1874+ }
1875+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 2LLU))].elem0 != 2/*typelist__*/)
1876+ {
1877+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 5
1878+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
1879+ state.addr = 18446744073709551561LLU; // 999999999I'''''''''''''''
1880+ break;
1881+ }
1882+ {
1883+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 5LLU, 2LLU), 1LLU);
1884+ LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1885+ }
1886+ {
1887+ uint64_t arg = tree_elem_addr(heap.data, 1LLU, *LOCAL_ACCESS(heap.data, 6LLU, 5LLU), 0LLU);
1888+ LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1889+ }
1890+ *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));
1891+ // parameter-reference u64 y_________ goes out of scope
1892+ (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference y_________ at 7
1893+ // parameter-reference type______ __________ goes out of scope
1894+ (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 6
1895+ // parameter type______ __________ goes out of scope
1896+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 5
1897+ // parameter-reference u64 x_________ goes out of scope
1898+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference x_________ at 4
1899+ // parameter-reference type______ __________ goes out of scope
1900+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3
1901+ // parameter type______ __________ goes out of scope
1902+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
1903+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
1904+ {
1905+ uint64_t baseinfo = heap.data[0].elem1;
1906+ struct pair pair = unpair(&heap, &baseinfo);
1907+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
1908+ state.addr = pair.elem1;
1909+ }
1910+ break;
1911+ }
1912+ case 18446744073709551561LLU: // 999999999I'''''''''''''''
1913+ {
1914+ fprintf(stderr, "INTERNAL COMPILER ERROR: missing pattern-match-case in definition of equtype___\n");
1915+ exit(-1);
1916+ break;
1917+ }
1918+ case 861504783110041600LLU: // typeinit__
1919+ {
1920+ if(*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU)) != 881834713755418624)
1921+ {
1922+ state.addr = 18446744073709551560LLU; // 999999999H'''''''''''''''
1923+ break;
1924+ }
1925+ // ACCUMULATE ARGUMENTS - BEGIN
1926+ {
1927+ uint64_t arg = *LOCAL_ACCESS(heap.data, 3LLU, 0LLU);
1928+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
1929+ }
1930+ // ACCUMULATE ARGUMENTS - END
1931+ uint64_t return_to = 18446744073709551559LLU;
1932+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
1933+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
1934+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
1935+ heap.data[0].elem1 = heap.data[0].elem0;
1936+ heap.data[0].elem0 = restore;
1937+ state.addr = 861504796319285248LLU; // typeu64___
1938+ break;
1939+ }
1940+ case 18446744073709551559LLU: // 999999999G'''''''''''''''
1941+ {
1942+ // parameter-reference u64 subtype___ goes out of scope
1943+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference subtype___ at 3
1944+ // parameter-reference u64 __________ goes out of scope
1945+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
1946+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
1947+ {
1948+ uint64_t baseinfo = heap.data[0].elem1;
1949+ struct pair pair = unpair(&heap, &baseinfo);
1950+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
1951+ state.addr = pair.elem1;
1952+ }
1953+ break;
1954+ }
1955+ case 18446744073709551560LLU: // 999999999H'''''''''''''''
1956+ {
1957+ if(*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU)) != 712900180986298368)
1958+ {
1959+ state.addr = 18446744073709551558LLU; // 999999999F'''''''''''''''
1960+ break;
1961+ }
1962+ {
1963+ uint64_t arg = 0;
1964+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1965+ }
1966+ *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /*subtype___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU));
1967+ // ACCUMULATE ARGUMENTS - BEGIN
1968+ {
1969+ uint64_t arg = *LOCAL_ACCESS(heap.data, 4LLU, 0LLU);
1970+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
1971+ }
1972+ {
1973+ uint64_t arg = /*subtype___*/*LOCAL_ACCESS(heap.data, 4LLU, 3LLU);
1974+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
1975+ }
1976+ // ACCUMULATE ARGUMENTS - END
1977+ uint64_t return_to = 18446744073709551557LLU;
1978+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
1979+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
1980+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
1981+ heap.data[0].elem1 = heap.data[0].elem0;
1982+ heap.data[0].elem0 = restore;
1983+ state.addr = 861504786250002432LLU; // typelist__
1984+ break;
1985+ }
1986+ case 18446744073709551557LLU: // 999999999E'''''''''''''''
1987+ {
1988+ // variable u64 subtype___ goes out of scope
1989+ // (uninitialized -> no destructor-call)
1990+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference subtype___ at 4
1991+ // parameter-reference u64 subtype___ goes out of scope
1992+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference subtype___ at 3
1993+ // parameter-reference u64 __________ goes out of scope
1994+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
1995+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
1996+ {
1997+ uint64_t baseinfo = heap.data[0].elem1;
1998+ struct pair pair = unpair(&heap, &baseinfo);
1999+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
2000+ state.addr = pair.elem1;
2001+ }
2002+ break;
2003+ }
2004+ case 18446744073709551558LLU: // 999999999F'''''''''''''''
2005+ {
2006+ {
2007+ uint64_t arg = 0;
2008+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2009+ }
2010+ *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /*subtype___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU));
2011+ state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551555LLU : 18446744073709551554LLU;
2012+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
2013+ break;
2014+ }
2015+ case 18446744073709551555LLU: // 999999999C'''''''''''''''
2016+ {
2017+ fprintf(stderr, "%s", "typeinit: struct/union ");
2018+ printid(stderr, /*maintype__*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU)));
2019+ fprintf(stderr, "%s", " must not have subtype but found ");
2020+ printid(stderr, /*subtype___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 2LLU)));
2021+ state.addr = 18446744073709551554LLU; // 999999999B'''''''''''''''
2022+ break;
2023+ }
2024+ case 18446744073709551554LLU: // 999999999B'''''''''''''''
2025+ {
2026+ {
2027+ uint64_t arg = 0;
2028+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2029+ }
2030+ *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /*maintype__*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 1LLU));
2031+ // ACCUMULATE ARGUMENTS - BEGIN
2032+ {
2033+ uint64_t arg = *LOCAL_ACCESS(heap.data, 4LLU, 0LLU);
2034+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
2035+ }
2036+ {
2037+ uint64_t arg = /*maintype__*/*LOCAL_ACCESS(heap.data, 4LLU, 3LLU);
2038+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
2039+ }
2040+ // ACCUMULATE ARGUMENTS - END
2041+ uint64_t return_to = 18446744073709551553LLU;
2042+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
2043+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
2044+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
2045+ heap.data[0].elem1 = heap.data[0].elem0;
2046+ heap.data[0].elem0 = restore;
2047+ state.addr = 861504788261634048LLU; // typename__
2048+ break;
2049+ }
2050+ case 18446744073709551553LLU: // 999999999A'''''''''''''''
2051+ {
2052+ // variable u64 maintype__ goes out of scope
2053+ // (uninitialized -> no destructor-call)
2054+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference maintype__ at 4
2055+ // parameter-reference u64 subtype___ goes out of scope
2056+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference subtype___ at 3
2057+ // parameter-reference u64 maintype__ goes out of scope
2058+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference maintype__ at 2
2059+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
2060+ {
2061+ uint64_t baseinfo = heap.data[0].elem1;
2062+ struct pair pair = unpair(&heap, &baseinfo);
2063+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
2064+ state.addr = pair.elem1;
2065+ }
2066+ break;
2067+ }
2068+ case 367395560426147840LLU: // TYPECOPY__
2069+ {
2070+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 != 0/*typeu64___*/)
2071+ {
2072+ state.addr = 18446744073709551552LLU; // 999999999_'''''''''''''''
2073+ break;
2074+ }
2075+ {
2076+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU), 1LLU);
2077+ LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2078+ }
2079+ // ACCUMULATE ARGUMENTS - BEGIN
2080+ {
2081+ uint64_t arg = *LOCAL_ACCESS(heap.data, 3LLU, 0LLU);
2082+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
2083+ }
2084+ // ACCUMULATE ARGUMENTS - END
2085+ uint64_t return_to = 18446744073709551551LLU;
2086+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
2087+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
2088+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
2089+ heap.data[0].elem1 = heap.data[0].elem0;
2090+ heap.data[0].elem0 = restore;
2091+ state.addr = 861504796319285248LLU; // typeu64___
2092+ break;
2093+ }
2094+ case 18446744073709551551LLU: // 9999999989'''''''''''''''
2095+ {
2096+ // parameter-reference type______ __________ goes out of scope
2097+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3
2098+ // parameter type______ __________ goes out of scope
2099+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
2100+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
2101+ {
2102+ uint64_t baseinfo = heap.data[0].elem1;
2103+ struct pair pair = unpair(&heap, &baseinfo);
2104+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
2105+ state.addr = pair.elem1;
2106+ }
2107+ break;
2108+ }
2109+ case 18446744073709551552LLU: // 999999999_'''''''''''''''
2110+ {
2111+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 != 1/*typename__*/)
2112+ {
2113+ state.addr = 18446744073709551550LLU; // 9999999988'''''''''''''''
2114+ break;
2115+ }
2116+ {
2117+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU), 1LLU);
2118+ LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2119+ }
2120+ {
2121+ uint64_t arg = tree_elem_addr(heap.data, 1LLU, *LOCAL_ACCESS(heap.data, 3LLU, 2LLU), 0LLU);
2122+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2123+ }
2124+ {
2125+ uint64_t arg = 0;
2126+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2127+ }
2128+ *LOCAL_ACCESS(heap.data, 5LLU, 4LLU) = /*name______*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 3LLU));
2129+ // ACCUMULATE ARGUMENTS - BEGIN
2130+ {
2131+ uint64_t arg = *LOCAL_ACCESS(heap.data, 5LLU, 0LLU);
2132+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
2133+ }
2134+ {
2135+ uint64_t arg = /*tmp_______*/*LOCAL_ACCESS(heap.data, 5LLU, 4LLU);
2136+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
2137+ }
2138+ // ACCUMULATE ARGUMENTS - END
2139+ uint64_t return_to = 18446744073709551549LLU;
2140+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
2141+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
2142+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
2143+ heap.data[0].elem1 = heap.data[0].elem0;
2144+ heap.data[0].elem0 = restore;
2145+ state.addr = 861504788261634048LLU; // typename__
2146+ break;
2147+ }
2148+ case 18446744073709551549LLU: // 9999999987'''''''''''''''
2149+ {
2150+ // variable u64 tmp_______ goes out of scope
2151+ // (uninitialized -> no destructor-call)
2152+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference tmp_______ at 5
2153+ // parameter-reference u64 name______ goes out of scope
2154+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference name______ at 4
2155+ // parameter-reference type______ __________ goes out of scope
2156+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3
2157+ // parameter type______ __________ goes out of scope
2158+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
2159+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
2160+ {
2161+ uint64_t baseinfo = heap.data[0].elem1;
2162+ struct pair pair = unpair(&heap, &baseinfo);
2163+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
2164+ state.addr = pair.elem1;
2165+ }
2166+ break;
2167+ }
2168+ case 18446744073709551550LLU: // 9999999988'''''''''''''''
2169+ {
2170+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 != 2/*typelist__*/)
2171+ {
2172+ state.addr = 18446744073709551548LLU; // 9999999986'''''''''''''''
2173+ break;
2174+ }
2175+ {
2176+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU), 1LLU);
2177+ LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2178+ }
2179+ {
2180+ uint64_t arg = tree_elem_addr(heap.data, 1LLU, *LOCAL_ACCESS(heap.data, 3LLU, 2LLU), 0LLU);
2181+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2182+ }
2183+ {
2184+ uint64_t arg = 0;
2185+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2186+ }
2187+ *LOCAL_ACCESS(heap.data, 5LLU, 4LLU) = /*name______*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 3LLU));
2188+ // ACCUMULATE ARGUMENTS - BEGIN
2189+ {
2190+ uint64_t arg = *LOCAL_ACCESS(heap.data, 5LLU, 0LLU);
2191+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
2192+ }
2193+ {
2194+ uint64_t arg = /*tmp_______*/*LOCAL_ACCESS(heap.data, 5LLU, 4LLU);
2195+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
2196+ }
2197+ // ACCUMULATE ARGUMENTS - END
2198+ uint64_t return_to = 18446744073709551547LLU;
2199+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
2200+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
2201+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
2202+ heap.data[0].elem1 = heap.data[0].elem0;
2203+ heap.data[0].elem0 = restore;
2204+ state.addr = 861504786250002432LLU; // typelist__
2205+ break;
2206+ }
2207+ case 18446744073709551547LLU: // 9999999985'''''''''''''''
2208+ {
2209+ // variable u64 tmp_______ goes out of scope
2210+ // (uninitialized -> no destructor-call)
2211+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference tmp_______ at 5
2212+ // parameter-reference u64 name______ goes out of scope
2213+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference name______ at 4
2214+ // parameter-reference type______ __________ goes out of scope
2215+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3
2216+ // parameter type______ __________ goes out of scope
2217+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
2218+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
2219+ {
2220+ uint64_t baseinfo = heap.data[0].elem1;
2221+ struct pair pair = unpair(&heap, &baseinfo);
2222+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
2223+ state.addr = pair.elem1;
2224+ }
2225+ break;
2226+ }
2227+ case 18446744073709551548LLU: // 9999999986'''''''''''''''
2228+ {
2229+ fprintf(stderr, "INTERNAL COMPILER ERROR: missing pattern-match-case in definition of TYPECOPY__\n");
2230+ exit(-1);
2231+ break;
2232+ }
2233+ case 819847183518878432LLU: // reporttype
2234+ {
2235+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 0/*typeu64___*/)
2236+ {
2237+ state.addr = 18446744073709551546LLU; // 9999999984'''''''''''''''
2238+ break;
2239+ }
2240+ {
2241+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU), 1LLU);
2242+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2243+ }
2244+ fprintf(stderr, "%s", "u64");
2245+ // parameter-reference type______ __________ goes out of scope
2246+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
2247+ // parameter type______ __________ goes out of scope
2248+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
2249+ {
2250+ uint64_t baseinfo = heap.data[0].elem1;
2251+ struct pair pair = unpair(&heap, &baseinfo);
2252+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
2253+ state.addr = pair.elem1;
2254+ }
2255+ break;
2256+ }
2257+ case 18446744073709551546LLU: // 9999999984'''''''''''''''
2258+ {
2259+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 1/*typename__*/)
2260+ {
2261+ state.addr = 18446744073709551545LLU; // 9999999983'''''''''''''''
2262+ break;
2263+ }
2264+ {
2265+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU), 1LLU);
2266+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2267+ }
2268+ {
2269+ uint64_t arg = tree_elem_addr(heap.data, 1LLU, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU), 0LLU);
2270+ LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2271+ }
2272+ printid(stderr, /*maintype__*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 2LLU)));
2273+ // parameter-reference u64 maintype__ goes out of scope
2274+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference maintype__ at 3
2275+ // parameter-reference type______ __________ goes out of scope
2276+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
2277+ // parameter type______ __________ goes out of scope
2278+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
2279+ {
2280+ uint64_t baseinfo = heap.data[0].elem1;
2281+ struct pair pair = unpair(&heap, &baseinfo);
2282+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
2283+ state.addr = pair.elem1;
2284+ }
2285+ break;
2286+ }
2287+ case 18446744073709551545LLU: // 9999999983'''''''''''''''
2288+ {
2289+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 2/*typelist__*/)
2290+ {
2291+ state.addr = 18446744073709551544LLU; // 9999999982'''''''''''''''
2292+ break;
2293+ }
2294+ {
2295+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU), 1LLU);
2296+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2297+ }
2298+ {
2299+ uint64_t arg = tree_elem_addr(heap.data, 1LLU, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU), 0LLU);
2300+ LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2301+ }
2302+ {
2303+ uint64_t arg = 0;
2304+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2305+ }
2306+ *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /*subtype___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU));
2307+ state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551543LLU : 18446744073709551542LLU;
2308+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
2309+ break;
2310+ }
2311+ case 18446744073709551543LLU: // 9999999981'''''''''''''''
2312+ {
2313+ fprintf(stderr, "%s", "list<");
2314+ printid(stderr, /*subtype___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 2LLU)));
2315+ fprintf(stderr, "%s", ">");
2316+ state.addr = 18446744073709551541LLU; // 999999998z'''''''''''''''
2317+ break;
2318+ }
2319+ case 18446744073709551542LLU: // 9999999980'''''''''''''''
2320+ {
2321+ fprintf(stderr, "%s", "list<?>");
2322+ state.addr = 18446744073709551541LLU; // 999999998z'''''''''''''''
2323+ break;
2324+ }
2325+ case 18446744073709551541LLU: // 999999998z'''''''''''''''
2326+ {
2327+ // parameter-reference u64 subtype___ goes out of scope
2328+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference subtype___ at 3
2329+ // parameter-reference type______ __________ goes out of scope
2330+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
2331+ // parameter type______ __________ goes out of scope
2332+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
2333+ {
2334+ uint64_t baseinfo = heap.data[0].elem1;
2335+ struct pair pair = unpair(&heap, &baseinfo);
2336+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
2337+ state.addr = pair.elem1;
2338+ }
2339+ break;
2340+ }
2341+ case 18446744073709551544LLU: // 9999999982'''''''''''''''
2342+ {
2343+ fprintf(stderr, "INTERNAL COMPILER ERROR: missing pattern-match-case in definition of reporttype\n");
2344+ exit(-1);
2345+ break;
2346+ }
2347+ case 787446708300855296LLU: // printtype_
2348+ {
2349+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 0/*typeu64___*/)
2350+ {
2351+ state.addr = 18446744073709551540LLU; // 999999998y'''''''''''''''
2352+ break;
2353+ }
2354+ {
2355+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU), 1LLU);
2356+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2357+ }
2358+ fprintf(stdout, "%s", "u64");
2359+ // parameter-reference type______ __________ goes out of scope
2360+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
2361+ // parameter type______ __________ goes out of scope
2362+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
2363+ {
2364+ uint64_t baseinfo = heap.data[0].elem1;
2365+ struct pair pair = unpair(&heap, &baseinfo);
2366+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
2367+ state.addr = pair.elem1;
2368+ }
2369+ break;
2370+ }
2371+ case 18446744073709551540LLU: // 999999998y'''''''''''''''
2372+ {
2373+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 1/*typename__*/)
2374+ {
2375+ state.addr = 18446744073709551539LLU; // 999999998x'''''''''''''''
2376+ break;
2377+ }
2378+ {
2379+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU), 1LLU);
2380+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2381+ }
2382+ {
2383+ uint64_t arg = tree_elem_addr(heap.data, 1LLU, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU), 0LLU);
2384+ LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2385+ }
2386+ printid(stdout, /*maintype__*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 2LLU)));
2387+ // parameter-reference u64 maintype__ goes out of scope
2388+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference maintype__ at 3
2389+ // parameter-reference type______ __________ goes out of scope
2390+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
2391+ // parameter type______ __________ goes out of scope
2392+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
2393+ {
2394+ uint64_t baseinfo = heap.data[0].elem1;
2395+ struct pair pair = unpair(&heap, &baseinfo);
2396+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
2397+ state.addr = pair.elem1;
2398+ }
2399+ break;
2400+ }
2401+ case 18446744073709551539LLU: // 999999998x'''''''''''''''
2402+ {
2403+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 2/*typelist__*/)
2404+ {
2405+ state.addr = 18446744073709551538LLU; // 999999998w'''''''''''''''
2406+ break;
2407+ }
2408+ {
2409+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU), 1LLU);
2410+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2411+ }
2412+ {
2413+ uint64_t arg = tree_elem_addr(heap.data, 1LLU, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU), 0LLU);
2414+ LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2415+ }
2416+ {
2417+ uint64_t arg = 0;
2418+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2419+ }
2420+ *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /*subtype___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU));
2421+ state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551537LLU : 18446744073709551536LLU;
2422+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
2423+ break;
2424+ }
2425+ case 18446744073709551537LLU: // 999999998v'''''''''''''''
2426+ {
2427+ fprintf(stdout, "%s", "list<");
2428+ printid(stdout, /*subtype___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 2LLU)));
2429+ fprintf(stdout, "%s", ">");
2430+ state.addr = 18446744073709551535LLU; // 999999998t'''''''''''''''
2431+ break;
2432+ }
2433+ case 18446744073709551536LLU: // 999999998u'''''''''''''''
2434+ {
2435+ fprintf(stdout, "%s", "list<?>");
2436+ state.addr = 18446744073709551535LLU; // 999999998t'''''''''''''''
2437+ break;
2438+ }
2439+ case 18446744073709551535LLU: // 999999998t'''''''''''''''
2440+ {
2441+ // parameter-reference u64 subtype___ goes out of scope
2442+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference subtype___ at 3
2443+ // parameter-reference type______ __________ goes out of scope
2444+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
2445+ // parameter type______ __________ goes out of scope
2446+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
2447+ {
2448+ uint64_t baseinfo = heap.data[0].elem1;
2449+ struct pair pair = unpair(&heap, &baseinfo);
2450+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
2451+ state.addr = pair.elem1;
2452+ }
2453+ break;
2454+ }
2455+ case 18446744073709551538LLU: // 999999998w'''''''''''''''
2456+ {
2457+ fprintf(stderr, "INTERNAL COMPILER ERROR: missing pattern-match-case in definition of printtype_\n");
2458+ exit(-1);
2459+ break;
2460+ }
2461+ case 18446744073709551534LLU: // 999999998s'''''''''''''''
2462+ {
2463+ {
2464+ uint64_t arg = tree_pop_move(&heap, 3LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
2465+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2466+ }
2467+ // emitted destructur for type u64
2468+ // RELEASE temporary destructor-variable
2469+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
2470+ {
2471+ uint64_t arg = tree_pop_move(&heap, 2LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
2472+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2473+ }
2474+ // emitted destructur for type u64
2475+ // RELEASE temporary destructor-variable
2476+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
2477+ {
2478+ uint64_t arg = tree_pop_move(&heap, 1LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
2479+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2480+ }
2481+ // emitted destructur for type type______
2482+ // ACCUMULATE ARGUMENTS - BEGIN
2483+ {
2484+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 2LLU, 1LLU);
2485+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
2486+ }
2487+ // ACCUMULATE ARGUMENTS - END
2488+ uint64_t return_to = 18446744073709551533LLU;
2489+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
2490+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
2491+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
2492+ heap.data[0].elem1 = heap.data[0].elem0;
2493+ heap.data[0].elem0 = restore;
2494+ state.addr = 18446744073709551573LLU; // 999999999U'''''''''''''''
2495+ break;
2496+ }
2497+ case 18446744073709551533LLU: // 999999998r'''''''''''''''
2498+ {
2499+ // RELEASE temporary destructor-variable
2500+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
2501+ // RELEASE destructor-argument
2502+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 1
2503+ {
2504+ uint64_t baseinfo = heap.data[0].elem1;
2505+ struct pair pair = unpair(&heap, &baseinfo);
2506+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
2507+ state.addr = pair.elem1;
2508+ }
2509+ break;
2510+ }
2511+ case 819859607768530944LLU: // resdest___
2512+ {
2513+ // struct-constructor resdest___
2514+ {
2515+ uint64_t result_tuple = 0;
2516+ // copy references
2517+ {
2518+ uint64_t elem = *LOCAL_ACCESS(heap.data, 3LLU + 1, 0LLU + 1);
2519+ tree_push_move(&heap, 0LLU, &result_tuple, &elem);
2520+ }
2521+ {
2522+ uint64_t elem = *LOCAL_ACCESS(heap.data, 3LLU + 1, 1LLU + 1);
2523+ tree_push_move(&heap, 1LLU, &result_tuple, &elem);
2524+ }
2525+ {
2526+ uint64_t elem = *LOCAL_ACCESS(heap.data, 3LLU + 1, 2LLU + 1);
2527+ tree_push_move(&heap, 2LLU, &result_tuple, &elem);
2528+ }
2529+ // release parameters
2530+ {
2531+ (void)LOCAL_POP_MOVE(&heap, 3LLU + 1, &(heap.data[0].elem1)/*memory root*/);
2532+ }
2533+ {
2534+ (void)LOCAL_POP_MOVE(&heap, 2LLU + 1, &(heap.data[0].elem1)/*memory root*/);
2535+ }
2536+ {
2537+ (void)LOCAL_POP_MOVE(&heap, 1LLU + 1, &(heap.data[0].elem1)/*memory root*/);
2538+ }
2539+ *access_heap(heap.data, LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*memory root*/)) = result_tuple;
2540+ }
2541+ {
2542+ uint64_t baseinfo = heap.data[0].elem1;
2543+ struct pair pair = unpair(&heap, &baseinfo);
2544+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
2545+ state.addr = pair.elem1;
2546+ }
2547+ break;
2548+ }
2549+ case 589059885019168768LLU: // equres____
2550+ {
2551+
2552+ // ACCUMULATE ARGUMENTS - BEGIN
2553+ {
2554+ uint64_t arg = *LOCAL_ACCESS(heap.data, 3LLU, 0LLU);
2555+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
2556+ }
2557+ {
2558+ uint64_t arg = /*x_________*/tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 0LLU);
2559+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
2560+ }
2561+ {
2562+ uint64_t arg = /*y_________*/tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 3LLU, 2LLU), 0LLU);
2563+ LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
2564+ }
2565+ // ACCUMULATE ARGUMENTS - END
2566+ uint64_t return_to = 18446744073709551532LLU;
2567+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0));
2568+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
2569+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
2570+ heap.data[0].elem1 = heap.data[0].elem0;
2571+ heap.data[0].elem0 = restore;
2572+ state.addr = 589060043891015680LLU; // equtype___
2573+ break;
2574+ }
2575+ case 18446744073709551532LLU: // 999999998q'''''''''''''''
2576+ {
2577+ {
2578+ uint64_t arg = 0;
2579+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2580+ }
2581+ *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /*equal_____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU));
2582+ state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551531LLU : 18446744073709551530LLU;
2583+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
2584+ break;
2585+ }
2586+ case 18446744073709551531LLU: // 999999998p'''''''''''''''
2587+ {
2588+
2589+ *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));
2590+ {
2591+ uint64_t arg = 0;
2592+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2593+ }
2594+ *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /*equal_____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU));
2595+ state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551529LLU : 18446744073709551528LLU;
2596+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
2597+ break;
2598+ }
2599+ case 18446744073709551529LLU: // 999999998n'''''''''''''''
2600+ {
2601+
2602+ *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));
2603+ state.addr = 18446744073709551528LLU; // 999999998m'''''''''''''''
2604+ break;
2605+ }
2606+ case 18446744073709551528LLU: // 999999998m'''''''''''''''
2607+ {
2608+ state.addr = 18446744073709551530LLU; // 999999998o'''''''''''''''
2609+ break;
2610+ }
2611+ case 18446744073709551530LLU: // 999999998o'''''''''''''''
2612+ {
2613+ // parameter-reference resdest___ y_________ goes out of scope
2614+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference y_________ at 3
2615+ // parameter-reference resdest___ x_________ goes out of scope
2616+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference x_________ at 2
2617+ // parameter-reference u64 equal_____ goes out of scope
2618+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference equal_____ at 1
2619+ {
2620+ uint64_t baseinfo = heap.data[0].elem1;
2621+ struct pair pair = unpair(&heap, &baseinfo);
2622+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
2623+ state.addr = pair.elem1;
2624+ }
2625+ break;
2626+ }
2627+ case 333468934555566080LLU: // ResCopy___
2628+ {
2629+ {
2630+ uint64_t arg = tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU), 0LLU);
2631+ LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2632+ }
2633+ {
2634+ uint64_t arg = tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 1LLU);
2635+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2636+ }
2637+ {
2638+ uint64_t arg = tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 4LLU, 1LLU), 2LLU);
2639+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2640+ }
2641+ // ACCUMULATE ARGUMENTS - BEGIN
2642+ {
2643+ uint64_t arg = *LOCAL_ACCESS(heap.data, 5LLU, 0LLU);
2644+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
2645+ }
2646+ {
2647+ uint64_t arg = heap.data[0].elem0;
2648+ LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2649+ }
2650+ {
2651+ uint64_t arg = 0;
2652+ LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2653+ }
2654+ // ACCUMULATE ARGUMENTS - BEGIN
2655+ {
2656+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 7LLU, 6LLU);
2657+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
2658+ }
2659+ {
2660+ uint64_t arg = /*type______*/*LOCAL_ACCESS(heap.data, 7LLU, 2LLU);
2661+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
2662+ }
2663+ // ACCUMULATE ARGUMENTS - END
2664+ uint64_t return_to = 18446744073709551525LLU;
2665+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
2666+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
2667+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
2668+ heap.data[0].elem1 = heap.data[0].elem0;
2669+ heap.data[0].elem0 = restore;
2670+ state.addr = 367395560426147840LLU; // TYPECOPY__
2671+ break;
2672+ }
2673+ case 18446744073709551525LLU: // 999999998j'''''''''''''''
2674+ {
2675+ {
2676+ uint64_t exchange = LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 7*/;
2677+ heap.data[0].elem0 = LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 6*/;
2678+
2679+ {
2680+ uint64_t arg = exchange;
2681+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
2682+ }
2683+ }
2684+ {
2685+ uint64_t arg = heap.data[0].elem0;
2686+ LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2687+ }
2688+ {
2689+ uint64_t arg = 0;
2690+ LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2691+ }
2692+ // ACCUMULATE ARGUMENTS - BEGIN
2693+ {
2694+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 7LLU, 6LLU);
2695+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
2696+ }
2697+ {
2698+ uint64_t arg = /*idx_______*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 7LLU, 3LLU));
2699+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
2700+ }
2701+ // ACCUMULATE ARGUMENTS - END
2702+ uint64_t return_to = 18446744073709551524LLU;
2703+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
2704+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
2705+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
2706+ heap.data[0].elem1 = heap.data[0].elem0;
2707+ heap.data[0].elem0 = restore;
2708+ state.addr = 552446646280519680LLU; // copyu64___
2709+ break;
2710+ }
2711+ case 18446744073709551524LLU: // 999999998i'''''''''''''''
2712+ {
2713+ {
2714+ uint64_t exchange = LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 7*/;
2715+ heap.data[0].elem0 = LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 6*/;
2716+
2717+ {
2718+ uint64_t arg = exchange;
2719+ LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
2720+ }
2721+ }
2722+ {
2723+ uint64_t arg = heap.data[0].elem0;
2724+ LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2725+ }
2726+ {
2727+ uint64_t arg = 0;
2728+ LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2729+ }
2730+ // ACCUMULATE ARGUMENTS - BEGIN
2731+ {
2732+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 7LLU, 6LLU);
2733+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
2734+ }
2735+ {
2736+ uint64_t arg = /*reference_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 7LLU, 4LLU));
2737+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
2738+ }
2739+ // ACCUMULATE ARGUMENTS - END
2740+ uint64_t return_to = 18446744073709551523LLU;
2741+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
2742+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
2743+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
2744+ heap.data[0].elem1 = heap.data[0].elem0;
2745+ heap.data[0].elem0 = restore;
2746+ state.addr = 552446646280519680LLU; // copyu64___
2747+ break;
2748+ }
2749+ case 18446744073709551523LLU: // 999999998h'''''''''''''''
2750+ {
2751+ {
2752+ uint64_t exchange = LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 7*/;
2753+ heap.data[0].elem0 = LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 6*/;
2754+
2755+ {
2756+ uint64_t arg = exchange;
2757+ LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
2758+ }
2759+ }
2760+ // ACCUMULATE ARGUMENTS - END
2761+ uint64_t return_to = 18446744073709551526LLU;
2762+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
2763+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
2764+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
2765+ heap.data[0].elem1 = heap.data[0].elem0;
2766+ heap.data[0].elem0 = restore;
2767+ state.addr = 819859607768530944LLU; // resdest___
2768+ break;
2769+ }
2770+ case 18446744073709551526LLU: // 999999998k'''''''''''''''
2771+ {
2772+ // parameter-reference u64 reference_ goes out of scope
2773+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference reference_ at 5
2774+ // parameter-reference u64 idx_______ goes out of scope
2775+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference idx_______ at 4
2776+ // parameter-reference type______ type______ goes out of scope
2777+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type______ at 3
2778+ // parameter-reference resdest___ __________ goes out of scope
2779+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
2780+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
2781+ {
2782+ uint64_t baseinfo = heap.data[0].elem1;
2783+ struct pair pair = unpair(&heap, &baseinfo);
2784+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
2785+ state.addr = pair.elem1;
2786+ }
2787+ break;
2788+ }
2789+ case 325737967258195136LLU: // REPORTRES_
2790+ {
2791+ {
2792+ uint64_t arg = tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU), 0LLU);
2793+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2794+ }
2795+ {
2796+ uint64_t arg = tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 2LLU, 0LLU), 1LLU);
2797+ LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2798+ }
2799+ {
2800+ uint64_t arg = tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU), 2LLU);
2801+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2802+ }
2803+ // ACCUMULATE ARGUMENTS - BEGIN
2804+ {
2805+ uint64_t arg = /*type______*/*LOCAL_ACCESS(heap.data, 4LLU, 1LLU);
2806+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
2807+ }
2808+ // ACCUMULATE ARGUMENTS - END
2809+ uint64_t return_to = 18446744073709551521LLU;
2810+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
2811+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
2812+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
2813+ heap.data[0].elem1 = heap.data[0].elem0;
2814+ heap.data[0].elem0 = restore;
2815+ state.addr = 819847183518878432LLU; // reporttype
2816+ break;
2817+ }
2818+ case 18446744073709551521LLU: // 999999998f'''''''''''''''
2819+ {
2820+ fprintf(stderr, "%s", " ");
2821+ fprintf(stderr, "%s", "(");
2822+ fprintf(stderr, "%llu", (unsigned long long)/*index_____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU)));
2823+ fprintf(stderr, "%s", ")");
2824+ // parameter-reference u64 reference_ goes out of scope
2825+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference reference_ at 4
2826+ // parameter-reference u64 index_____ goes out of scope
2827+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference index_____ at 3
2828+ // parameter-reference type______ type______ goes out of scope
2829+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type______ at 2
2830+ // parameter-reference resdest___ __________ goes out of scope
2831+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
2832+ {
2833+ uint64_t baseinfo = heap.data[0].elem1;
2834+ struct pair pair = unpair(&heap, &baseinfo);
2835+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
2836+ state.addr = pair.elem1;
2837+ }
2838+ break;
2839+ }
2840+ case 325737967258195155LLU: // REPORTRESS
2841+ {
2842+ fprintf(stderr, "%s", "(");
2843+ {
2844+ uint64_t arg = 0;
2845+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2846+ }
2847+ *LOCAL_ACCESS(heap.data, 2LLU, 1LLU) = 1;
2848+ {
2849+ uint64_t arg = /*rs________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 0LLU));
2850+ LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2851+ }
2852+ {
2853+ uint64_t arg = 0;
2854+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2855+ }
2856+ state.addr = 18446744073709551520LLU; // 999999998e'''''''''''''''
2857+ break;
2858+ }
2859+ case 18446744073709551520LLU: // 999999998e'''''''''''''''
2860+ {
2861+ if(!*LOCAL_ACCESS(heap.data, 4LLU, 2LLU))
2862+ {
2863+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
2864+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 3
2865+ {
2866+ state.addr = 18446744073709551519LLU; // 999999998d'''''''''''''''
2867+ break;
2868+ }
2869+ }
2870+ /*direct*/*LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = (*LOCAL_ACCESS(heap.data, 4LLU, 2LLU) << 1) + 1LLU;
2871+ *LOCAL_ACCESS(heap.data, 4LLU, 2LLU) = heap.data[*LOCAL_ACCESS(heap.data, 4LLU, 2LLU)].elem0;
2872+ {
2873+ uint64_t arg = 0;
2874+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2875+ }
2876+ *LOCAL_ACCESS(heap.data, 5LLU, 4LLU) = /*first_____*/*LOCAL_ACCESS(heap.data, 5LLU, 1LLU);
2877+ state.addr = *LOCAL_ACCESS(heap.data, 5LLU, 4LLU) ? 18446744073709551518LLU : 18446744073709551517LLU;
2878+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 5
2879+ break;
2880+ }
2881+ case 18446744073709551518LLU: // 999999998c'''''''''''''''
2882+ {
2883+
2884+ *LOCAL_ACCESS(heap.data, 4LLU, 1LLU) = 0;
2885+ state.addr = 18446744073709551516LLU; // 999999998a'''''''''''''''
2886+ break;
2887+ }
2888+ case 18446744073709551517LLU: // 999999998b'''''''''''''''
2889+ {
2890+ fprintf(stderr, "%s", ", ");
2891+ state.addr = 18446744073709551516LLU; // 999999998a'''''''''''''''
2892+ break;
2893+ }
2894+ case 18446744073709551516LLU: // 999999998a'''''''''''''''
2895+ {
2896+ // ACCUMULATE ARGUMENTS - BEGIN
2897+ {
2898+ uint64_t arg = /*r_________*/*LOCAL_ACCESS(heap.data, 4LLU, 3LLU);
2899+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
2900+ }
2901+ // ACCUMULATE ARGUMENTS - END
2902+ uint64_t return_to = 18446744073709551515LLU;
2903+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
2904+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
2905+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
2906+ heap.data[0].elem1 = heap.data[0].elem0;
2907+ heap.data[0].elem0 = restore;
2908+ state.addr = 325737967258195136LLU; // REPORTRES_
2909+ break;
2910+ }
2911+ case 18446744073709551515LLU: // 999999998$'''''''''''''''
2912+ {
2913+ // parameter-reference resdest___ r_________ goes out of scope
2914+ // parameter-reference list<resdest___> rs________ goes out of scope
2915+ state.addr = 18446744073709551520LLU; // 999999998e'''''''''''''''
2916+ break;
2917+ }
2918+ case 18446744073709551519LLU: // 999999998d'''''''''''''''
2919+ {
2920+ fprintf(stderr, "%s", ")");
2921+ // variable u64 first_____ goes out of scope
2922+ // emitted destructur for type u64
2923+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference first_____ at 2
2924+ // parameter-reference list<resdest___> rs________ goes out of scope
2925+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference rs________ at 1
2926+ {
2927+ uint64_t baseinfo = heap.data[0].elem1;
2928+ struct pair pair = unpair(&heap, &baseinfo);
2929+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
2930+ state.addr = pair.elem1;
2931+ }
2932+ break;
2933+ }
2934+ case 18446744073709551513LLU: // 999999998Y'''''''''''''''
2935+ {
2936+ // destructor for variant maintain__
2937+ // RELEASE destructor-argument
2938+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 1
2939+ {
2940+ uint64_t baseinfo = heap.data[0].elem1;
2941+ struct pair pair = unpair(&heap, &baseinfo);
2942+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
2943+ state.addr = pair.elem1;
2944+ }
2945+ break;
2946+ }
2947+ case 18446744073709551512LLU: // 999999998X'''''''''''''''
2948+ {
2949+ // destructor for variant consume___
2950+ // RELEASE destructor-argument
2951+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 1
2952+ {
2953+ uint64_t baseinfo = heap.data[0].elem1;
2954+ struct pair pair = unpair(&heap, &baseinfo);
2955+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
2956+ state.addr = pair.elem1;
2957+ }
2958+ break;
2959+ }
2960+ case 18446744073709551511LLU: // 999999998W'''''''''''''''
2961+ {
2962+ // destructor for variant produce___
2963+ // RELEASE destructor-argument
2964+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 1
2965+ {
2966+ uint64_t baseinfo = heap.data[0].elem1;
2967+ struct pair pair = unpair(&heap, &baseinfo);
2968+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
2969+ state.addr = pair.elem1;
2970+ }
2971+ break;
2972+ }
2973+ case 18446744073709551514LLU: // 999999998Z'''''''''''''''
2974+ {
2975+ struct pair type_data = unpair(&heap, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
2976+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)) = type_data.elem1;
2977+ state.addr = 18446744073709551511LLU + type_data.elem0;
2978+ break;
2979+ }
2980+ case 728618437845356544LLU: // maintain__
2981+ {
2982+ // union-constructor maintain__
2983+ {
2984+ uint64_t result_tuple = 0;
2985+ // copy references
2986+ // release parameters
2987+ {
2988+ uint64_t constridx = 2LLU;
2989+ uint64_t root = pair_move(&heap, &constridx, &result_tuple);
2990+ *access_heap(heap.data, LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*memory root*/)) = root;
2991+ }
2992+ }
2993+ {
2994+ uint64_t baseinfo = heap.data[0].elem1;
2995+ struct pair pair = unpair(&heap, &baseinfo);
2996+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
2997+ state.addr = pair.elem1;
2998+ }
2999+ break;
3000+ }
3001+ case 552437437528276992LLU: // consume___
3002+ {
3003+ // union-constructor consume___
3004+ {
3005+ uint64_t result_tuple = 0;
3006+ // copy references
3007+ // release parameters
3008+ {
3009+ uint64_t constridx = 1LLU;
3010+ uint64_t root = pair_move(&heap, &constridx, &result_tuple);
3011+ *access_heap(heap.data, LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*memory root*/)) = root;
3012+ }
3013+ }
3014+ {
3015+ uint64_t baseinfo = heap.data[0].elem1;
3016+ struct pair pair = unpair(&heap, &baseinfo);
3017+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
3018+ state.addr = pair.elem1;
3019+ }
3020+ break;
3021+ }
3022+ case 787472410168262656LLU: // produce___
3023+ {
3024+ // union-constructor produce___
3025+ {
3026+ uint64_t result_tuple = 0;
3027+ // copy references
3028+ // release parameters
3029+ {
3030+ uint64_t constridx = 0LLU;
3031+ uint64_t root = pair_move(&heap, &constridx, &result_tuple);
3032+ *access_heap(heap.data, LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*memory root*/)) = root;
3033+ }
3034+ }
3035+ {
3036+ uint64_t baseinfo = heap.data[0].elem1;
3037+ struct pair pair = unpair(&heap, &baseinfo);
3038+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
3039+ state.addr = pair.elem1;
3040+ }
3041+ break;
3042+ }
3043+ case 589058781102643104LLU: // equbalance
3044+ {
3045+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU))].elem0 != 0/*produce___*/)
3046+ {
3047+ state.addr = 18446744073709551510LLU; // 999999998V'''''''''''''''
3048+ break;
3049+ }
3050+ {
3051+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 1LLU);
3052+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3053+ }
3054+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU))].elem0 != 0/*produce___*/)
3055+ {
3056+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
3057+ state.addr = 18446744073709551510LLU; // 999999998V'''''''''''''''
3058+ break;
3059+ }
3060+ {
3061+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU), 1LLU);
3062+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3063+ }
3064+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 0LLU)) = 1LLU;
3065+ // parameter-reference continuity __________ goes out of scope
3066+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 5
3067+ // parameter continuity __________ goes out of scope
3068+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 4
3069+ // parameter-reference continuity __________ goes out of scope
3070+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3
3071+ // parameter continuity __________ goes out of scope
3072+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
3073+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
3074+ {
3075+ uint64_t baseinfo = heap.data[0].elem1;
3076+ struct pair pair = unpair(&heap, &baseinfo);
3077+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
3078+ state.addr = pair.elem1;
3079+ }
3080+ break;
3081+ }
3082+ case 18446744073709551510LLU: // 999999998V'''''''''''''''
3083+ {
3084+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU))].elem0 != 1/*consume___*/)
3085+ {
3086+ state.addr = 18446744073709551509LLU; // 999999998U'''''''''''''''
3087+ break;
3088+ }
3089+ {
3090+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 1LLU);
3091+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3092+ }
3093+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU))].elem0 != 0/*produce___*/)
3094+ {
3095+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
3096+ state.addr = 18446744073709551509LLU; // 999999998U'''''''''''''''
3097+ break;
3098+ }
3099+ {
3100+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU), 1LLU);
3101+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3102+ }
3103+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 0LLU)) = 0LLU;
3104+ // parameter-reference continuity __________ goes out of scope
3105+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 5
3106+ // parameter continuity __________ goes out of scope
3107+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 4
3108+ // parameter-reference continuity __________ goes out of scope
3109+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3
3110+ // parameter continuity __________ goes out of scope
3111+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
3112+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
3113+ {
3114+ uint64_t baseinfo = heap.data[0].elem1;
3115+ struct pair pair = unpair(&heap, &baseinfo);
3116+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
3117+ state.addr = pair.elem1;
3118+ }
3119+ break;
3120+ }
3121+ case 18446744073709551509LLU: // 999999998U'''''''''''''''
3122+ {
3123+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU))].elem0 != 2/*maintain__*/)
3124+ {
3125+ state.addr = 18446744073709551508LLU; // 999999998T'''''''''''''''
3126+ break;
3127+ }
3128+ {
3129+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 1LLU);
3130+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3131+ }
3132+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU))].elem0 != 0/*produce___*/)
3133+ {
3134+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
3135+ state.addr = 18446744073709551508LLU; // 999999998T'''''''''''''''
3136+ break;
3137+ }
3138+ {
3139+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU), 1LLU);
3140+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3141+ }
3142+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 0LLU)) = 0LLU;
3143+ // parameter-reference continuity __________ goes out of scope
3144+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 5
3145+ // parameter continuity __________ goes out of scope
3146+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 4
3147+ // parameter-reference continuity __________ goes out of scope
3148+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3
3149+ // parameter continuity __________ goes out of scope
3150+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
3151+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
3152+ {
3153+ uint64_t baseinfo = heap.data[0].elem1;
3154+ struct pair pair = unpair(&heap, &baseinfo);
3155+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
3156+ state.addr = pair.elem1;
3157+ }
3158+ break;
3159+ }
3160+ case 18446744073709551508LLU: // 999999998T'''''''''''''''
3161+ {
3162+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU))].elem0 != 0/*produce___*/)
3163+ {
3164+ state.addr = 18446744073709551507LLU; // 999999998S'''''''''''''''
3165+ break;
3166+ }
3167+ {
3168+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 1LLU);
3169+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3170+ }
3171+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU))].elem0 != 1/*consume___*/)
3172+ {
3173+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
3174+ state.addr = 18446744073709551507LLU; // 999999998S'''''''''''''''
3175+ break;
3176+ }
3177+ {
3178+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU), 1LLU);
3179+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3180+ }
3181+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 0LLU)) = 0LLU;
3182+ // parameter-reference continuity __________ goes out of scope
3183+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 5
3184+ // parameter continuity __________ goes out of scope
3185+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 4
3186+ // parameter-reference continuity __________ goes out of scope
3187+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3
3188+ // parameter continuity __________ goes out of scope
3189+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
3190+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
3191+ {
3192+ uint64_t baseinfo = heap.data[0].elem1;
3193+ struct pair pair = unpair(&heap, &baseinfo);
3194+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
3195+ state.addr = pair.elem1;
3196+ }
3197+ break;
3198+ }
3199+ case 18446744073709551507LLU: // 999999998S'''''''''''''''
3200+ {
3201+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU))].elem0 != 1/*consume___*/)
3202+ {
3203+ state.addr = 18446744073709551506LLU; // 999999998R'''''''''''''''
3204+ break;
3205+ }
3206+ {
3207+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 1LLU);
3208+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3209+ }
3210+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU))].elem0 != 1/*consume___*/)
3211+ {
3212+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
3213+ state.addr = 18446744073709551506LLU; // 999999998R'''''''''''''''
3214+ break;
3215+ }
3216+ {
3217+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU), 1LLU);
3218+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3219+ }
3220+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 0LLU)) = 1LLU;
3221+ // parameter-reference continuity __________ goes out of scope
3222+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 5
3223+ // parameter continuity __________ goes out of scope
3224+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 4
3225+ // parameter-reference continuity __________ goes out of scope
3226+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3
3227+ // parameter continuity __________ goes out of scope
3228+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
3229+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
3230+ {
3231+ uint64_t baseinfo = heap.data[0].elem1;
3232+ struct pair pair = unpair(&heap, &baseinfo);
3233+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
3234+ state.addr = pair.elem1;
3235+ }
3236+ break;
3237+ }
3238+ case 18446744073709551506LLU: // 999999998R'''''''''''''''
3239+ {
3240+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU))].elem0 != 2/*maintain__*/)
3241+ {
3242+ state.addr = 18446744073709551505LLU; // 999999998Q'''''''''''''''
3243+ break;
3244+ }
3245+ {
3246+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 1LLU);
3247+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3248+ }
3249+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU))].elem0 != 1/*consume___*/)
3250+ {
3251+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
3252+ state.addr = 18446744073709551505LLU; // 999999998Q'''''''''''''''
3253+ break;
3254+ }
3255+ {
3256+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU), 1LLU);
3257+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3258+ }
3259+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 0LLU)) = 0LLU;
3260+ // parameter-reference continuity __________ goes out of scope
3261+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 5
3262+ // parameter continuity __________ goes out of scope
3263+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 4
3264+ // parameter-reference continuity __________ goes out of scope
3265+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3
3266+ // parameter continuity __________ goes out of scope
3267+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
3268+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
3269+ {
3270+ uint64_t baseinfo = heap.data[0].elem1;
3271+ struct pair pair = unpair(&heap, &baseinfo);
3272+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
3273+ state.addr = pair.elem1;
3274+ }
3275+ break;
3276+ }
3277+ case 18446744073709551505LLU: // 999999998Q'''''''''''''''
3278+ {
3279+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU))].elem0 != 0/*produce___*/)
3280+ {
3281+ state.addr = 18446744073709551504LLU; // 999999998P'''''''''''''''
3282+ break;
3283+ }
3284+ {
3285+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 1LLU);
3286+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3287+ }
3288+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU))].elem0 != 2/*maintain__*/)
3289+ {
3290+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
3291+ state.addr = 18446744073709551504LLU; // 999999998P'''''''''''''''
3292+ break;
3293+ }
3294+ {
3295+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU), 1LLU);
3296+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3297+ }
3298+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 0LLU)) = 0LLU;
3299+ // parameter-reference continuity __________ goes out of scope
3300+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 5
3301+ // parameter continuity __________ goes out of scope
3302+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 4
3303+ // parameter-reference continuity __________ goes out of scope
3304+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3
3305+ // parameter continuity __________ goes out of scope
3306+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
3307+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
3308+ {
3309+ uint64_t baseinfo = heap.data[0].elem1;
3310+ struct pair pair = unpair(&heap, &baseinfo);
3311+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
3312+ state.addr = pair.elem1;
3313+ }
3314+ break;
3315+ }
3316+ case 18446744073709551504LLU: // 999999998P'''''''''''''''
3317+ {
3318+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU))].elem0 != 1/*consume___*/)
3319+ {
3320+ state.addr = 18446744073709551503LLU; // 999999998O'''''''''''''''
3321+ break;
3322+ }
3323+ {
3324+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 1LLU);
3325+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3326+ }
3327+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU))].elem0 != 2/*maintain__*/)
3328+ {
3329+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
3330+ state.addr = 18446744073709551503LLU; // 999999998O'''''''''''''''
3331+ break;
3332+ }
3333+ {
3334+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU), 1LLU);
3335+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3336+ }
3337+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 0LLU)) = 0LLU;
3338+ // parameter-reference continuity __________ goes out of scope
3339+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 5
3340+ // parameter continuity __________ goes out of scope
3341+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 4
3342+ // parameter-reference continuity __________ goes out of scope
3343+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3
3344+ // parameter continuity __________ goes out of scope
3345+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
3346+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
3347+ {
3348+ uint64_t baseinfo = heap.data[0].elem1;
3349+ struct pair pair = unpair(&heap, &baseinfo);
3350+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
3351+ state.addr = pair.elem1;
3352+ }
3353+ break;
3354+ }
3355+ case 18446744073709551503LLU: // 999999998O'''''''''''''''
3356+ {
3357+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU))].elem0 != 2/*maintain__*/)
3358+ {
3359+ state.addr = 18446744073709551502LLU; // 999999998N'''''''''''''''
3360+ break;
3361+ }
3362+ {
3363+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 1LLU);
3364+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3365+ }
3366+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU))].elem0 != 2/*maintain__*/)
3367+ {
3368+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
3369+ state.addr = 18446744073709551502LLU; // 999999998N'''''''''''''''
3370+ break;
3371+ }
3372+ {
3373+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU), 1LLU);
3374+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3375+ }
3376+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 0LLU)) = 1LLU;
3377+ // parameter-reference continuity __________ goes out of scope
3378+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 5
3379+ // parameter continuity __________ goes out of scope
3380+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 4
3381+ // parameter-reference continuity __________ goes out of scope
3382+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3
3383+ // parameter continuity __________ goes out of scope
3384+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
3385+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
3386+ {
3387+ uint64_t baseinfo = heap.data[0].elem1;
3388+ struct pair pair = unpair(&heap, &baseinfo);
3389+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
3390+ state.addr = pair.elem1;
3391+ }
3392+ break;
3393+ }
3394+ case 18446744073709551502LLU: // 999999998N'''''''''''''''
3395+ {
3396+ fprintf(stderr, "INTERNAL COMPILER ERROR: missing pattern-match-case in definition of equbalance\n");
3397+ exit(-1);
3398+ break;
3399+ }
3400+ case 58555672873677120LLU: // CPBALANCE_
3401+ {
3402+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 != 0/*produce___*/)
3403+ {
3404+ state.addr = 18446744073709551501LLU; // 999999998M'''''''''''''''
3405+ break;
3406+ }
3407+ {
3408+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU), 1LLU);
3409+ LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3410+ }
3411+ // ACCUMULATE ARGUMENTS - BEGIN
3412+ {
3413+ uint64_t arg = *LOCAL_ACCESS(heap.data, 3LLU, 0LLU);
3414+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
3415+ }
3416+ // ACCUMULATE ARGUMENTS - END
3417+ uint64_t return_to = 18446744073709551500LLU;
3418+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
3419+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
3420+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
3421+ heap.data[0].elem1 = heap.data[0].elem0;
3422+ heap.data[0].elem0 = restore;
3423+ state.addr = 787472410168262656LLU; // produce___
3424+ break;
3425+ }
3426+ case 18446744073709551500LLU: // 999999998L'''''''''''''''
3427+ {
3428+ // parameter-reference continuity __________ goes out of scope
3429+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3
3430+ // parameter continuity __________ goes out of scope
3431+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
3432+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
3433+ {
3434+ uint64_t baseinfo = heap.data[0].elem1;
3435+ struct pair pair = unpair(&heap, &baseinfo);
3436+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
3437+ state.addr = pair.elem1;
3438+ }
3439+ break;
3440+ }
3441+ case 18446744073709551501LLU: // 999999998M'''''''''''''''
3442+ {
3443+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 != 1/*consume___*/)
3444+ {
3445+ state.addr = 18446744073709551499LLU; // 999999998K'''''''''''''''
3446+ break;
3447+ }
3448+ {
3449+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU), 1LLU);
3450+ LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3451+ }
3452+ // ACCUMULATE ARGUMENTS - BEGIN
3453+ {
3454+ uint64_t arg = *LOCAL_ACCESS(heap.data, 3LLU, 0LLU);
3455+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
3456+ }
3457+ // ACCUMULATE ARGUMENTS - END
3458+ uint64_t return_to = 18446744073709551498LLU;
3459+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
3460+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
3461+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
3462+ heap.data[0].elem1 = heap.data[0].elem0;
3463+ heap.data[0].elem0 = restore;
3464+ state.addr = 552437437528276992LLU; // consume___
3465+ break;
3466+ }
3467+ case 18446744073709551498LLU: // 999999998J'''''''''''''''
3468+ {
3469+ // parameter-reference continuity __________ goes out of scope
3470+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3
3471+ // parameter continuity __________ goes out of scope
3472+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
3473+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
3474+ {
3475+ uint64_t baseinfo = heap.data[0].elem1;
3476+ struct pair pair = unpair(&heap, &baseinfo);
3477+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
3478+ state.addr = pair.elem1;
3479+ }
3480+ break;
3481+ }
3482+ case 18446744073709551499LLU: // 999999998K'''''''''''''''
3483+ {
3484+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 != 2/*maintain__*/)
3485+ {
3486+ state.addr = 18446744073709551497LLU; // 999999998I'''''''''''''''
3487+ break;
3488+ }
3489+ {
3490+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU), 1LLU);
3491+ LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3492+ }
3493+ // ACCUMULATE ARGUMENTS - BEGIN
3494+ {
3495+ uint64_t arg = *LOCAL_ACCESS(heap.data, 3LLU, 0LLU);
3496+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
3497+ }
3498+ // ACCUMULATE ARGUMENTS - END
3499+ uint64_t return_to = 18446744073709551496LLU;
3500+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
3501+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
3502+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
3503+ heap.data[0].elem1 = heap.data[0].elem0;
3504+ heap.data[0].elem0 = restore;
3505+ state.addr = 728618437845356544LLU; // maintain__
3506+ break;
3507+ }
3508+ case 18446744073709551496LLU: // 999999998H'''''''''''''''
3509+ {
3510+ // parameter-reference continuity __________ goes out of scope
3511+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3
3512+ // parameter continuity __________ goes out of scope
3513+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
3514+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
3515+ {
3516+ uint64_t baseinfo = heap.data[0].elem1;
3517+ struct pair pair = unpair(&heap, &baseinfo);
3518+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
3519+ state.addr = pair.elem1;
3520+ }
3521+ break;
3522+ }
3523+ case 18446744073709551497LLU: // 999999998I'''''''''''''''
3524+ {
3525+ fprintf(stderr, "INTERNAL COMPILER ERROR: missing pattern-match-case in definition of CPBALANCE_\n");
3526+ exit(-1);
3527+ break;
3528+ }
3529+ case 18446744073709551494LLU: // 999999998F'''''''''''''''
3530+ {
3531+ // destructor for variant blkloop___
3532+ // RELEASE destructor-argument
3533+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 1
3534+ {
3535+ uint64_t baseinfo = heap.data[0].elem1;
3536+ struct pair pair = unpair(&heap, &baseinfo);
3537+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
3538+ state.addr = pair.elem1;
3539+ }
3540+ break;
3541+ }
3542+ case 18446744073709551493LLU: // 999999998E'''''''''''''''
3543+ {
3544+ // destructor for variant blkelse___
3545+ // RELEASE destructor-argument
3546+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 1
3547+ {
3548+ uint64_t baseinfo = heap.data[0].elem1;
3549+ struct pair pair = unpair(&heap, &baseinfo);
3550+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
3551+ state.addr = pair.elem1;
3552+ }
3553+ break;
3554+ }
3555+ case 18446744073709551492LLU: // 999999998D'''''''''''''''
3556+ {
3557+ // destructor for variant blkif_____
3558+ // RELEASE destructor-argument
3559+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 1
3560+ {
3561+ uint64_t baseinfo = heap.data[0].elem1;
3562+ struct pair pair = unpair(&heap, &baseinfo);
3563+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
3564+ state.addr = pair.elem1;
3565+ }
3566+ break;
3567+ }
3568+ case 18446744073709551491LLU: // 999999998C'''''''''''''''
3569+ {
3570+ // destructor for variant blkwhen___
3571+ // RELEASE destructor-argument
3572+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 1
3573+ {
3574+ uint64_t baseinfo = heap.data[0].elem1;
3575+ struct pair pair = unpair(&heap, &baseinfo);
3576+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
3577+ state.addr = pair.elem1;
3578+ }
3579+ break;
3580+ }
3581+ case 18446744073709551490LLU: // 999999998B'''''''''''''''
3582+ {
3583+ // destructor for variant blknone___
3584+ // RELEASE destructor-argument
3585+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 1
3586+ {
3587+ uint64_t baseinfo = heap.data[0].elem1;
3588+ struct pair pair = unpair(&heap, &baseinfo);
3589+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
3590+ state.addr = pair.elem1;
3591+ }
3592+ break;
3593+ }
3594+ case 18446744073709551495LLU: // 999999998G'''''''''''''''
3595+ {
3596+ struct pair type_data = unpair(&heap, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
3597+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)) = type_data.elem1;
3598+ state.addr = 18446744073709551490LLU + type_data.elem0;
3599+ break;
3600+ }
3601+ case 533564932506779648LLU: // blkloop___
3602+ {
3603+ // union-constructor blkloop___
3604+ {
3605+ uint64_t result_tuple = 0;
3606+ // copy references
3607+ // release parameters
3608+ {
3609+ uint64_t constridx = 4LLU;
3610+ uint64_t root = pair_move(&heap, &constridx, &result_tuple);
3611+ *access_heap(heap.data, LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*memory root*/)) = root;
3612+ }
3613+ }
3614+ {
3615+ uint64_t baseinfo = heap.data[0].elem1;
3616+ struct pair pair = unpair(&heap, &baseinfo);
3617+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
3618+ state.addr = pair.elem1;
3619+ }
3620+ break;
3621+ }
3622+ case 533564448313442304LLU: // blkelse___
3623+ {
3624+ // union-constructor blkelse___
3625+ {
3626+ uint64_t result_tuple = 0;
3627+ // copy references
3628+ // release parameters
3629+ {
3630+ uint64_t constridx = 3LLU;
3631+ uint64_t root = pair_move(&heap, &constridx, &result_tuple);
3632+ *access_heap(heap.data, LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*memory root*/)) = root;
3633+ }
3634+ }
3635+ {
3636+ uint64_t baseinfo = heap.data[0].elem1;
3637+ struct pair pair = unpair(&heap, &baseinfo);
3638+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
3639+ state.addr = pair.elem1;
3640+ }
3641+ break;
3642+ }
3643+ case 533564715968757760LLU: // blkif_____
3644+ {
3645+ // union-constructor blkif_____
3646+ {
3647+ uint64_t result_tuple = 0;
3648+ // copy references
3649+ // release parameters
3650+ {
3651+ uint64_t constridx = 2LLU;
3652+ uint64_t root = pair_move(&heap, &constridx, &result_tuple);
3653+ *access_heap(heap.data, LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*memory root*/)) = root;
3654+ }
3655+ }
3656+ {
3657+ uint64_t baseinfo = heap.data[0].elem1;
3658+ struct pair pair = unpair(&heap, &baseinfo);
3659+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
3660+ state.addr = pair.elem1;
3661+ }
3662+ break;
3663+ }
3664+ case 533565680736534528LLU: // blkwhen___
3665+ {
3666+ // union-constructor blkwhen___
3667+ {
3668+ uint64_t result_tuple = 0;
3669+ // copy references
3670+ // release parameters
3671+ {
3672+ uint64_t constridx = 1LLU;
3673+ uint64_t root = pair_move(&heap, &constridx, &result_tuple);
3674+ *access_heap(heap.data, LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*memory root*/)) = root;
3675+ }
3676+ }
3677+ {
3678+ uint64_t baseinfo = heap.data[0].elem1;
3679+ struct pair pair = unpair(&heap, &baseinfo);
3680+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
3681+ state.addr = pair.elem1;
3682+ }
3683+ break;
3684+ }
3685+ case 533565069926072320LLU: // blknone___
3686+ {
3687+ // union-constructor blknone___
3688+ {
3689+ uint64_t result_tuple = 0;
3690+ // copy references
3691+ // release parameters
3692+ {
3693+ uint64_t constridx = 0LLU;
3694+ uint64_t root = pair_move(&heap, &constridx, &result_tuple);
3695+ *access_heap(heap.data, LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*memory root*/)) = root;
3696+ }
3697+ }
3698+ {
3699+ uint64_t baseinfo = heap.data[0].elem1;
3700+ struct pair pair = unpair(&heap, &baseinfo);
3701+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
3702+ state.addr = pair.elem1;
3703+ }
3704+ break;
3705+ }
3706+ case 819847183514106240LLU: // reportblk_
3707+ {
3708+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 0/*blknone___*/)
3709+ {
3710+ state.addr = 18446744073709551489LLU; // 999999998A'''''''''''''''
3711+ break;
3712+ }
3713+ {
3714+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU), 1LLU);
3715+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3716+ }
3717+ fprintf(stderr, "%s", "blknone");
3718+ // parameter-reference blockvar__ __________ goes out of scope
3719+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
3720+ // parameter blockvar__ __________ goes out of scope
3721+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
3722+ {
3723+ uint64_t baseinfo = heap.data[0].elem1;
3724+ struct pair pair = unpair(&heap, &baseinfo);
3725+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
3726+ state.addr = pair.elem1;
3727+ }
3728+ break;
3729+ }
3730+ case 18446744073709551489LLU: // 999999998A'''''''''''''''
3731+ {
3732+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 1/*blkwhen___*/)
3733+ {
3734+ state.addr = 18446744073709551488LLU; // 999999998_'''''''''''''''
3735+ break;
3736+ }
3737+ {
3738+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU), 1LLU);
3739+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3740+ }
3741+ fprintf(stderr, "%s", "blkwhen");
3742+ // parameter-reference blockvar__ __________ goes out of scope
3743+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
3744+ // parameter blockvar__ __________ goes out of scope
3745+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
3746+ {
3747+ uint64_t baseinfo = heap.data[0].elem1;
3748+ struct pair pair = unpair(&heap, &baseinfo);
3749+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
3750+ state.addr = pair.elem1;
3751+ }
3752+ break;
3753+ }
3754+ case 18446744073709551488LLU: // 999999998_'''''''''''''''
3755+ {
3756+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 2/*blkif_____*/)
3757+ {
3758+ state.addr = 18446744073709551487LLU; // 9999999979'''''''''''''''
3759+ break;
3760+ }
3761+ {
3762+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU), 1LLU);
3763+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3764+ }
3765+ fprintf(stderr, "%s", "blkif");
3766+ // parameter-reference blockvar__ __________ goes out of scope
3767+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
3768+ // parameter blockvar__ __________ goes out of scope
3769+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
3770+ {
3771+ uint64_t baseinfo = heap.data[0].elem1;
3772+ struct pair pair = unpair(&heap, &baseinfo);
3773+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
3774+ state.addr = pair.elem1;
3775+ }
3776+ break;
3777+ }
3778+ case 18446744073709551487LLU: // 9999999979'''''''''''''''
3779+ {
3780+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 3/*blkelse___*/)
3781+ {
3782+ state.addr = 18446744073709551486LLU; // 9999999978'''''''''''''''
3783+ break;
3784+ }
3785+ {
3786+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU), 1LLU);
3787+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3788+ }
3789+ fprintf(stderr, "%s", "blkelse");
3790+ // parameter-reference blockvar__ __________ goes out of scope
3791+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
3792+ // parameter blockvar__ __________ goes out of scope
3793+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
3794+ {
3795+ uint64_t baseinfo = heap.data[0].elem1;
3796+ struct pair pair = unpair(&heap, &baseinfo);
3797+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
3798+ state.addr = pair.elem1;
3799+ }
3800+ break;
3801+ }
3802+ case 18446744073709551486LLU: // 9999999978'''''''''''''''
3803+ {
3804+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 4/*blkloop___*/)
3805+ {
3806+ state.addr = 18446744073709551485LLU; // 9999999977'''''''''''''''
3807+ break;
3808+ }
3809+ {
3810+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU), 1LLU);
3811+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3812+ }
3813+ fprintf(stderr, "%s", "blkloop");
3814+ // parameter-reference blockvar__ __________ goes out of scope
3815+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
3816+ // parameter blockvar__ __________ goes out of scope
3817+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
3818+ {
3819+ uint64_t baseinfo = heap.data[0].elem1;
3820+ struct pair pair = unpair(&heap, &baseinfo);
3821+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
3822+ state.addr = pair.elem1;
3823+ }
3824+ break;
3825+ }
3826+ case 18446744073709551485LLU: // 9999999977'''''''''''''''
3827+ {
3828+ fprintf(stderr, "INTERNAL COMPILER ERROR: missing pattern-match-case in definition of reportblk_\n");
3829+ exit(-1);
3830+ break;
3831+ }
3832+ case 18446744073709551483LLU: // 9999999975'''''''''''''''
3833+ {
3834+ // destructor for variant varhide___
3835+ // RELEASE destructor-argument
3836+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 1
3837+ {
3838+ uint64_t baseinfo = heap.data[0].elem1;
3839+ struct pair pair = unpair(&heap, &baseinfo);
3840+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
3841+ state.addr = pair.elem1;
3842+ }
3843+ break;
3844+ }
3845+ case 18446744073709551482LLU: // 9999999974'''''''''''''''
3846+ {
3847+ // destructor for variant elblock___
3848+ {
3849+ uint64_t arg = tree_pop_move(&heap, 1LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
3850+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3851+ }
3852+ // emitted destructur for type u64
3853+ // RELEASE temporary destructor-variable
3854+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
3855+ // RELEASE destructor-argument
3856+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 1
3857+ {
3858+ uint64_t baseinfo = heap.data[0].elem1;
3859+ struct pair pair = unpair(&heap, &baseinfo);
3860+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
3861+ state.addr = pair.elem1;
3862+ }
3863+ break;
3864+ }
3865+ case 18446744073709551481LLU: // 9999999973'''''''''''''''
3866+ {
3867+ // destructor for variant varblock__
3868+ // RELEASE destructor-argument
3869+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 1
3870+ {
3871+ uint64_t baseinfo = heap.data[0].elem1;
3872+ struct pair pair = unpair(&heap, &baseinfo);
3873+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
3874+ state.addr = pair.elem1;
3875+ }
3876+ break;
3877+ }
3878+ case 18446744073709551480LLU: // 9999999972'''''''''''''''
3879+ {
3880+ // destructor for variant varvirt___
3881+ {
3882+ uint64_t arg = tree_pop_move(&heap, 5LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
3883+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3884+ }
3885+ // emitted destructur for type u64
3886+ // RELEASE temporary destructor-variable
3887+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
3888+ {
3889+ uint64_t arg = tree_pop_move(&heap, 4LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
3890+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3891+ }
3892+ // emitted destructur for type u64
3893+ // RELEASE temporary destructor-variable
3894+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
3895+ {
3896+ uint64_t arg = tree_pop_move(&heap, 3LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
3897+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3898+ }
3899+ // emitted destructur for type type______
3900+ // ACCUMULATE ARGUMENTS - BEGIN
3901+ {
3902+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 2LLU, 1LLU);
3903+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
3904+ }
3905+ // ACCUMULATE ARGUMENTS - END
3906+ uint64_t return_to = 18446744073709551477LLU;
3907+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
3908+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
3909+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
3910+ heap.data[0].elem1 = heap.data[0].elem0;
3911+ heap.data[0].elem0 = restore;
3912+ state.addr = 18446744073709551573LLU; // 999999999U'''''''''''''''
3913+ break;
3914+ }
3915+ case 18446744073709551477LLU: // 999999997z'''''''''''''''
3916+ {
3917+ // RELEASE temporary destructor-variable
3918+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
3919+ {
3920+ uint64_t arg = tree_pop_move(&heap, 2LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
3921+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3922+ }
3923+ // emitted destructur for type u64
3924+ // RELEASE temporary destructor-variable
3925+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
3926+ {
3927+ uint64_t arg = tree_pop_move(&heap, 1LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
3928+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3929+ }
3930+ // emitted destructur for type u64
3931+ // RELEASE temporary destructor-variable
3932+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
3933+ // RELEASE destructor-argument
3934+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 1
3935+ {
3936+ uint64_t baseinfo = heap.data[0].elem1;
3937+ struct pair pair = unpair(&heap, &baseinfo);
3938+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
3939+ state.addr = pair.elem1;
3940+ }
3941+ break;
3942+ }
3943+ case 18446744073709551479LLU: // 9999999971'''''''''''''''
3944+ {
3945+ // destructor for variant varref____
3946+ {
3947+ uint64_t arg = tree_pop_move(&heap, 6LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
3948+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3949+ }
3950+ // emitted destructur for type u64
3951+ // RELEASE temporary destructor-variable
3952+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
3953+ {
3954+ uint64_t arg = tree_pop_move(&heap, 5LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
3955+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3956+ }
3957+ // emitted destructur for type u64
3958+ // RELEASE temporary destructor-variable
3959+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
3960+ {
3961+ uint64_t arg = tree_pop_move(&heap, 4LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
3962+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3963+ }
3964+ // emitted destructur for type u64
3965+ // RELEASE temporary destructor-variable
3966+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
3967+ {
3968+ uint64_t arg = tree_pop_move(&heap, 3LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
3969+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3970+ }
3971+ // emitted destructur for type type______
3972+ // ACCUMULATE ARGUMENTS - BEGIN
3973+ {
3974+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 2LLU, 1LLU);
3975+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
3976+ }
3977+ // ACCUMULATE ARGUMENTS - END
3978+ uint64_t return_to = 18446744073709551476LLU;
3979+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
3980+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
3981+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
3982+ heap.data[0].elem1 = heap.data[0].elem0;
3983+ heap.data[0].elem0 = restore;
3984+ state.addr = 18446744073709551573LLU; // 999999999U'''''''''''''''
3985+ break;
3986+ }
3987+ case 18446744073709551476LLU: // 999999997y'''''''''''''''
3988+ {
3989+ // RELEASE temporary destructor-variable
3990+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
3991+ {
3992+ uint64_t arg = tree_pop_move(&heap, 2LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
3993+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3994+ }
3995+ // emitted destructur for type u64
3996+ // RELEASE temporary destructor-variable
3997+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
3998+ {
3999+ uint64_t arg = tree_pop_move(&heap, 1LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
4000+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4001+ }
4002+ // emitted destructur for type u64
4003+ // RELEASE temporary destructor-variable
4004+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
4005+ // RELEASE destructor-argument
4006+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 1
4007+ {
4008+ uint64_t baseinfo = heap.data[0].elem1;
4009+ struct pair pair = unpair(&heap, &baseinfo);
4010+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
4011+ state.addr = pair.elem1;
4012+ }
4013+ break;
4014+ }
4015+ case 18446744073709551478LLU: // 9999999970'''''''''''''''
4016+ {
4017+ // destructor for variant varvar____
4018+ {
4019+ uint64_t arg = tree_pop_move(&heap, 5LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
4020+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4021+ }
4022+ // emitted destructur for type u64
4023+ // RELEASE temporary destructor-variable
4024+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
4025+ {
4026+ uint64_t arg = tree_pop_move(&heap, 4LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
4027+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4028+ }
4029+ // emitted destructur for type u64
4030+ // RELEASE temporary destructor-variable
4031+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
4032+ {
4033+ uint64_t arg = tree_pop_move(&heap, 3LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
4034+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4035+ }
4036+ // emitted destructur for type type______
4037+ // ACCUMULATE ARGUMENTS - BEGIN
4038+ {
4039+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 2LLU, 1LLU);
4040+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4041+ }
4042+ // ACCUMULATE ARGUMENTS - END
4043+ uint64_t return_to = 18446744073709551475LLU;
4044+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4045+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4046+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
4047+ heap.data[0].elem1 = heap.data[0].elem0;
4048+ heap.data[0].elem0 = restore;
4049+ state.addr = 18446744073709551573LLU; // 999999999U'''''''''''''''
4050+ break;
4051+ }
4052+ case 18446744073709551475LLU: // 999999997x'''''''''''''''
4053+ {
4054+ // RELEASE temporary destructor-variable
4055+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
4056+ {
4057+ uint64_t arg = tree_pop_move(&heap, 2LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
4058+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4059+ }
4060+ // emitted destructur for type u64
4061+ // RELEASE temporary destructor-variable
4062+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
4063+ {
4064+ uint64_t arg = tree_pop_move(&heap, 1LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
4065+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4066+ }
4067+ // emitted destructur for type u64
4068+ // RELEASE temporary destructor-variable
4069+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
4070+ // RELEASE destructor-argument
4071+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 1
4072+ {
4073+ uint64_t baseinfo = heap.data[0].elem1;
4074+ struct pair pair = unpair(&heap, &baseinfo);
4075+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
4076+ state.addr = pair.elem1;
4077+ }
4078+ break;
4079+ }
4080+ case 18446744073709551484LLU: // 9999999976'''''''''''''''
4081+ {
4082+ struct pair type_data = unpair(&heap, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
4083+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)) = type_data.elem1;
4084+ state.addr = 18446744073709551478LLU + type_data.elem0;
4085+ break;
4086+ }
4087+ case 890787182770388992LLU: // varhide___
4088+ {
4089+ // union-constructor varhide___
4090+ {
4091+ uint64_t result_tuple = 0;
4092+ // copy references
4093+ // release parameters
4094+ {
4095+ uint64_t constridx = 5LLU;
4096+ uint64_t root = pair_move(&heap, &constridx, &result_tuple);
4097+ *access_heap(heap.data, LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*memory root*/)) = root;
4098+ }
4099+ }
4100+ {
4101+ uint64_t baseinfo = heap.data[0].elem1;
4102+ struct pair pair = unpair(&heap, &baseinfo);
4103+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
4104+ state.addr = pair.elem1;
4105+ }
4106+ break;
4107+ }
4108+ case 587568545413988352LLU: // elblock___
4109+ {
4110+ // union-constructor elblock___
4111+ {
4112+ uint64_t result_tuple = 0;
4113+ // copy references
4114+ {
4115+ uint64_t elem = *LOCAL_ACCESS(heap.data, 1LLU + 1, 0LLU + 1);
4116+ tree_push_move(&heap, 0LLU, &result_tuple, &elem);
4117+ }
4118+ // release parameters
4119+ {
4120+ (void)LOCAL_POP_MOVE(&heap, 1LLU + 1, &(heap.data[0].elem1)/*memory root*/);
4121+ }
4122+ {
4123+ uint64_t constridx = 4LLU;
4124+ uint64_t root = pair_move(&heap, &constridx, &result_tuple);
4125+ *access_heap(heap.data, LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*memory root*/)) = root;
4126+ }
4127+ }
4128+ {
4129+ uint64_t baseinfo = heap.data[0].elem1;
4130+ struct pair pair = unpair(&heap, &baseinfo);
4131+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
4132+ state.addr = pair.elem1;
4133+ }
4134+ break;
4135+ }
4136+ case 890786773858934784LLU: // varblock__
4137+ {
4138+ // union-constructor varblock__
4139+ {
4140+ uint64_t result_tuple = 0;
4141+ // copy references
4142+ // release parameters
4143+ {
4144+ uint64_t constridx = 3LLU;
4145+ uint64_t root = pair_move(&heap, &constridx, &result_tuple);
4146+ *access_heap(heap.data, LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*memory root*/)) = root;
4147+ }
4148+ }
4149+ {
4150+ uint64_t baseinfo = heap.data[0].elem1;
4151+ struct pair pair = unpair(&heap, &baseinfo);
4152+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
4153+ state.addr = pair.elem1;
4154+ }
4155+ break;
4156+ }
4157+ case 890788145081876480LLU: // varvirt___
4158+ {
4159+ // union-constructor varvirt___
4160+ {
4161+ uint64_t result_tuple = 0;
4162+ // copy references
4163+ {
4164+ uint64_t elem = *LOCAL_ACCESS(heap.data, 5LLU + 1, 0LLU + 1);
4165+ tree_push_move(&heap, 0LLU, &result_tuple, &elem);
4166+ }
4167+ {
4168+ uint64_t elem = *LOCAL_ACCESS(heap.data, 5LLU + 1, 1LLU + 1);
4169+ tree_push_move(&heap, 1LLU, &result_tuple, &elem);
4170+ }
4171+ {
4172+ uint64_t elem = *LOCAL_ACCESS(heap.data, 5LLU + 1, 2LLU + 1);
4173+ tree_push_move(&heap, 2LLU, &result_tuple, &elem);
4174+ }
4175+ {
4176+ uint64_t elem = *LOCAL_ACCESS(heap.data, 5LLU + 1, 3LLU + 1);
4177+ tree_push_move(&heap, 3LLU, &result_tuple, &elem);
4178+ }
4179+ {
4180+ uint64_t elem = *LOCAL_ACCESS(heap.data, 5LLU + 1, 4LLU + 1);
4181+ tree_push_move(&heap, 4LLU, &result_tuple, &elem);
4182+ }
4183+ // release parameters
4184+ {
4185+ (void)LOCAL_POP_MOVE(&heap, 5LLU + 1, &(heap.data[0].elem1)/*memory root*/);
4186+ }
4187+ {
4188+ (void)LOCAL_POP_MOVE(&heap, 4LLU + 1, &(heap.data[0].elem1)/*memory root*/);
4189+ }
4190+ {
4191+ (void)LOCAL_POP_MOVE(&heap, 3LLU + 1, &(heap.data[0].elem1)/*memory root*/);
4192+ }
4193+ {
4194+ (void)LOCAL_POP_MOVE(&heap, 2LLU + 1, &(heap.data[0].elem1)/*memory root*/);
4195+ }
4196+ {
4197+ (void)LOCAL_POP_MOVE(&heap, 1LLU + 1, &(heap.data[0].elem1)/*memory root*/);
4198+ }
4199+ {
4200+ uint64_t constridx = 2LLU;
4201+ uint64_t root = pair_move(&heap, &constridx, &result_tuple);
4202+ *access_heap(heap.data, LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*memory root*/)) = root;
4203+ }
4204+ }
4205+ {
4206+ uint64_t baseinfo = heap.data[0].elem1;
4207+ struct pair pair = unpair(&heap, &baseinfo);
4208+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
4209+ state.addr = pair.elem1;
4210+ }
4211+ break;
4212+ }
4213+ case 890787865695354880LLU: // varref____
4214+ {
4215+ // union-constructor varref____
4216+ {
4217+ uint64_t result_tuple = 0;
4218+ // copy references
4219+ {
4220+ uint64_t elem = *LOCAL_ACCESS(heap.data, 6LLU + 1, 0LLU + 1);
4221+ tree_push_move(&heap, 0LLU, &result_tuple, &elem);
4222+ }
4223+ {
4224+ uint64_t elem = *LOCAL_ACCESS(heap.data, 6LLU + 1, 1LLU + 1);
4225+ tree_push_move(&heap, 1LLU, &result_tuple, &elem);
4226+ }
4227+ {
4228+ uint64_t elem = *LOCAL_ACCESS(heap.data, 6LLU + 1, 2LLU + 1);
4229+ tree_push_move(&heap, 2LLU, &result_tuple, &elem);
4230+ }
4231+ {
4232+ uint64_t elem = *LOCAL_ACCESS(heap.data, 6LLU + 1, 3LLU + 1);
4233+ tree_push_move(&heap, 3LLU, &result_tuple, &elem);
4234+ }
4235+ {
4236+ uint64_t elem = *LOCAL_ACCESS(heap.data, 6LLU + 1, 4LLU + 1);
4237+ tree_push_move(&heap, 4LLU, &result_tuple, &elem);
4238+ }
4239+ {
4240+ uint64_t elem = *LOCAL_ACCESS(heap.data, 6LLU + 1, 5LLU + 1);
4241+ tree_push_move(&heap, 5LLU, &result_tuple, &elem);
4242+ }
4243+ // release parameters
4244+ {
4245+ (void)LOCAL_POP_MOVE(&heap, 6LLU + 1, &(heap.data[0].elem1)/*memory root*/);
4246+ }
4247+ {
4248+ (void)LOCAL_POP_MOVE(&heap, 5LLU + 1, &(heap.data[0].elem1)/*memory root*/);
4249+ }
4250+ {
4251+ (void)LOCAL_POP_MOVE(&heap, 4LLU + 1, &(heap.data[0].elem1)/*memory root*/);
4252+ }
4253+ {
4254+ (void)LOCAL_POP_MOVE(&heap, 3LLU + 1, &(heap.data[0].elem1)/*memory root*/);
4255+ }
4256+ {
4257+ (void)LOCAL_POP_MOVE(&heap, 2LLU + 1, &(heap.data[0].elem1)/*memory root*/);
4258+ }
4259+ {
4260+ (void)LOCAL_POP_MOVE(&heap, 1LLU + 1, &(heap.data[0].elem1)/*memory root*/);
4261+ }
4262+ {
4263+ uint64_t constridx = 1LLU;
4264+ uint64_t root = pair_move(&heap, &constridx, &result_tuple);
4265+ *access_heap(heap.data, LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*memory root*/)) = root;
4266+ }
4267+ }
4268+ {
4269+ uint64_t baseinfo = heap.data[0].elem1;
4270+ struct pair pair = unpair(&heap, &baseinfo);
4271+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
4272+ state.addr = pair.elem1;
4273+ }
4274+ break;
4275+ }
4276+ case 890788136479621120LLU: // varvar____
4277+ {
4278+ // union-constructor varvar____
4279+ {
4280+ uint64_t result_tuple = 0;
4281+ // copy references
4282+ {
4283+ uint64_t elem = *LOCAL_ACCESS(heap.data, 5LLU + 1, 0LLU + 1);
4284+ tree_push_move(&heap, 0LLU, &result_tuple, &elem);
4285+ }
4286+ {
4287+ uint64_t elem = *LOCAL_ACCESS(heap.data, 5LLU + 1, 1LLU + 1);
4288+ tree_push_move(&heap, 1LLU, &result_tuple, &elem);
4289+ }
4290+ {
4291+ uint64_t elem = *LOCAL_ACCESS(heap.data, 5LLU + 1, 2LLU + 1);
4292+ tree_push_move(&heap, 2LLU, &result_tuple, &elem);
4293+ }
4294+ {
4295+ uint64_t elem = *LOCAL_ACCESS(heap.data, 5LLU + 1, 3LLU + 1);
4296+ tree_push_move(&heap, 3LLU, &result_tuple, &elem);
4297+ }
4298+ {
4299+ uint64_t elem = *LOCAL_ACCESS(heap.data, 5LLU + 1, 4LLU + 1);
4300+ tree_push_move(&heap, 4LLU, &result_tuple, &elem);
4301+ }
4302+ // release parameters
4303+ {
4304+ (void)LOCAL_POP_MOVE(&heap, 5LLU + 1, &(heap.data[0].elem1)/*memory root*/);
4305+ }
4306+ {
4307+ (void)LOCAL_POP_MOVE(&heap, 4LLU + 1, &(heap.data[0].elem1)/*memory root*/);
4308+ }
4309+ {
4310+ (void)LOCAL_POP_MOVE(&heap, 3LLU + 1, &(heap.data[0].elem1)/*memory root*/);
4311+ }
4312+ {
4313+ (void)LOCAL_POP_MOVE(&heap, 2LLU + 1, &(heap.data[0].elem1)/*memory root*/);
4314+ }
4315+ {
4316+ (void)LOCAL_POP_MOVE(&heap, 1LLU + 1, &(heap.data[0].elem1)/*memory root*/);
4317+ }
4318+ {
4319+ uint64_t constridx = 0LLU;
4320+ uint64_t root = pair_move(&heap, &constridx, &result_tuple);
4321+ *access_heap(heap.data, LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*memory root*/)) = root;
4322+ }
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 819847183519304512LLU: // reportvar_
4333+ {
4334+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 0/*varvar____*/)
4335+ {
4336+ state.addr = 18446744073709551474LLU; // 999999997w'''''''''''''''
4337+ break;
4338+ }
4339+ {
4340+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU), 1LLU);
4341+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4342+ }
4343+ fprintf(stderr, "%s", "varvar");
4344+ // parameter-reference varkind___ __________ goes out of scope
4345+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
4346+ // parameter varkind___ __________ goes out of scope
4347+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
4348+ {
4349+ uint64_t baseinfo = heap.data[0].elem1;
4350+ struct pair pair = unpair(&heap, &baseinfo);
4351+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
4352+ state.addr = pair.elem1;
4353+ }
4354+ break;
4355+ }
4356+ case 18446744073709551474LLU: // 999999997w'''''''''''''''
4357+ {
4358+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 1/*varref____*/)
4359+ {
4360+ state.addr = 18446744073709551473LLU; // 999999997v'''''''''''''''
4361+ break;
4362+ }
4363+ {
4364+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU), 1LLU);
4365+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4366+ }
4367+ fprintf(stderr, "%s", "varref");
4368+ // parameter-reference varkind___ __________ goes out of scope
4369+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
4370+ // parameter varkind___ __________ goes out of scope
4371+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
4372+ {
4373+ uint64_t baseinfo = heap.data[0].elem1;
4374+ struct pair pair = unpair(&heap, &baseinfo);
4375+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
4376+ state.addr = pair.elem1;
4377+ }
4378+ break;
4379+ }
4380+ case 18446744073709551473LLU: // 999999997v'''''''''''''''
4381+ {
4382+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 2/*varvirt___*/)
4383+ {
4384+ state.addr = 18446744073709551472LLU; // 999999997u'''''''''''''''
4385+ break;
4386+ }
4387+ {
4388+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU), 1LLU);
4389+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4390+ }
4391+ fprintf(stderr, "%s", "varvirt");
4392+ // parameter-reference varkind___ __________ goes out of scope
4393+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
4394+ // parameter varkind___ __________ goes out of scope
4395+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
4396+ {
4397+ uint64_t baseinfo = heap.data[0].elem1;
4398+ struct pair pair = unpair(&heap, &baseinfo);
4399+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
4400+ state.addr = pair.elem1;
4401+ }
4402+ break;
4403+ }
4404+ case 18446744073709551472LLU: // 999999997u'''''''''''''''
4405+ {
4406+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 3/*varblock__*/)
4407+ {
4408+ state.addr = 18446744073709551471LLU; // 999999997t'''''''''''''''
4409+ break;
4410+ }
4411+ {
4412+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU), 1LLU);
4413+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4414+ }
4415+ fprintf(stderr, "%s", "varblock");
4416+ // parameter-reference varkind___ __________ goes out of scope
4417+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
4418+ // parameter varkind___ __________ goes out of scope
4419+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
4420+ {
4421+ uint64_t baseinfo = heap.data[0].elem1;
4422+ struct pair pair = unpair(&heap, &baseinfo);
4423+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
4424+ state.addr = pair.elem1;
4425+ }
4426+ break;
4427+ }
4428+ case 18446744073709551471LLU: // 999999997t'''''''''''''''
4429+ {
4430+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 4/*elblock___*/)
4431+ {
4432+ state.addr = 18446744073709551470LLU; // 999999997s'''''''''''''''
4433+ break;
4434+ }
4435+ {
4436+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU), 1LLU);
4437+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4438+ }
4439+ fprintf(stderr, "%s", "elblock");
4440+ // parameter-reference varkind___ __________ goes out of scope
4441+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
4442+ // parameter varkind___ __________ goes out of scope
4443+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
4444+ {
4445+ uint64_t baseinfo = heap.data[0].elem1;
4446+ struct pair pair = unpair(&heap, &baseinfo);
4447+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
4448+ state.addr = pair.elem1;
4449+ }
4450+ break;
4451+ }
4452+ case 18446744073709551470LLU: // 999999997s'''''''''''''''
4453+ {
4454+ if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 5/*varhide___*/)
4455+ {
4456+ state.addr = 18446744073709551469LLU; // 999999997r'''''''''''''''
4457+ break;
4458+ }
4459+ {
4460+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU), 1LLU);
4461+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4462+ }
4463+ fprintf(stderr, "%s", "varhide");
4464+ // parameter-reference varkind___ __________ goes out of scope
4465+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
4466+ // parameter varkind___ __________ goes out of scope
4467+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
4468+ {
4469+ uint64_t baseinfo = heap.data[0].elem1;
4470+ struct pair pair = unpair(&heap, &baseinfo);
4471+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
4472+ state.addr = pair.elem1;
4473+ }
4474+ break;
4475+ }
4476+ case 18446744073709551469LLU: // 999999997r'''''''''''''''
4477+ {
4478+ fprintf(stderr, "INTERNAL COMPILER ERROR: missing pattern-match-case in definition of reportvar_\n");
4479+ exit(-1);
4480+ break;
4481+ }
4482+ case 18446744073709551468LLU: // 999999997q'''''''''''''''
4483+ {
4484+ {
4485+ uint64_t arg = tree_pop_move(&heap, 4LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
4486+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4487+ }
4488+ // emitted destructur for type u64
4489+ // RELEASE temporary destructor-variable
4490+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
4491+ {
4492+ uint64_t arg = tree_pop_move(&heap, 3LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
4493+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4494+ }
4495+ // emitted destructur for type continuity
4496+ // ACCUMULATE ARGUMENTS - BEGIN
4497+ {
4498+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 2LLU, 1LLU);
4499+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4500+ }
4501+ // ACCUMULATE ARGUMENTS - END
4502+ uint64_t return_to = 18446744073709551467LLU;
4503+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4504+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4505+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
4506+ heap.data[0].elem1 = heap.data[0].elem0;
4507+ heap.data[0].elem0 = restore;
4508+ state.addr = 18446744073709551514LLU; // 999999998Z'''''''''''''''
4509+ break;
4510+ }
4511+ case 18446744073709551467LLU: // 999999997p'''''''''''''''
4512+ {
4513+ // RELEASE temporary destructor-variable
4514+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
4515+ {
4516+ uint64_t arg = tree_pop_move(&heap, 2LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
4517+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4518+ }
4519+ // emitted destructur for type u64
4520+ // RELEASE temporary destructor-variable
4521+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
4522+ {
4523+ uint64_t arg = tree_pop_move(&heap, 1LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
4524+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4525+ }
4526+ // emitted destructur for type type______
4527+ // ACCUMULATE ARGUMENTS - BEGIN
4528+ {
4529+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 2LLU, 1LLU);
4530+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4531+ }
4532+ // ACCUMULATE ARGUMENTS - END
4533+ uint64_t return_to = 18446744073709551466LLU;
4534+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4535+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4536+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
4537+ heap.data[0].elem1 = heap.data[0].elem0;
4538+ heap.data[0].elem0 = restore;
4539+ state.addr = 18446744073709551573LLU; // 999999999U'''''''''''''''
4540+ break;
4541+ }
4542+ case 18446744073709551466LLU: // 999999997o'''''''''''''''
4543+ {
4544+ // RELEASE temporary destructor-variable
4545+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
4546+ // RELEASE destructor-argument
4547+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 1
4548+ {
4549+ uint64_t baseinfo = heap.data[0].elem1;
4550+ struct pair pair = unpair(&heap, &baseinfo);
4551+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
4552+ state.addr = pair.elem1;
4553+ }
4554+ break;
4555+ }
4556+ case 782700512565788672LLU: // pardef____
4557+ {
4558+ // struct-constructor pardef____
4559+ {
4560+ uint64_t result_tuple = 0;
4561+ // copy references
4562+ {
4563+ uint64_t elem = *LOCAL_ACCESS(heap.data, 4LLU + 1, 0LLU + 1);
4564+ tree_push_move(&heap, 0LLU, &result_tuple, &elem);
4565+ }
4566+ {
4567+ uint64_t elem = *LOCAL_ACCESS(heap.data, 4LLU + 1, 1LLU + 1);
4568+ tree_push_move(&heap, 1LLU, &result_tuple, &elem);
4569+ }
4570+ {
4571+ uint64_t elem = *LOCAL_ACCESS(heap.data, 4LLU + 1, 2LLU + 1);
4572+ tree_push_move(&heap, 2LLU, &result_tuple, &elem);
4573+ }
4574+ {
4575+ uint64_t elem = *LOCAL_ACCESS(heap.data, 4LLU + 1, 3LLU + 1);
4576+ tree_push_move(&heap, 3LLU, &result_tuple, &elem);
4577+ }
4578+ // release parameters
4579+ {
4580+ (void)LOCAL_POP_MOVE(&heap, 4LLU + 1, &(heap.data[0].elem1)/*memory root*/);
4581+ }
4582+ {
4583+ (void)LOCAL_POP_MOVE(&heap, 3LLU + 1, &(heap.data[0].elem1)/*memory root*/);
4584+ }
4585+ {
4586+ (void)LOCAL_POP_MOVE(&heap, 2LLU + 1, &(heap.data[0].elem1)/*memory root*/);
4587+ }
4588+ {
4589+ (void)LOCAL_POP_MOVE(&heap, 1LLU + 1, &(heap.data[0].elem1)/*memory root*/);
4590+ }
4591+ *access_heap(heap.data, LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*memory root*/)) = result_tuple;
4592+ }
4593+ {
4594+ uint64_t baseinfo = heap.data[0].elem1;
4595+ struct pair pair = unpair(&heap, &baseinfo);
4596+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
4597+ state.addr = pair.elem1;
4598+ }
4599+ break;
4600+ }
4601+ case 18446744073709551465LLU: // 999999997n'''''''''''''''
4602+ {
4603+ {
4604+ uint64_t arg = tree_pop_move(&heap, 2LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
4605+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4606+ }
4607+ // emitted destructur for type type______
4608+ // ACCUMULATE ARGUMENTS - BEGIN
4609+ {
4610+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 2LLU, 1LLU);
4611+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4612+ }
4613+ // ACCUMULATE ARGUMENTS - END
4614+ uint64_t return_to = 18446744073709551464LLU;
4615+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4616+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4617+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
4618+ heap.data[0].elem1 = heap.data[0].elem0;
4619+ heap.data[0].elem0 = restore;
4620+ state.addr = 18446744073709551573LLU; // 999999999U'''''''''''''''
4621+ break;
4622+ }
4623+ case 18446744073709551464LLU: // 999999997m'''''''''''''''
4624+ {
4625+ // RELEASE temporary destructor-variable
4626+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
4627+ {
4628+ uint64_t arg = tree_pop_move(&heap, 1LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
4629+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4630+ }
4631+ // emitted destructur for type u64
4632+ // RELEASE temporary destructor-variable
4633+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
4634+ // RELEASE destructor-argument
4635+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 1
4636+ {
4637+ uint64_t baseinfo = heap.data[0].elem1;
4638+ struct pair pair = unpair(&heap, &baseinfo);
4639+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
4640+ state.addr = pair.elem1;
4641+ }
4642+ break;
4643+ }
4644+ case 587581796494082048LLU: // elemdef___
4645+ {
4646+ // struct-constructor elemdef___
4647+ {
4648+ uint64_t result_tuple = 0;
4649+ // copy references
4650+ {
4651+ uint64_t elem = *LOCAL_ACCESS(heap.data, 2LLU + 1, 0LLU + 1);
4652+ tree_push_move(&heap, 0LLU, &result_tuple, &elem);
4653+ }
4654+ {
4655+ uint64_t elem = *LOCAL_ACCESS(heap.data, 2LLU + 1, 1LLU + 1);
4656+ tree_push_move(&heap, 1LLU, &result_tuple, &elem);
4657+ }
4658+ // release parameters
4659+ {
4660+ (void)LOCAL_POP_MOVE(&heap, 2LLU + 1, &(heap.data[0].elem1)/*memory root*/);
4661+ }
4662+ {
4663+ (void)LOCAL_POP_MOVE(&heap, 1LLU + 1, &(heap.data[0].elem1)/*memory root*/);
4664+ }
4665+ *access_heap(heap.data, LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*memory root*/)) = result_tuple;
4666+ }
4667+ {
4668+ uint64_t baseinfo = heap.data[0].elem1;
4669+ struct pair pair = unpair(&heap, &baseinfo);
4670+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
4671+ state.addr = pair.elem1;
4672+ }
4673+ break;
4674+ }
4675+ case 18446744073709551463LLU: // 999999997l'''''''''''''''
4676+ {
4677+ {
4678+ uint64_t arg = tree_pop_move(&heap, 5LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
4679+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4680+ }
4681+ // emitted destructur for type u64
4682+ // RELEASE temporary destructor-variable
4683+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
4684+ {
4685+ uint64_t arg = tree_pop_move(&heap, 4LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
4686+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4687+ }
4688+ // emitted destructur for type type______
4689+ // ACCUMULATE ARGUMENTS - BEGIN
4690+ {
4691+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 2LLU, 1LLU);
4692+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4693+ }
4694+ // ACCUMULATE ARGUMENTS - END
4695+ uint64_t return_to = 18446744073709551462LLU;
4696+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4697+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4698+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
4699+ heap.data[0].elem1 = heap.data[0].elem0;
4700+ heap.data[0].elem0 = restore;
4701+ state.addr = 18446744073709551573LLU; // 999999999U'''''''''''''''
4702+ break;
4703+ }
4704+ case 18446744073709551462LLU: // 999999997k'''''''''''''''
4705+ {
4706+ // RELEASE temporary destructor-variable
4707+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
4708+ {
4709+ uint64_t arg = tree_pop_move(&heap, 3LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
4710+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4711+ }
4712+ // emitted destructur for type u64
4713+ // RELEASE temporary destructor-variable
4714+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
4715+ {
4716+ uint64_t arg = tree_pop_move(&heap, 2LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
4717+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4718+ }
4719+ // emitted destructur for type continuity
4720+ // ACCUMULATE ARGUMENTS - BEGIN
4721+ {
4722+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 2LLU, 1LLU);
4723+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4724+ }
4725+ // ACCUMULATE ARGUMENTS - END
4726+ uint64_t return_to = 18446744073709551461LLU;
4727+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4728+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4729+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
4730+ heap.data[0].elem1 = heap.data[0].elem0;
4731+ heap.data[0].elem0 = restore;
4732+ state.addr = 18446744073709551514LLU; // 999999998Z'''''''''''''''
4733+ break;
4734+ }
4735+ case 18446744073709551461LLU: // 999999997j'''''''''''''''
4736+ {
4737+ // RELEASE temporary destructor-variable
4738+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
4739+ {
4740+ uint64_t arg = tree_pop_move(&heap, 1LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
4741+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4742+ }
4743+ // emitted destructur for type u64
4744+ // RELEASE temporary destructor-variable
4745+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
4746+ // RELEASE destructor-argument
4747+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 1
4748+ {
4749+ uint64_t baseinfo = heap.data[0].elem1;
4750+ struct pair pair = unpair(&heap, &baseinfo);
4751+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
4752+ state.addr = pair.elem1;
4753+ }
4754+ break;
4755+ }
4756+ case 838947815509196800LLU: // signdef___
4757+ {
4758+ // struct-constructor signdef___
4759+ {
4760+ uint64_t result_tuple = 0;
4761+ // copy references
4762+ {
4763+ uint64_t elem = *LOCAL_ACCESS(heap.data, 5LLU + 1, 0LLU + 1);
4764+ tree_push_move(&heap, 0LLU, &result_tuple, &elem);
4765+ }
4766+ {
4767+ uint64_t elem = *LOCAL_ACCESS(heap.data, 5LLU + 1, 1LLU + 1);
4768+ tree_push_move(&heap, 1LLU, &result_tuple, &elem);
4769+ }
4770+ {
4771+ uint64_t elem = *LOCAL_ACCESS(heap.data, 5LLU + 1, 2LLU + 1);
4772+ tree_push_move(&heap, 2LLU, &result_tuple, &elem);
4773+ }
4774+ {
4775+ uint64_t elem = *LOCAL_ACCESS(heap.data, 5LLU + 1, 3LLU + 1);
4776+ tree_push_move(&heap, 3LLU, &result_tuple, &elem);
4777+ }
4778+ {
4779+ uint64_t elem = *LOCAL_ACCESS(heap.data, 5LLU + 1, 4LLU + 1);
4780+ tree_push_move(&heap, 4LLU, &result_tuple, &elem);
4781+ }
4782+ // release parameters
4783+ {
4784+ (void)LOCAL_POP_MOVE(&heap, 5LLU + 1, &(heap.data[0].elem1)/*memory root*/);
4785+ }
4786+ {
4787+ (void)LOCAL_POP_MOVE(&heap, 4LLU + 1, &(heap.data[0].elem1)/*memory root*/);
4788+ }
4789+ {
4790+ (void)LOCAL_POP_MOVE(&heap, 3LLU + 1, &(heap.data[0].elem1)/*memory root*/);
4791+ }
4792+ {
4793+ (void)LOCAL_POP_MOVE(&heap, 2LLU + 1, &(heap.data[0].elem1)/*memory root*/);
4794+ }
4795+ {
4796+ (void)LOCAL_POP_MOVE(&heap, 1LLU + 1, &(heap.data[0].elem1)/*memory root*/);
4797+ }
4798+ *access_heap(heap.data, LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*memory root*/)) = result_tuple;
4799+ }
4800+ {
4801+ uint64_t baseinfo = heap.data[0].elem1;
4802+ struct pair pair = unpair(&heap, &baseinfo);
4803+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
4804+ state.addr = pair.elem1;
4805+ }
4806+ break;
4807+ }
4808+ case 552740200527038528LLU: // cpsigndef_
4809+ {
4810+ {
4811+ uint64_t arg = tree_elem_addr(heap.data, 5LLU, *LOCAL_ACCESS(heap.data, 2LLU, 0LLU), 0LLU);
4812+ LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4813+ }
4814+ {
4815+ uint64_t arg = tree_elem_addr(heap.data, 5LLU, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU), 1LLU);
4816+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4817+ }
4818+ {
4819+ uint64_t arg = tree_elem_addr(heap.data, 5LLU, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU), 2LLU);
4820+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4821+ }
4822+ {
4823+ uint64_t arg = tree_elem_addr(heap.data, 5LLU, *LOCAL_ACCESS(heap.data, 5LLU, 0LLU), 3LLU);
4824+ LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4825+ }
4826+ {
4827+ uint64_t arg = tree_elem_addr(heap.data, 5LLU, *LOCAL_ACCESS(heap.data, 6LLU, 0LLU), 4LLU);
4828+ LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4829+ }
4830+ {
4831+ uint64_t arg = tree_elem_addr(heap.data, 5LLU, *LOCAL_ACCESS(heap.data, 7LLU, 1LLU), 0LLU);
4832+ LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4833+ }
4834+ {
4835+ uint64_t arg = tree_elem_addr(heap.data, 5LLU, *LOCAL_ACCESS(heap.data, 8LLU, 1LLU), 1LLU);
4836+ LOCAL_PUSH_MOVE(&heap, 8, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4837+ }
4838+ {
4839+ uint64_t arg = tree_elem_addr(heap.data, 5LLU, *LOCAL_ACCESS(heap.data, 9LLU, 1LLU), 2LLU);
4840+ LOCAL_PUSH_MOVE(&heap, 9, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4841+ }
4842+ {
4843+ uint64_t arg = tree_elem_addr(heap.data, 5LLU, *LOCAL_ACCESS(heap.data, 10LLU, 1LLU), 3LLU);
4844+ LOCAL_PUSH_MOVE(&heap, 10, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4845+ }
4846+ {
4847+ uint64_t arg = tree_elem_addr(heap.data, 5LLU, *LOCAL_ACCESS(heap.data, 11LLU, 1LLU), 4LLU);
4848+ LOCAL_PUSH_MOVE(&heap, 11, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4849+ }
4850+
4851+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 12LLU, 2LLU)) = /*indirect1_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 12LLU, 7LLU));
4852+
4853+ // emitted destructur for type continuity
4854+ // ACCUMULATE ARGUMENTS - BEGIN
4855+ {
4856+ uint64_t arg = *LOCAL_ACCESS(heap.data, 12LLU, 3LLU);
4857+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4858+ }
4859+ // ACCUMULATE ARGUMENTS - END
4860+ uint64_t return_to = 18446744073709551459LLU;
4861+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4862+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4863+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
4864+ heap.data[0].elem1 = heap.data[0].elem0;
4865+ heap.data[0].elem0 = restore;
4866+ state.addr = 18446744073709551514LLU; // 999999998Z'''''''''''''''
4867+ break;
4868+ }
4869+ case 18446744073709551459LLU: // 999999997h'''''''''''''''
4870+ {
4871+ // ACCUMULATE ARGUMENTS - BEGIN
4872+ {
4873+ uint64_t arg = *LOCAL_ACCESS(heap.data, 12LLU, 3LLU);
4874+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4875+ }
4876+ {
4877+ uint64_t arg = /*cont1_____*/*LOCAL_ACCESS(heap.data, 12LLU, 8LLU);
4878+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4879+ }
4880+ // ACCUMULATE ARGUMENTS - END
4881+ uint64_t return_to = 18446744073709551458LLU;
4882+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
4883+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4884+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
4885+ heap.data[0].elem1 = heap.data[0].elem0;
4886+ heap.data[0].elem0 = restore;
4887+ state.addr = 58555672873677120LLU; // CPBALANCE_
4888+ break;
4889+ }
4890+ case 18446744073709551458LLU: // 999999997g'''''''''''''''
4891+ {
4892+
4893+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 12LLU, 4LLU)) = /*mutable1__*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 12LLU, 9LLU));
4894+
4895+ // emitted destructur for type type______
4896+ // ACCUMULATE ARGUMENTS - BEGIN
4897+ {
4898+ uint64_t arg = *LOCAL_ACCESS(heap.data, 12LLU, 5LLU);
4899+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4900+ }
4901+ // ACCUMULATE ARGUMENTS - END
4902+ uint64_t return_to = 18446744073709551457LLU;
4903+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4904+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4905+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
4906+ heap.data[0].elem1 = heap.data[0].elem0;
4907+ heap.data[0].elem0 = restore;
4908+ state.addr = 18446744073709551573LLU; // 999999999U'''''''''''''''
4909+ break;
4910+ }
4911+ case 18446744073709551457LLU: // 999999997f'''''''''''''''
4912+ {
4913+ // ACCUMULATE ARGUMENTS - BEGIN
4914+ {
4915+ uint64_t arg = *LOCAL_ACCESS(heap.data, 12LLU, 5LLU);
4916+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4917+ }
4918+ {
4919+ uint64_t arg = /*type1_____*/*LOCAL_ACCESS(heap.data, 12LLU, 10LLU);
4920+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4921+ }
4922+ // ACCUMULATE ARGUMENTS - END
4923+ uint64_t return_to = 18446744073709551456LLU;
4924+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
4925+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4926+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
4927+ heap.data[0].elem1 = heap.data[0].elem0;
4928+ heap.data[0].elem0 = restore;
4929+ state.addr = 367395560426147840LLU; // TYPECOPY__
4930+ break;
4931+ }
4932+ case 18446744073709551456LLU: // 999999997e'''''''''''''''
4933+ {
4934+
4935+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 12LLU, 6LLU)) = /*curidx1___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 12LLU, 11LLU));
4936+ // parameter-reference u64 curidx1___ goes out of scope
4937+ (void)LOCAL_POP_MOVE(&heap, 12LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference curidx1___ at 12
4938+ // parameter-reference type______ type1_____ goes out of scope
4939+ (void)LOCAL_POP_MOVE(&heap, 11LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type1_____ at 11
4940+ // parameter-reference u64 mutable1__ goes out of scope
4941+ (void)LOCAL_POP_MOVE(&heap, 10LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference mutable1__ at 10
4942+ // parameter-reference continuity cont1_____ goes out of scope
4943+ (void)LOCAL_POP_MOVE(&heap, 9LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference cont1_____ at 9
4944+ // parameter-reference u64 indirect1_ goes out of scope
4945+ (void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference indirect1_ at 8
4946+ // parameter-reference signdef___ __________ goes out of scope
4947+ (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 7
4948+ // parameter-reference u64 curidx0___ goes out of scope
4949+ (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference curidx0___ at 6
4950+ // parameter-reference type______ type0_____ goes out of scope
4951+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type0_____ at 5
4952+ // parameter-reference u64 mutable0__ goes out of scope
4953+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference mutable0__ at 4
4954+ // parameter-reference continuity cont0_____ goes out of scope
4955+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference cont0_____ at 3
4956+ // parameter-reference u64 indirect0_ goes out of scope
4957+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference indirect0_ at 2
4958+ // parameter-reference signdef___ __________ goes out of scope
4959+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
4960+ {
4961+ uint64_t baseinfo = heap.data[0].elem1;
4962+ struct pair pair = unpair(&heap, &baseinfo);
4963+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
4964+ state.addr = pair.elem1;
4965+ }
4966+ break;
4967+ }
4968+ case 589059743276730432LLU: // equpardef_
4969+ {
4970+
4971+ // ACCUMULATE ARGUMENTS - BEGIN
4972+ {
4973+ uint64_t arg = *LOCAL_ACCESS(heap.data, 3LLU, 0LLU);
4974+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4975+ }
4976+ {
4977+ uint64_t arg = /*x_________*/tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 0LLU);
4978+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4979+ }
4980+ {
4981+ uint64_t arg = /*y_________*/tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 3LLU, 2LLU), 0LLU);
4982+ LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4983+ }
4984+ // ACCUMULATE ARGUMENTS - END
4985+ uint64_t return_to = 18446744073709551455LLU;
4986+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0));
4987+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4988+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
4989+ heap.data[0].elem1 = heap.data[0].elem0;
4990+ heap.data[0].elem0 = restore;
4991+ state.addr = 589060043891015680LLU; // equtype___
4992+ break;
4993+ }
4994+ case 18446744073709551455LLU: // 999999997d'''''''''''''''
4995+ {
4996+ {
4997+ uint64_t arg = 0;
4998+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4999+ }
5000+ *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /*equal_____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU));
5001+ state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551454LLU : 18446744073709551453LLU;
5002+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
5003+ break;
5004+ }
5005+ case 18446744073709551454LLU: // 999999997c'''''''''''''''
5006+ {
5007+ state.addr = 18446744073709551452LLU; // 999999997a'''''''''''''''
5008+ break;
5009+ }
5010+ case 18446744073709551453LLU: // 999999997b'''''''''''''''
5011+ {
5012+ fprintf(stderr, "%s", "type");
5013+ state.addr = 18446744073709551452LLU; // 999999997a'''''''''''''''
5014+ break;
5015+ }
5016+ case 18446744073709551452LLU: // 999999997a'''''''''''''''
5017+ {
5018+ {
5019+ uint64_t arg = 0;
5020+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5021+ }
5022+ *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /*equal_____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU));
5023+ state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551451LLU : 18446744073709551450LLU;
5024+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
5025+ break;
5026+ }
5027+ case 18446744073709551451LLU: // 999999997$'''''''''''''''
5028+ {
5029+
5030+ *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));
5031+ {
5032+ uint64_t arg = 0;
5033+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5034+ }
5035+ *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /*equal_____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU));
5036+ state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551449LLU : 18446744073709551448LLU;
5037+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
5038+ break;
5039+ }
5040+ case 18446744073709551449LLU: // 999999997Y'''''''''''''''
5041+ {
5042+ state.addr = 18446744073709551447LLU; // 999999997W'''''''''''''''
5043+ break;
5044+ }
5045+ case 18446744073709551448LLU: // 999999997X'''''''''''''''
5046+ {
5047+ fprintf(stderr, "%s", "mutable");
5048+ state.addr = 18446744073709551447LLU; // 999999997W'''''''''''''''
5049+ break;
5050+ }
5051+ case 18446744073709551447LLU: // 999999997W'''''''''''''''
5052+ {
5053+ {
5054+ uint64_t arg = 0;
5055+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5056+ }
5057+ *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /*equal_____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU));
5058+ state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551446LLU : 18446744073709551445LLU;
5059+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
5060+ break;
5061+ }
5062+ case 18446744073709551446LLU: // 999999997V'''''''''''''''
5063+ {
5064+
5065+ // ACCUMULATE ARGUMENTS - BEGIN
5066+ {
5067+ uint64_t arg = *LOCAL_ACCESS(heap.data, 3LLU, 0LLU);
5068+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5069+ }
5070+ {
5071+ uint64_t arg = /*x_________*/tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 2LLU);
5072+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5073+ }
5074+ {
5075+ uint64_t arg = /*y_________*/tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 3LLU, 2LLU), 2LLU);
5076+ LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5077+ }
5078+ // ACCUMULATE ARGUMENTS - END
5079+ uint64_t return_to = 18446744073709551444LLU;
5080+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0));
5081+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5082+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
5083+ heap.data[0].elem1 = heap.data[0].elem0;
5084+ heap.data[0].elem0 = restore;
5085+ state.addr = 589058781102643104LLU; // equbalance
5086+ break;
5087+ }
5088+ case 18446744073709551444LLU: // 999999997T'''''''''''''''
5089+ {
5090+ {
5091+ uint64_t arg = 0;
5092+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5093+ }
5094+ *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /*equal_____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU));
5095+ state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551443LLU : 18446744073709551442LLU;
5096+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
5097+ break;
5098+ }
5099+ case 18446744073709551443LLU: // 999999997S'''''''''''''''
5100+ {
5101+ state.addr = 18446744073709551441LLU; // 999999997Q'''''''''''''''
5102+ break;
5103+ }
5104+ case 18446744073709551442LLU: // 999999997R'''''''''''''''
5105+ {
5106+ fprintf(stderr, "%s", "continuity");
5107+ state.addr = 18446744073709551441LLU; // 999999997Q'''''''''''''''
5108+ break;
5109+ }
5110+ case 18446744073709551441LLU: // 999999997Q'''''''''''''''
5111+ {
5112+ {
5113+ uint64_t arg = 0;
5114+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5115+ }
5116+ *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /*equal_____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU));
5117+ state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551440LLU : 18446744073709551439LLU;
5118+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
5119+ break;
5120+ }
5121+ case 18446744073709551440LLU: // 999999997P'''''''''''''''
5122+ {
5123+
5124+ *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));
5125+ {
5126+ uint64_t arg = 0;
5127+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5128+ }
5129+ *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /*equal_____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU));
5130+ state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551438LLU : 18446744073709551437LLU;
5131+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
5132+ break;
5133+ }
5134+ case 18446744073709551438LLU: // 999999997N'''''''''''''''
5135+ {
5136+ state.addr = 18446744073709551436LLU; // 999999997L'''''''''''''''
5137+ break;
5138+ }
5139+ case 18446744073709551437LLU: // 999999997M'''''''''''''''
5140+ {
5141+ fprintf(stderr, "%s", "REFERENCE");
5142+ state.addr = 18446744073709551436LLU; // 999999997L'''''''''''''''
5143+ break;
5144+ }
5145+ case 18446744073709551436LLU: // 999999997L'''''''''''''''
5146+ {
5147+ state.addr = 18446744073709551439LLU; // 999999997O'''''''''''''''
5148+ break;
5149+ }
5150+ case 18446744073709551439LLU: // 999999997O'''''''''''''''
5151+ {
5152+ state.addr = 18446744073709551445LLU; // 999999997U'''''''''''''''
5153+ break;
5154+ }
5155+ case 18446744073709551445LLU: // 999999997U'''''''''''''''
5156+ {
5157+ state.addr = 18446744073709551450LLU; // 999999997Z'''''''''''''''
5158+ break;
5159+ }
5160+ case 18446744073709551450LLU: // 999999997Z'''''''''''''''
5161+ {
5162+ // parameter-reference pardef____ y_________ goes out of scope
5163+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference y_________ at 3
5164+ // parameter-reference pardef____ x_________ goes out of scope
5165+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference x_________ at 2
5166+ // parameter-reference u64 equal_____ goes out of scope
5167+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference equal_____ at 1
5168+ {
5169+ uint64_t baseinfo = heap.data[0].elem1;
5170+ struct pair pair = unpair(&heap, &baseinfo);
5171+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
5172+ state.addr = pair.elem1;
5173+ }
5174+ break;
5175+ }
5176+ case 589058998957897761LLU: // equelemdef
5177+ {
5178+
5179+ *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));
5180+ {
5181+ uint64_t arg = 0;
5182+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5183+ }
5184+ *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /*equal_____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU));
5185+ state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551435LLU : 18446744073709551434LLU;
5186+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
5187+ break;
5188+ }
5189+ case 18446744073709551435LLU: // 999999997K'''''''''''''''
5190+ {
5191+
5192+ // ACCUMULATE ARGUMENTS - BEGIN
5193+ {
5194+ uint64_t arg = *LOCAL_ACCESS(heap.data, 3LLU, 0LLU);
5195+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5196+ }
5197+ {
5198+ uint64_t arg = /*x_________*/tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 1LLU);
5199+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5200+ }
5201+ {
5202+ uint64_t arg = /*y_________*/tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 3LLU, 2LLU), 1LLU);
5203+ LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5204+ }
5205+ // ACCUMULATE ARGUMENTS - END
5206+ uint64_t return_to = 18446744073709551433LLU;
5207+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0));
5208+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5209+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
5210+ heap.data[0].elem1 = heap.data[0].elem0;
5211+ heap.data[0].elem0 = restore;
5212+ state.addr = 589060043891015680LLU; // equtype___
5213+ break;
5214+ }
5215+ case 18446744073709551433LLU: // 999999997I'''''''''''''''
5216+ {
5217+ state.addr = 18446744073709551434LLU; // 999999997J'''''''''''''''
5218+ break;
5219+ }
5220+ case 18446744073709551434LLU: // 999999997J'''''''''''''''
5221+ {
5222+ // parameter-reference elemdef___ y_________ goes out of scope
5223+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference y_________ at 3
5224+ // parameter-reference elemdef___ x_________ goes out of scope
5225+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference x_________ at 2
5226+ // parameter-reference u64 equal_____ goes out of scope
5227+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference equal_____ at 1
5228+ {
5229+ uint64_t baseinfo = heap.data[0].elem1;
5230+ struct pair pair = unpair(&heap, &baseinfo);
5231+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
5232+ state.addr = pair.elem1;
5233+ }
5234+ break;
5235+ }
5236+ case 782700512573827828LLU: // pardefcopy
5237+ {
5238+ {
5239+ uint64_t arg = tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 2LLU, 0LLU), 0LLU);
5240+ LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5241+ }
5242+ {
5243+ uint64_t arg = tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU), 1LLU);
5244+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5245+ }
5246+ {
5247+ uint64_t arg = tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU), 2LLU);
5248+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5249+ }
5250+ {
5251+ uint64_t arg = tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 5LLU, 0LLU), 3LLU);
5252+ LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5253+ }
5254+ {
5255+ uint64_t arg = tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 6LLU, 1LLU), 0LLU);
5256+ LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5257+ }
5258+ {
5259+ uint64_t arg = tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 7LLU, 1LLU), 1LLU);
5260+ LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5261+ }
5262+ {
5263+ uint64_t arg = tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 8LLU, 1LLU), 2LLU);
5264+ LOCAL_PUSH_MOVE(&heap, 8, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5265+ }
5266+ {
5267+ uint64_t arg = tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 9LLU, 1LLU), 3LLU);
5268+ LOCAL_PUSH_MOVE(&heap, 9, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5269+ }
5270+
5271+ // emitted destructur for type type______
5272+ // ACCUMULATE ARGUMENTS - BEGIN
5273+ {
5274+ uint64_t arg = *LOCAL_ACCESS(heap.data, 10LLU, 2LLU);
5275+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5276+ }
5277+ // ACCUMULATE ARGUMENTS - END
5278+ uint64_t return_to = 18446744073709551431LLU;
5279+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5280+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5281+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
5282+ heap.data[0].elem1 = heap.data[0].elem0;
5283+ heap.data[0].elem0 = restore;
5284+ state.addr = 18446744073709551573LLU; // 999999999U'''''''''''''''
5285+ break;
5286+ }
5287+ case 18446744073709551431LLU: // 999999997G'''''''''''''''
5288+ {
5289+ // ACCUMULATE ARGUMENTS - BEGIN
5290+ {
5291+ uint64_t arg = *LOCAL_ACCESS(heap.data, 10LLU, 2LLU);
5292+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5293+ }
5294+ {
5295+ uint64_t arg = /*type1_____*/*LOCAL_ACCESS(heap.data, 10LLU, 6LLU);
5296+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5297+ }
5298+ // ACCUMULATE ARGUMENTS - END
5299+ uint64_t return_to = 18446744073709551430LLU;
5300+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
5301+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5302+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
5303+ heap.data[0].elem1 = heap.data[0].elem0;
5304+ heap.data[0].elem0 = restore;
5305+ state.addr = 367395560426147840LLU; // TYPECOPY__
5306+ break;
5307+ }
5308+ case 18446744073709551430LLU: // 999999997F'''''''''''''''
5309+ {
5310+
5311+ // emitted destructur for type continuity
5312+ // ACCUMULATE ARGUMENTS - BEGIN
5313+ {
5314+ uint64_t arg = *LOCAL_ACCESS(heap.data, 10LLU, 4LLU);
5315+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5316+ }
5317+ // ACCUMULATE ARGUMENTS - END
5318+ uint64_t return_to = 18446744073709551429LLU;
5319+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5320+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5321+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
5322+ heap.data[0].elem1 = heap.data[0].elem0;
5323+ heap.data[0].elem0 = restore;
5324+ state.addr = 18446744073709551514LLU; // 999999998Z'''''''''''''''
5325+ break;
5326+ }
5327+ case 18446744073709551429LLU: // 999999997E'''''''''''''''
5328+ {
5329+ // ACCUMULATE ARGUMENTS - BEGIN
5330+ {
5331+ uint64_t arg = *LOCAL_ACCESS(heap.data, 10LLU, 4LLU);
5332+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5333+ }
5334+ {
5335+ uint64_t arg = /*balance1__*/*LOCAL_ACCESS(heap.data, 10LLU, 8LLU);
5336+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5337+ }
5338+ // ACCUMULATE ARGUMENTS - END
5339+ uint64_t return_to = 18446744073709551428LLU;
5340+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
5341+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5342+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
5343+ heap.data[0].elem1 = heap.data[0].elem0;
5344+ heap.data[0].elem0 = restore;
5345+ state.addr = 58555672873677120LLU; // CPBALANCE_
5346+ break;
5347+ }
5348+ case 18446744073709551428LLU: // 999999997D'''''''''''''''
5349+ {
5350+
5351+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 10LLU, 3LLU)) = /*mutable1__*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 10LLU, 7LLU));
5352+
5353+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 10LLU, 5LLU)) = /*reference1*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 10LLU, 9LLU));
5354+ // parameter-reference u64 reference1 goes out of scope
5355+ (void)LOCAL_POP_MOVE(&heap, 10LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference reference1 at 10
5356+ // parameter-reference continuity balance1__ goes out of scope
5357+ (void)LOCAL_POP_MOVE(&heap, 9LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference balance1__ at 9
5358+ // parameter-reference u64 mutable1__ goes out of scope
5359+ (void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference mutable1__ at 8
5360+ // parameter-reference type______ type1_____ goes out of scope
5361+ (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type1_____ at 7
5362+ // parameter-reference pardef____ __________ goes out of scope
5363+ (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 6
5364+ // parameter-reference u64 reference0 goes out of scope
5365+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference reference0 at 5
5366+ // parameter-reference continuity balance0__ goes out of scope
5367+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference balance0__ at 4
5368+ // parameter-reference u64 mutable0__ goes out of scope
5369+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference mutable0__ at 3
5370+ // parameter-reference type______ type0_____ goes out of scope
5371+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type0_____ at 2
5372+ // parameter-reference pardef____ __________ goes out of scope
5373+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
5374+ {
5375+ uint64_t baseinfo = heap.data[0].elem1;
5376+ struct pair pair = unpair(&heap, &baseinfo);
5377+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
5378+ state.addr = pair.elem1;
5379+ }
5380+ break;
5381+ }
5382+ case 296309897384864500LLU: // ParDefCopy
5383+ {
5384+ {
5385+ uint64_t arg = tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU), 0LLU);
5386+ LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5387+ }
5388+ {
5389+ uint64_t arg = tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 1LLU);
5390+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5391+ }
5392+ {
5393+ uint64_t arg = tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 4LLU, 1LLU), 2LLU);
5394+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5395+ }
5396+ {
5397+ uint64_t arg = tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 5LLU, 1LLU), 3LLU);
5398+ LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5399+ }
5400+ // ACCUMULATE ARGUMENTS - BEGIN
5401+ {
5402+ uint64_t arg = *LOCAL_ACCESS(heap.data, 6LLU, 0LLU);
5403+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5404+ }
5405+ {
5406+ uint64_t arg = heap.data[0].elem0;
5407+ LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5408+ }
5409+ {
5410+ uint64_t arg = 0;
5411+ LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5412+ }
5413+ // ACCUMULATE ARGUMENTS - BEGIN
5414+ {
5415+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 8LLU, 7LLU);
5416+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5417+ }
5418+ {
5419+ uint64_t arg = /*type1_____*/*LOCAL_ACCESS(heap.data, 8LLU, 2LLU);
5420+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5421+ }
5422+ // ACCUMULATE ARGUMENTS - END
5423+ uint64_t return_to = 18446744073709551425LLU;
5424+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
5425+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5426+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
5427+ heap.data[0].elem1 = heap.data[0].elem0;
5428+ heap.data[0].elem0 = restore;
5429+ state.addr = 367395560426147840LLU; // TYPECOPY__
5430+ break;
5431+ }
5432+ case 18446744073709551425LLU: // 999999997A'''''''''''''''
5433+ {
5434+ {
5435+ uint64_t exchange = LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 8*/;
5436+ heap.data[0].elem0 = LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 7*/;
5437+
5438+ {
5439+ uint64_t arg = exchange;
5440+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5441+ }
5442+ }
5443+ {
5444+ uint64_t arg = heap.data[0].elem0;
5445+ LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5446+ }
5447+ {
5448+ uint64_t arg = 0;
5449+ LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5450+ }
5451+ // ACCUMULATE ARGUMENTS - BEGIN
5452+ {
5453+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 8LLU, 7LLU);
5454+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5455+ }
5456+ {
5457+ uint64_t arg = /*mutable1__*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 8LLU, 3LLU));
5458+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5459+ }
5460+ // ACCUMULATE ARGUMENTS - END
5461+ uint64_t return_to = 18446744073709551424LLU;
5462+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
5463+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5464+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
5465+ heap.data[0].elem1 = heap.data[0].elem0;
5466+ heap.data[0].elem0 = restore;
5467+ state.addr = 552446646280519680LLU; // copyu64___
5468+ break;
5469+ }
5470+ case 18446744073709551424LLU: // 999999997_'''''''''''''''
5471+ {
5472+ {
5473+ uint64_t exchange = LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 8*/;
5474+ heap.data[0].elem0 = LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 7*/;
5475+
5476+ {
5477+ uint64_t arg = exchange;
5478+ LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5479+ }
5480+ }
5481+ {
5482+ uint64_t arg = heap.data[0].elem0;
5483+ LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5484+ }
5485+ {
5486+ uint64_t arg = 0;
5487+ LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5488+ }
5489+ // ACCUMULATE ARGUMENTS - BEGIN
5490+ {
5491+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 8LLU, 7LLU);
5492+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5493+ }
5494+ {
5495+ uint64_t arg = /*balance1__*/*LOCAL_ACCESS(heap.data, 8LLU, 4LLU);
5496+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5497+ }
5498+ // ACCUMULATE ARGUMENTS - END
5499+ uint64_t return_to = 18446744073709551423LLU;
5500+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
5501+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5502+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
5503+ heap.data[0].elem1 = heap.data[0].elem0;
5504+ heap.data[0].elem0 = restore;
5505+ state.addr = 58555672873677120LLU; // CPBALANCE_
5506+ break;
5507+ }
5508+ case 18446744073709551423LLU: // 9999999969'''''''''''''''
5509+ {
5510+ {
5511+ uint64_t exchange = LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 8*/;
5512+ heap.data[0].elem0 = LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 7*/;
5513+
5514+ {
5515+ uint64_t arg = exchange;
5516+ LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5517+ }
5518+ }
5519+ {
5520+ uint64_t arg = heap.data[0].elem0;
5521+ LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5522+ }
5523+ {
5524+ uint64_t arg = 0;
5525+ LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5526+ }
5527+ // ACCUMULATE ARGUMENTS - BEGIN
5528+ {
5529+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 8LLU, 7LLU);
5530+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5531+ }
5532+ {
5533+ uint64_t arg = /*reference1*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 8LLU, 5LLU));
5534+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5535+ }
5536+ // ACCUMULATE ARGUMENTS - END
5537+ uint64_t return_to = 18446744073709551422LLU;
5538+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
5539+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5540+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
5541+ heap.data[0].elem1 = heap.data[0].elem0;
5542+ heap.data[0].elem0 = restore;
5543+ state.addr = 552446646280519680LLU; // copyu64___
5544+ break;
5545+ }
5546+ case 18446744073709551422LLU: // 9999999968'''''''''''''''
5547+ {
5548+ {
5549+ uint64_t exchange = LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 8*/;
5550+ heap.data[0].elem0 = LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 7*/;
5551+
5552+ {
5553+ uint64_t arg = exchange;
5554+ LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5555+ }
5556+ }
5557+ // ACCUMULATE ARGUMENTS - END
5558+ uint64_t return_to = 18446744073709551426LLU;
5559+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0));
5560+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5561+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
5562+ heap.data[0].elem1 = heap.data[0].elem0;
5563+ heap.data[0].elem0 = restore;
5564+ state.addr = 782700512565788672LLU; // pardef____
5565+ break;
5566+ }
5567+ case 18446744073709551426LLU: // 999999997B'''''''''''''''
5568+ {
5569+ // parameter-reference u64 reference1 goes out of scope
5570+ (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference reference1 at 6
5571+ // parameter-reference continuity balance1__ goes out of scope
5572+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference balance1__ at 5
5573+ // parameter-reference u64 mutable1__ goes out of scope
5574+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference mutable1__ at 4
5575+ // parameter-reference type______ type1_____ goes out of scope
5576+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type1_____ at 3
5577+ // parameter-reference pardef____ __________ goes out of scope
5578+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
5579+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
5580+ {
5581+ uint64_t baseinfo = heap.data[0].elem1;
5582+ struct pair pair = unpair(&heap, &baseinfo);
5583+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
5584+ state.addr = pair.elem1;
5585+ }
5586+ break;
5587+ }
5588+ case 782700512577972928LLU: // pardefscp_
5589+ {
5590+ {
5591+ uint64_t arg = 0;
5592+ LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5593+ }
5594+ {
5595+ uint64_t arg = /*srcs______*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU));
5596+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5597+ }
5598+ {
5599+ uint64_t arg = 0;
5600+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5601+ }
5602+ state.addr = 18446744073709551421LLU; // 9999999967'''''''''''''''
5603+ break;
5604+ }
5605+ case 18446744073709551421LLU: // 9999999967'''''''''''''''
5606+ {
5607+ if(!*LOCAL_ACCESS(heap.data, 5LLU, 3LLU))
5608+ {
5609+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 5
5610+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
5611+ {
5612+ state.addr = 18446744073709551420LLU; // 9999999966'''''''''''''''
5613+ break;
5614+ }
5615+ }
5616+ /*direct*/*LOCAL_ACCESS(heap.data, 5LLU, 4LLU) = (*LOCAL_ACCESS(heap.data, 5LLU, 3LLU) << 1) + 1LLU;
5617+ *LOCAL_ACCESS(heap.data, 5LLU, 3LLU) = heap.data[*LOCAL_ACCESS(heap.data, 5LLU, 3LLU)].elem0;
5618+ {
5619+ uint64_t arg = 0;
5620+ LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5621+ }
5622+ // ACCUMULATE ARGUMENTS - BEGIN
5623+ {
5624+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 6LLU, 5LLU);
5625+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5626+ }
5627+ {
5628+ uint64_t arg = /*src_______*/*LOCAL_ACCESS(heap.data, 6LLU, 4LLU);
5629+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5630+ }
5631+ // ACCUMULATE ARGUMENTS - END
5632+ uint64_t return_to = 18446744073709551416LLU;
5633+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
5634+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5635+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
5636+ heap.data[0].elem1 = heap.data[0].elem0;
5637+ heap.data[0].elem0 = restore;
5638+ state.addr = 296309897384864500LLU; // ParDefCopy
5639+ break;
5640+ }
5641+ case 18446744073709551416LLU: // 9999999962'''''''''''''''
5642+ {
5643+ state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 6LLU, 5LLU), &*LOCAL_ACCESS(heap.data, 6LLU, 2LLU), 11) ? 18446744073709551419LLU : 18446744073709551418LLU;
5644+ break;
5645+ }
5646+ case 18446744073709551419LLU: // 9999999965'''''''''''''''
5647+ {
5648+ {
5649+ fprintf(stderr, "%s\n", "INTERNAL ERROR: out of heap in pardefscp - recompile with increased heap-size");
5650+ exit(-1);
5651+ }
5652+ // emitted destructur for type pardef____
5653+ // ACCUMULATE ARGUMENTS - BEGIN
5654+ {
5655+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 6LLU, 5LLU);
5656+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5657+ }
5658+ // ACCUMULATE ARGUMENTS - END
5659+ uint64_t return_to = 18446744073709551415LLU;
5660+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5661+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5662+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
5663+ heap.data[0].elem1 = heap.data[0].elem0;
5664+ heap.data[0].elem0 = restore;
5665+ state.addr = 18446744073709551468LLU; // 999999997q'''''''''''''''
5666+ break;
5667+ }
5668+ case 18446744073709551415LLU: // 9999999961'''''''''''''''
5669+ {
5670+ // parameter pardef____ dst_______ goes out of scope
5671+ state.addr = 18446744073709551417LLU; // 9999999963'''''''''''''''
5672+ break;
5673+ }
5674+ case 18446744073709551418LLU: // 9999999964'''''''''''''''
5675+ {
5676+ state.addr = 18446744073709551417LLU; // 9999999963'''''''''''''''
5677+ break;
5678+ }
5679+ case 18446744073709551417LLU: // 9999999963'''''''''''''''
5680+ {
5681+ (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 6
5682+ // parameter-reference pardef____ src_______ goes out of scope
5683+ // parameter-reference list<pardef____> srcs______ goes out of scope
5684+ state.addr = 18446744073709551421LLU; // 9999999967'''''''''''''''
5685+ break;
5686+ }
5687+ case 18446744073709551420LLU: // 9999999966'''''''''''''''
5688+ {
5689+ swap(&*LOCAL_ACCESS(heap.data, 3LLU, 2LLU), &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU))); // result
5690+ // variable list<pardef____> dsts______ goes out of scope
5691+ // (uninitialized -> no destructor-call)
5692+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference dsts______ at 3
5693+ // parameter-reference list<pardef____> srcs______ goes out of scope
5694+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference srcs______ at 2
5695+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
5696+ {
5697+ uint64_t baseinfo = heap.data[0].elem1;
5698+ struct pair pair = unpair(&heap, &baseinfo);
5699+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
5700+ state.addr = pair.elem1;
5701+ }
5702+ break;
5703+ }
5704+ case 587581813005601646LLU: // elems2pars
5705+ {
5706+ {
5707+ uint64_t arg = 0;
5708+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5709+ }
5710+ {
5711+ uint64_t arg = /*srcs______*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 1LLU));
5712+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5713+ }
5714+ {
5715+ uint64_t arg = 0;
5716+ LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5717+ }
5718+ state.addr = 18446744073709551414LLU; // 9999999960'''''''''''''''
5719+ break;
5720+ }
5721+ case 18446744073709551414LLU: // 9999999960'''''''''''''''
5722+ {
5723+ if(!*LOCAL_ACCESS(heap.data, 6LLU, 4LLU))
5724+ {
5725+ (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 6
5726+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 5
5727+ {
5728+ state.addr = 18446744073709551413LLU; // 999999996z'''''''''''''''
5729+ break;
5730+ }
5731+ }
5732+ /*direct*/*LOCAL_ACCESS(heap.data, 6LLU, 5LLU) = (*LOCAL_ACCESS(heap.data, 6LLU, 4LLU) << 1) + 1LLU;
5733+ *LOCAL_ACCESS(heap.data, 6LLU, 4LLU) = heap.data[*LOCAL_ACCESS(heap.data, 6LLU, 4LLU)].elem0;
5734+ {
5735+ uint64_t arg = 0;
5736+ LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5737+ }
5738+ *LOCAL_ACCESS(heap.data, 7LLU, 6LLU) = 1;
5739+ {
5740+ uint64_t arg = 0;
5741+ LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5742+ }
5743+ *LOCAL_ACCESS(heap.data, 8LLU, 7LLU) = /*reference_*/*LOCAL_ACCESS(heap.data, 8LLU, 2LLU);
5744+ {
5745+ uint64_t arg = 0;
5746+ LOCAL_PUSH_MOVE(&heap, 8, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5747+ }
5748+ // ACCUMULATE ARGUMENTS - BEGIN
5749+ {
5750+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 9LLU, 8LLU);
5751+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5752+ }
5753+ {
5754+ uint64_t arg = /*src_______*/tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 9LLU, 5LLU), 1LLU);
5755+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5756+ }
5757+ // ACCUMULATE ARGUMENTS - END
5758+ uint64_t return_to = 18446744073709551412LLU;
5759+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
5760+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5761+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
5762+ heap.data[0].elem1 = heap.data[0].elem0;
5763+ heap.data[0].elem0 = restore;
5764+ state.addr = 367395560426147840LLU; // TYPECOPY__
5765+ break;
5766+ }
5767+ case 18446744073709551412LLU: // 999999996y'''''''''''''''
5768+ {
5769+ {
5770+ uint64_t arg = 0;
5771+ LOCAL_PUSH_MOVE(&heap, 9, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5772+ }
5773+ // ACCUMULATE ARGUMENTS - BEGIN
5774+ {
5775+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 10LLU, 9LLU);
5776+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5777+ }
5778+ // ACCUMULATE ARGUMENTS - END
5779+ uint64_t return_to = 18446744073709551411LLU;
5780+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5781+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5782+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
5783+ heap.data[0].elem1 = heap.data[0].elem0;
5784+ heap.data[0].elem0 = restore;
5785+ state.addr = 552437437528276992LLU; // consume___
5786+ break;
5787+ }
5788+ case 18446744073709551411LLU: // 999999996x'''''''''''''''
5789+ {
5790+ {
5791+ uint64_t arg = 0;
5792+ LOCAL_PUSH_MOVE(&heap, 10, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5793+ }
5794+ // ACCUMULATE ARGUMENTS - BEGIN
5795+ {
5796+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 11LLU, 10LLU);
5797+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5798+ }
5799+ {
5800+ uint64_t arg = /*type______*/*LOCAL_ACCESS(heap.data, 11LLU, 8LLU);
5801+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5802+ }
5803+ {
5804+ uint64_t arg = /*mutable___*/*LOCAL_ACCESS(heap.data, 11LLU, 6LLU);
5805+ LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5806+ }
5807+ {
5808+ uint64_t arg = /*continuity*/*LOCAL_ACCESS(heap.data, 11LLU, 9LLU);
5809+ LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5810+ }
5811+ {
5812+ uint64_t arg = /*reference_*/*LOCAL_ACCESS(heap.data, 11LLU, 7LLU);
5813+ LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5814+ }
5815+ // ACCUMULATE ARGUMENTS - END
5816+ uint64_t return_to = 18446744073709551407LLU;
5817+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0));
5818+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5819+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
5820+ heap.data[0].elem1 = heap.data[0].elem0;
5821+ heap.data[0].elem0 = restore;
5822+ state.addr = 782700512565788672LLU; // pardef____
5823+ break;
5824+ }
5825+ case 18446744073709551407LLU: // 999999996t'''''''''''''''
5826+ {
5827+ state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 11LLU, 10LLU), &*LOCAL_ACCESS(heap.data, 11LLU, 3LLU), 11) ? 18446744073709551410LLU : 18446744073709551409LLU;
5828+ break;
5829+ }
5830+ case 18446744073709551410LLU: // 999999996w'''''''''''''''
5831+ {
5832+ fprintf(stderr, "%s", "pushing par ");
5833+ // ACCUMULATE ARGUMENTS - BEGIN
5834+ {
5835+ uint64_t arg = /*newpar____*/tree_elem_addr(heap.data, 4LLU, LOCAL_ACCESS_ADDR(heap.data, 11LLU, 10LLU), 0LLU);
5836+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5837+ }
5838+ // ACCUMULATE ARGUMENTS - END
5839+ uint64_t return_to = 18446744073709551406LLU;
5840+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5841+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5842+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
5843+ heap.data[0].elem1 = heap.data[0].elem0;
5844+ heap.data[0].elem0 = restore;
5845+ state.addr = 819847183518878432LLU; // reporttype
5846+ break;
5847+ }
5848+ case 18446744073709551406LLU: // 999999996s'''''''''''''''
5849+ {
5850+ fprintf(stderr, "%s", "\n");
5851+ {
5852+ fprintf(stderr, "%s\n", "INTERNAL ERROR: out of heap/dynamic in compiler, elems2pars - recompile compiler with increased heap-size");
5853+ exit(-1);
5854+ }
5855+ // emitted destructur for type pardef____
5856+ // ACCUMULATE ARGUMENTS - BEGIN
5857+ {
5858+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 11LLU, 10LLU);
5859+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5860+ }
5861+ // ACCUMULATE ARGUMENTS - END
5862+ uint64_t return_to = 18446744073709551405LLU;
5863+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5864+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5865+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
5866+ heap.data[0].elem1 = heap.data[0].elem0;
5867+ heap.data[0].elem0 = restore;
5868+ state.addr = 18446744073709551468LLU; // 999999997q'''''''''''''''
5869+ break;
5870+ }
5871+ case 18446744073709551405LLU: // 999999996r'''''''''''''''
5872+ {
5873+ // parameter pardef____ newpar____ goes out of scope
5874+ state.addr = 18446744073709551408LLU; // 999999996u'''''''''''''''
5875+ break;
5876+ }
5877+ case 18446744073709551409LLU: // 999999996v'''''''''''''''
5878+ {
5879+ state.addr = 18446744073709551408LLU; // 999999996u'''''''''''''''
5880+ break;
5881+ }
5882+ case 18446744073709551408LLU: // 999999996u'''''''''''''''
5883+ {
5884+ (void)LOCAL_POP_MOVE(&heap, 11LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 11
5885+ // variable continuity continuity goes out of scope
5886+ // (uninitialized -> no destructor-call)
5887+ (void)LOCAL_POP_MOVE(&heap, 10LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference continuity at 10
5888+ // variable type______ type______ goes out of scope
5889+ // (uninitialized -> no destructor-call)
5890+ (void)LOCAL_POP_MOVE(&heap, 9LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type______ at 9
5891+ // variable u64 reference_ goes out of scope
5892+ // (uninitialized -> no destructor-call)
5893+ (void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference reference_ at 8
5894+ // variable u64 mutable___ goes out of scope
5895+ // (uninitialized -> no destructor-call)
5896+ (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference mutable___ at 7
5897+ // parameter-reference elemdef___ src_______ goes out of scope
5898+ // parameter-reference list<elemdef___> srcs______ goes out of scope
5899+ state.addr = 18446744073709551414LLU; // 9999999960'''''''''''''''
5900+ break;
5901+ }
5902+ case 18446744073709551413LLU: // 999999996z'''''''''''''''
5903+ {
5904+ swap(&*LOCAL_ACCESS(heap.data, 4LLU, 3LLU), &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU))); // result
5905+ // variable list<pardef____> dsts______ goes out of scope
5906+ // (uninitialized -> no destructor-call)
5907+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference dsts______ at 4
5908+ // parameter u64 reference_ goes out of scope
5909+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference reference_ at 3
5910+ // parameter-reference list<elemdef___> srcs______ goes out of scope
5911+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference srcs______ at 2
5912+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
5913+ {
5914+ uint64_t baseinfo = heap.data[0].elem1;
5915+ struct pair pair = unpair(&heap, &baseinfo);
5916+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
5917+ state.addr = pair.elem1;
5918+ }
5919+ break;
5920+ }
5921+ case 101193007747052544LLU: // ElemDefCP_
5922+ {
5923+ {
5924+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU), 0LLU);
5925+ LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5926+ }
5927+ {
5928+ uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 1LLU);
5929+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5930+ }
5931+ // ACCUMULATE ARGUMENTS - BEGIN
5932+ {
5933+ uint64_t arg = *LOCAL_ACCESS(heap.data, 4LLU, 0LLU);
5934+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5935+ }
5936+ {
5937+ uint64_t arg = heap.data[0].elem0;
5938+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5939+ }
5940+ {
5941+ uint64_t arg = 0;
5942+ LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5943+ }
5944+ // ACCUMULATE ARGUMENTS - BEGIN
5945+ {
5946+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 6LLU, 5LLU);
5947+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5948+ }
5949+ {
5950+ uint64_t arg = /*id1_______*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 6LLU, 2LLU));
5951+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5952+ }
5953+ // ACCUMULATE ARGUMENTS - END
5954+ uint64_t return_to = 18446744073709551402LLU;
5955+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
5956+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5957+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
5958+ heap.data[0].elem1 = heap.data[0].elem0;
5959+ heap.data[0].elem0 = restore;
5960+ state.addr = 552446646280519680LLU; // copyu64___
5961+ break;
5962+ }
5963+ case 18446744073709551402LLU: // 999999996o'''''''''''''''
5964+ {
5965+ {
5966+ uint64_t exchange = LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 6*/;
5967+ heap.data[0].elem0 = LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 5*/;
5968+
5969+ {
5970+ uint64_t arg = exchange;
5971+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5972+ }
5973+ }
5974+ {
5975+ uint64_t arg = heap.data[0].elem0;
5976+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5977+ }
5978+ {
5979+ uint64_t arg = 0;
5980+ LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5981+ }
5982+ // ACCUMULATE ARGUMENTS - BEGIN
5983+ {
5984+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 6LLU, 5LLU);
5985+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5986+ }
5987+ {
5988+ uint64_t arg = /*type1_____*/*LOCAL_ACCESS(heap.data, 6LLU, 3LLU);
5989+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5990+ }
5991+ // ACCUMULATE ARGUMENTS - END
5992+ uint64_t return_to = 18446744073709551401LLU;
5993+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
5994+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5995+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
5996+ heap.data[0].elem1 = heap.data[0].elem0;
5997+ heap.data[0].elem0 = restore;
5998+ state.addr = 367395560426147840LLU; // TYPECOPY__
5999+ break;
6000+ }
6001+ case 18446744073709551401LLU: // 999999996n'''''''''''''''
6002+ {
6003+ {
6004+ uint64_t exchange = LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 6*/;
6005+ heap.data[0].elem0 = LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 5*/;
6006+
6007+ {
6008+ uint64_t arg = exchange;
6009+ LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6010+ }
6011+ }
6012+ // ACCUMULATE ARGUMENTS - END
6013+ uint64_t return_to = 18446744073709551403LLU;
6014+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0));
6015+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6016+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
6017+ heap.data[0].elem1 = heap.data[0].elem0;
6018+ heap.data[0].elem0 = restore;
6019+ state.addr = 587581796494082048LLU; // elemdef___
6020+ break;
6021+ }
6022+ case 18446744073709551403LLU: // 999999996p'''''''''''''''
6023+ {
6024+ // parameter-reference type______ type1_____ goes out of scope
6025+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type1_____ at 4
6026+ // parameter-reference u64 id1_______ goes out of scope
6027+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id1_______ at 3
6028+ // parameter-reference elemdef___ __________ goes out of scope
6029+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
6030+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
6031+ {
6032+ uint64_t baseinfo = heap.data[0].elem1;
6033+ struct pair pair = unpair(&heap, &baseinfo);
6034+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
6035+ state.addr = pair.elem1;
6036+ }
6037+ break;
6038+ }
6039+ case 587581796494272427LLU: // elemdefscp
6040+ {
6041+ {
6042+ uint64_t arg = 0;
6043+ LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6044+ }
6045+ {
6046+ uint64_t arg = /*srcs______*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU));
6047+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6048+ }
6049+ {
6050+ uint64_t arg = 0;
6051+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6052+ }
6053+ state.addr = 18446744073709551400LLU; // 999999996m'''''''''''''''
6054+ break;
6055+ }
6056+ case 18446744073709551400LLU: // 999999996m'''''''''''''''
6057+ {
6058+ if(!*LOCAL_ACCESS(heap.data, 5LLU, 3LLU))
6059+ {
6060+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 5
6061+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
6062+ {
6063+ state.addr = 18446744073709551399LLU; // 999999996l'''''''''''''''
6064+ break;
6065+ }
6066+ }
6067+ /*direct*/*LOCAL_ACCESS(heap.data, 5LLU, 4LLU) = (*LOCAL_ACCESS(heap.data, 5LLU, 3LLU) << 1) + 1LLU;
6068+ *LOCAL_ACCESS(heap.data, 5LLU, 3LLU) = heap.data[*LOCAL_ACCESS(heap.data, 5LLU, 3LLU)].elem0;
6069+ {
6070+ uint64_t arg = 0;
6071+ LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6072+ }
6073+ // ACCUMULATE ARGUMENTS - BEGIN
6074+ {
6075+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 6LLU, 5LLU);
6076+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6077+ }
6078+ {
6079+ uint64_t arg = /*src_______*/*LOCAL_ACCESS(heap.data, 6LLU, 4LLU);
6080+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6081+ }
6082+ // ACCUMULATE ARGUMENTS - END
6083+ uint64_t return_to = 18446744073709551395LLU;
6084+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
6085+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6086+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
6087+ heap.data[0].elem1 = heap.data[0].elem0;
6088+ heap.data[0].elem0 = restore;
6089+ state.addr = 101193007747052544LLU; // ElemDefCP_
6090+ break;
6091+ }
6092+ case 18446744073709551395LLU: // 999999996h'''''''''''''''
6093+ {
6094+ state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 6LLU, 5LLU), &*LOCAL_ACCESS(heap.data, 6LLU, 2LLU), 7) ? 18446744073709551398LLU : 18446744073709551397LLU;
6095+ break;
6096+ }
6097+ case 18446744073709551398LLU: // 999999996k'''''''''''''''
6098+ {
6099+ fprintf(stderr, "%s", "pushing par ");
6100+ // ACCUMULATE ARGUMENTS - BEGIN
6101+ {
6102+ uint64_t arg = /*dst_______*/tree_elem_addr(heap.data, 2LLU, LOCAL_ACCESS_ADDR(heap.data, 6LLU, 5LLU), 1LLU);
6103+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6104+ }
6105+ // ACCUMULATE ARGUMENTS - END
6106+ uint64_t return_to = 18446744073709551394LLU;
6107+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6108+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6109+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
6110+ heap.data[0].elem1 = heap.data[0].elem0;
6111+ heap.data[0].elem0 = restore;
6112+ state.addr = 819847183518878432LLU; // reporttype
6113+ break;
6114+ }
6115+ case 18446744073709551394LLU: // 999999996g'''''''''''''''
6116+ {
6117+ fprintf(stderr, "%s", "\n");
6118+ {
6119+ fprintf(stderr, "%s\n", "INTERNAL ERROR: out of heap/dynamic in compiler, elemdesfcp - recompile compiler with increased heap-size");
6120+ exit(-1);
6121+ }
6122+ // emitted destructur for type elemdef___
6123+ // ACCUMULATE ARGUMENTS - BEGIN
6124+ {
6125+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 6LLU, 5LLU);
6126+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6127+ }
6128+ // ACCUMULATE ARGUMENTS - END
6129+ uint64_t return_to = 18446744073709551393LLU;
6130+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6131+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6132+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
6133+ heap.data[0].elem1 = heap.data[0].elem0;
6134+ heap.data[0].elem0 = restore;
6135+ state.addr = 18446744073709551465LLU; // 999999997n'''''''''''''''
6136+ break;
6137+ }
6138+ case 18446744073709551393LLU: // 999999996f'''''''''''''''
6139+ {
6140+ // parameter elemdef___ dst_______ goes out of scope
6141+ state.addr = 18446744073709551396LLU; // 999999996i'''''''''''''''
6142+ break;
6143+ }
6144+ case 18446744073709551397LLU: // 999999996j'''''''''''''''
6145+ {
6146+ state.addr = 18446744073709551396LLU; // 999999996i'''''''''''''''
6147+ break;
6148+ }
6149+ case 18446744073709551396LLU: // 999999996i'''''''''''''''
6150+ {
6151+ (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 6
6152+ // parameter-reference elemdef___ src_______ goes out of scope
6153+ // parameter-reference list<elemdef___> srcs______ goes out of scope
6154+ state.addr = 18446744073709551400LLU; // 999999996m'''''''''''''''
6155+ break;
6156+ }
6157+ case 18446744073709551399LLU: // 999999996l'''''''''''''''
6158+ {
6159+ swap(&*LOCAL_ACCESS(heap.data, 3LLU, 2LLU), &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU))); // result
6160+ // variable list<elemdef___> dsts______ goes out of scope
6161+ // (uninitialized -> no destructor-call)
6162+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference dsts______ at 3
6163+ // parameter-reference list<elemdef___> srcs______ goes out of scope
6164+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference srcs______ at 2
6165+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
6166+ {
6167+ uint64_t baseinfo = heap.data[0].elem1;
6168+ struct pair pair = unpair(&heap, &baseinfo);
6169+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
6170+ state.addr = pair.elem1;
6171+ }
6172+ break;
6173+ }
6174+ case 325750391286068249LLU: // RESDEFCOPY
6175+ {
6176+ {
6177+ uint64_t arg = tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU), 0LLU);
6178+ LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6179+ }
6180+ {
6181+ uint64_t arg = tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 1LLU);
6182+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6183+ }
6184+ {
6185+ uint64_t arg = tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 4LLU, 1LLU), 2LLU);
6186+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6187+ }
6188+ // ACCUMULATE ARGUMENTS - BEGIN
6189+ {
6190+ uint64_t arg = *LOCAL_ACCESS(heap.data, 5LLU, 0LLU);
6191+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6192+ }
6193+ {
6194+ uint64_t arg = heap.data[0].elem0;
6195+ LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6196+ }
6197+ {
6198+ uint64_t arg = 0;
6199+ LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6200+ }
6201+ // ACCUMULATE ARGUMENTS - BEGIN
6202+ {
6203+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 7LLU, 6LLU);
6204+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6205+ }
6206+ {
6207+ uint64_t arg = /*type1_____*/*LOCAL_ACCESS(heap.data, 7LLU, 2LLU);
6208+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6209+ }
6210+ // ACCUMULATE ARGUMENTS - END
6211+ uint64_t return_to = 18446744073709551390LLU;
6212+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
6213+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6214+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
6215+ heap.data[0].elem1 = heap.data[0].elem0;
6216+ heap.data[0].elem0 = restore;
6217+ state.addr = 367395560426147840LLU; // TYPECOPY__
6218+ break;
6219+ }
6220+ case 18446744073709551390LLU: // 999999996c'''''''''''''''
6221+ {
6222+ {
6223+ uint64_t exchange = LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 7*/;
6224+ heap.data[0].elem0 = LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 6*/;
6225+
6226+ {
6227+ uint64_t arg = exchange;
6228+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6229+ }
6230+ }
6231+ {
6232+ uint64_t arg = heap.data[0].elem0;
6233+ LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6234+ }
6235+ {
6236+ uint64_t arg = 0;
6237+ LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6238+ }
6239+ // ACCUMULATE ARGUMENTS - BEGIN
6240+ {
6241+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 7LLU, 6LLU);
6242+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6243+ }
6244+ {
6245+ uint64_t arg = /*idx1______*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 7LLU, 3LLU));
6246+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6247+ }
6248+ // ACCUMULATE ARGUMENTS - END
6249+ uint64_t return_to = 18446744073709551389LLU;
6250+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
6251+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6252+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
6253+ heap.data[0].elem1 = heap.data[0].elem0;
6254+ heap.data[0].elem0 = restore;
6255+ state.addr = 552446646280519680LLU; // copyu64___
6256+ break;
6257+ }
6258+ case 18446744073709551389LLU: // 999999996b'''''''''''''''
6259+ {
6260+ {
6261+ uint64_t exchange = LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 7*/;
6262+ heap.data[0].elem0 = LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 6*/;
6263+
6264+ {
6265+ uint64_t arg = exchange;
6266+ LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6267+ }
6268+ }
6269+ {
6270+ uint64_t arg = heap.data[0].elem0;
6271+ LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6272+ }
6273+ {
6274+ uint64_t arg = 0;
6275+ LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6276+ }
6277+ // ACCUMULATE ARGUMENTS - BEGIN
6278+ {
6279+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 7LLU, 6LLU);
6280+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6281+ }
6282+ {
6283+ uint64_t arg = /*reference1*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 7LLU, 4LLU));
6284+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6285+ }
6286+ // ACCUMULATE ARGUMENTS - END
6287+ uint64_t return_to = 18446744073709551388LLU;
6288+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
6289+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6290+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
6291+ heap.data[0].elem1 = heap.data[0].elem0;
6292+ heap.data[0].elem0 = restore;
6293+ state.addr = 552446646280519680LLU; // copyu64___
6294+ break;
6295+ }
6296+ case 18446744073709551388LLU: // 999999996a'''''''''''''''
6297+ {
6298+ {
6299+ uint64_t exchange = LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 7*/;
6300+ heap.data[0].elem0 = LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 6*/;
6301+
6302+ {
6303+ uint64_t arg = exchange;
6304+ LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6305+ }
6306+ }
6307+ // ACCUMULATE ARGUMENTS - END
6308+ uint64_t return_to = 18446744073709551391LLU;
6309+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
6310+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6311+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
6312+ heap.data[0].elem1 = heap.data[0].elem0;
6313+ heap.data[0].elem0 = restore;
6314+ state.addr = 819859607768530944LLU; // resdest___
6315+ break;
6316+ }
6317+ case 18446744073709551391LLU: // 999999996d'''''''''''''''
6318+ {
6319+ // parameter-reference u64 reference1 goes out of scope
6320+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference reference1 at 5
6321+ // parameter-reference u64 idx1______ goes out of scope
6322+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference idx1______ at 4
6323+ // parameter-reference type______ type1_____ goes out of scope
6324+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type1_____ at 3
6325+ // parameter-reference resdest___ __________ goes out of scope
6326+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
6327+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
6328+ {
6329+ uint64_t baseinfo = heap.data[0].elem1;
6330+ struct pair pair = unpair(&heap, &baseinfo);
6331+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
6332+ state.addr = pair.elem1;
6333+ }
6334+ break;
6335+ }
6336+ case 18446744073709551387LLU: // 999999996$'''''''''''''''
6337+ {
6338+ {
6339+ uint64_t arg = tree_pop_move(&heap, 2LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
6340+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6341+ }
6342+ // emitted destructur for type u64
6343+ // RELEASE temporary destructor-variable
6344+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
6345+ {
6346+ uint64_t arg = tree_pop_move(&heap, 1LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
6347+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6348+ }
6349+ // emitted destructur for type u64
6350+ // RELEASE temporary destructor-variable
6351+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
6352+ // RELEASE destructor-argument
6353+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 1
6354+ {
6355+ uint64_t baseinfo = heap.data[0].elem1;
6356+ struct pair pair = unpair(&heap, &baseinfo);
6357+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
6358+ state.addr = pair.elem1;
6359+ }
6360+ break;
6361+ }
6362+ case 746649810298337261LLU: // nametoaddr
6363+ {
6364+ // struct-constructor nametoaddr
6365+ {
6366+ uint64_t result_tuple = 0;
6367+ // copy references
6368+ {
6369+ uint64_t elem = *LOCAL_ACCESS(heap.data, 2LLU + 1, 0LLU + 1);
6370+ tree_push_move(&heap, 0LLU, &result_tuple, &elem);
6371+ }
6372+ {
6373+ uint64_t elem = *LOCAL_ACCESS(heap.data, 2LLU + 1, 1LLU + 1);
6374+ tree_push_move(&heap, 1LLU, &result_tuple, &elem);
6375+ }
6376+ // release parameters
6377+ {
6378+ (void)LOCAL_POP_MOVE(&heap, 2LLU + 1, &(heap.data[0].elem1)/*memory root*/);
6379+ }
6380+ {
6381+ (void)LOCAL_POP_MOVE(&heap, 1LLU + 1, &(heap.data[0].elem1)/*memory root*/);
6382+ }
6383+ *access_heap(heap.data, LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*memory root*/)) = result_tuple;
6384+ }
6385+ {
6386+ uint64_t baseinfo = heap.data[0].elem1;
6387+ struct pair pair = unpair(&heap, &baseinfo);
6388+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
6389+ state.addr = pair.elem1;
6390+ }
6391+ break;
6392+ }
6393+ case 18446744073709551386LLU: // 999999996Z'''''''''''''''
6394+ {
6395+ {
6396+ uint64_t arg = tree_pop_move(&heap, 7LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
6397+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6398+ }
6399+ // emitted destructur for type u64
6400+ // RELEASE temporary destructor-variable
6401+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
6402+ {
6403+ uint64_t arg = tree_pop_move(&heap, 6LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
6404+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6405+ }
6406+ // emitted destructur for type u64
6407+ // RELEASE temporary destructor-variable
6408+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
6409+ {
6410+ uint64_t arg = tree_pop_move(&heap, 5LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
6411+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6412+ }
6413+ // emitted destructur for type u64
6414+ // RELEASE temporary destructor-variable
6415+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
6416+ {
6417+ uint64_t arg = tree_pop_move(&heap, 4LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
6418+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6419+ }
6420+ // emitted destructur for type u64
6421+ // RELEASE temporary destructor-variable
6422+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
6423+ {
6424+ uint64_t arg = tree_pop_move(&heap, 3LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
6425+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6426+ }
6427+ // emitted destructur for type u64
6428+ // RELEASE temporary destructor-variable
6429+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
6430+ {
6431+ uint64_t arg = tree_pop_move(&heap, 2LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
6432+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6433+ }
6434+ // emitted destructur for type list<pardef____>
6435+ state.addr = 18446744073709551384LLU; // 999999996X'''''''''''''''
6436+ break;
6437+ }
6438+ case 18446744073709551384LLU: // 999999996X'''''''''''''''
6439+ {
6440+ if(!*LOCAL_ACCESS(heap.data, 2LLU, 1LLU)/*list*/)
6441+ {
6442+ state.addr = 18446744073709551385LLU; // 999999996Y'''''''''''''''
6443+ break;
6444+ }
6445+ // temporary list-element
6446+ {
6447+ uint64_t arg = list_pop_move(&heap, &*LOCAL_ACCESS(heap.data, 2LLU, 1LLU)/*list*/, 11);
6448+ LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6449+ }
6450+ // ACCUMULATE ARGUMENTS - BEGIN
6451+ {
6452+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 3LLU, 2LLU);
6453+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6454+ }
6455+ // ACCUMULATE ARGUMENTS - END
6456+ uint64_t return_to = 18446744073709551383LLU;
6457+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6458+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6459+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
6460+ heap.data[0].elem1 = heap.data[0].elem0;
6461+ heap.data[0].elem0 = restore;
6462+ state.addr = 18446744073709551468LLU; // 999999997q'''''''''''''''
6463+ break;
6464+ }
6465+ case 18446744073709551383LLU: // 999999996W'''''''''''''''
6466+ {
6467+ // RELEASE temporary destructor-variable
6468+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 3
6469+ state.addr = 18446744073709551384LLU; // 999999996X'''''''''''''''
6470+ break;
6471+ }
6472+ case 18446744073709551385LLU: // 999999996Y'''''''''''''''
6473+ {
6474+ // RELEASE temporary destructor-variable
6475+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
6476+ {
6477+ uint64_t arg = tree_pop_move(&heap, 1LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
6478+ LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6479+ }
6480+ // emitted destructur for type list<resdest___>
6481+ state.addr = 18446744073709551381LLU; // 999999996U'''''''''''''''
6482+ break;
6483+ }
6484+ case 18446744073709551381LLU: // 999999996U'''''''''''''''
6485+ {
6486+ if(!*LOCAL_ACCESS(heap.data, 2LLU, 1LLU)/*list*/)
6487+ {
6488+ state.addr = 18446744073709551382LLU; // 999999996V'''''''''''''''
6489+ break;
6490+ }
6491+ // temporary list-element
6492+ {
6493+ uint64_t arg = list_pop_move(&heap, &*LOCAL_ACCESS(heap.data, 2LLU, 1LLU)/*list*/, 8);
6494+ LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6495+ }
6496+ // ACCUMULATE ARGUMENTS - BEGIN
6497+ {
6498+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 3LLU, 2LLU);
6499+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6500+ }
6501+ // ACCUMULATE ARGUMENTS - END
6502+ uint64_t return_to = 18446744073709551380LLU;
6503+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6504+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6505+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
6506+ heap.data[0].elem1 = heap.data[0].elem0;
6507+ heap.data[0].elem0 = restore;
6508+ state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
6509+ break;
6510+ }
6511+ case 18446744073709551380LLU: // 999999996T'''''''''''''''
6512+ {
6513+ // RELEASE temporary destructor-variable
6514+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 3
6515+ state.addr = 18446744073709551381LLU; // 999999996U'''''''''''''''
6516+ break;
6517+ }
6518+ case 18446744073709551382LLU: // 999999996V'''''''''''''''
6519+ {
6520+ // RELEASE temporary destructor-variable
6521+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
6522+ // RELEASE destructor-argument
6523+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 1
6524+ {
6525+ uint64_t baseinfo = heap.data[0].elem1;
6526+ struct pair pair = unpair(&heap, &baseinfo);
6527+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
6528+ state.addr = pair.elem1;
6529+ }
6530+ break;
6531+ }
6532+ case 608168382267297792LLU: // function__
6533+ {
6534+ // struct-constructor function__
6535+ {
6536+ uint64_t result_tuple = 0;
6537+ // copy references
6538+ {
6539+ uint64_t elem = *LOCAL_ACCESS(heap.data, 7LLU + 1, 0LLU + 1);
6540+ tree_push_move(&heap, 0LLU, &result_tuple, &elem);
6541+ }
6542+ {
6543+ uint64_t elem = *LOCAL_ACCESS(heap.data, 7LLU + 1, 1LLU + 1);
6544+ tree_push_move(&heap, 1LLU, &result_tuple, &elem);
6545+ }
6546+ {
6547+ uint64_t elem = *LOCAL_ACCESS(heap.data, 7LLU + 1, 2LLU + 1);
6548+ tree_push_move(&heap, 2LLU, &result_tuple, &elem);
6549+ }
6550+ {
6551+ uint64_t elem = *LOCAL_ACCESS(heap.data, 7LLU + 1, 3LLU + 1);
6552+ tree_push_move(&heap, 3LLU, &result_tuple, &elem);
6553+ }
6554+ {
6555+ uint64_t elem = *LOCAL_ACCESS(heap.data, 7LLU + 1, 4LLU + 1);
6556+ tree_push_move(&heap, 4LLU, &result_tuple, &elem);
6557+ }
6558+ {
6559+ uint64_t elem = *LOCAL_ACCESS(heap.data, 7LLU + 1, 5LLU + 1);
6560+ tree_push_move(&heap, 5LLU, &result_tuple, &elem);
6561+ }
6562+ {
6563+ uint64_t elem = *LOCAL_ACCESS(heap.data, 7LLU + 1, 6LLU + 1);
6564+ tree_push_move(&heap, 6LLU, &result_tuple, &elem);
6565+ }
6566+ // release parameters
6567+ {
6568+ (void)LOCAL_POP_MOVE(&heap, 7LLU + 1, &(heap.data[0].elem1)/*memory root*/);
6569+ }
6570+ {
6571+ (void)LOCAL_POP_MOVE(&heap, 6LLU + 1, &(heap.data[0].elem1)/*memory root*/);
6572+ }
6573+ {
6574+ (void)LOCAL_POP_MOVE(&heap, 5LLU + 1, &(heap.data[0].elem1)/*memory root*/);
6575+ }
6576+ {
6577+ (void)LOCAL_POP_MOVE(&heap, 4LLU + 1, &(heap.data[0].elem1)/*memory root*/);
6578+ }
6579+ {
6580+ (void)LOCAL_POP_MOVE(&heap, 3LLU + 1, &(heap.data[0].elem1)/*memory root*/);
6581+ }
6582+ {
6583+ (void)LOCAL_POP_MOVE(&heap, 2LLU + 1, &(heap.data[0].elem1)/*memory root*/);
6584+ }
6585+ {
6586+ (void)LOCAL_POP_MOVE(&heap, 1LLU + 1, &(heap.data[0].elem1)/*memory root*/);
6587+ }
6588+ *access_heap(heap.data, LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*memory root*/)) = result_tuple;
6589+ }
6590+ {
6591+ uint64_t baseinfo = heap.data[0].elem1;
6592+ struct pair pair = unpair(&heap, &baseinfo);
6593+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
6594+ state.addr = pair.elem1;
6595+ }
6596+ break;
6597+ }
6598+ case 121779622511284459LLU: // FunctionCp
6599+ {
6600+ {
6601+ uint64_t arg = tree_elem_addr(heap.data, 7LLU, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU), 0LLU);
6602+ LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6603+ }
6604+ {
6605+ uint64_t arg = tree_elem_addr(heap.data, 7LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 1LLU);
6606+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6607+ }
6608+ {
6609+ uint64_t arg = tree_elem_addr(heap.data, 7LLU, *LOCAL_ACCESS(heap.data, 4LLU, 1LLU), 2LLU);
6610+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6611+ }
6612+ {
6613+ uint64_t arg = tree_elem_addr(heap.data, 7LLU, *LOCAL_ACCESS(heap.data, 5LLU, 1LLU), 3LLU);
6614+ LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6615+ }
6616+ {
6617+ uint64_t arg = tree_elem_addr(heap.data, 7LLU, *LOCAL_ACCESS(heap.data, 6LLU, 1LLU), 4LLU);
6618+ LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6619+ }
6620+ {
6621+ uint64_t arg = tree_elem_addr(heap.data, 7LLU, *LOCAL_ACCESS(heap.data, 7LLU, 1LLU), 5LLU);
6622+ LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6623+ }
6624+ {
6625+ uint64_t arg = tree_elem_addr(heap.data, 7LLU, *LOCAL_ACCESS(heap.data, 8LLU, 1LLU), 6LLU);
6626+ LOCAL_PUSH_MOVE(&heap, 8, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6627+ }
6628+ {
6629+ uint64_t arg = 0;
6630+ LOCAL_PUSH_MOVE(&heap, 9, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6631+ }
6632+ {
6633+ uint64_t arg = /*resultpars*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 10LLU, 2LLU));
6634+ LOCAL_PUSH_MOVE(&heap, 10, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6635+ }
6636+ {
6637+ uint64_t arg = 0;
6638+ LOCAL_PUSH_MOVE(&heap, 11, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6639+ }
6640+ state.addr = 18446744073709551378LLU; // 999999996R'''''''''''''''
6641+ break;
6642+ }
6643+ case 18446744073709551378LLU: // 999999996R'''''''''''''''
6644+ {
6645+ if(!*LOCAL_ACCESS(heap.data, 12LLU, 10LLU))
6646+ {
6647+ (void)LOCAL_POP_MOVE(&heap, 12LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 12
6648+ (void)LOCAL_POP_MOVE(&heap, 11LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 11
6649+ {
6650+ state.addr = 18446744073709551377LLU; // 999999996Q'''''''''''''''
6651+ break;
6652+ }
6653+ }
6654+ /*direct*/*LOCAL_ACCESS(heap.data, 12LLU, 11LLU) = (*LOCAL_ACCESS(heap.data, 12LLU, 10LLU) << 1) + 1LLU;
6655+ *LOCAL_ACCESS(heap.data, 12LLU, 10LLU) = heap.data[*LOCAL_ACCESS(heap.data, 12LLU, 10LLU)].elem0;
6656+ {
6657+ uint64_t arg = 0;
6658+ LOCAL_PUSH_MOVE(&heap, 12, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6659+ }
6660+ // ACCUMULATE ARGUMENTS - BEGIN
6661+ {
6662+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 13LLU, 12LLU);
6663+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6664+ }
6665+ {
6666+ uint64_t arg = /*rp________*/*LOCAL_ACCESS(heap.data, 13LLU, 11LLU);
6667+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6668+ }
6669+ // ACCUMULATE ARGUMENTS - END
6670+ uint64_t return_to = 18446744073709551373LLU;
6671+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
6672+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6673+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
6674+ heap.data[0].elem1 = heap.data[0].elem0;
6675+ heap.data[0].elem0 = restore;
6676+ state.addr = 333468934555566080LLU; // ResCopy___
6677+ break;
6678+ }
6679+ case 18446744073709551373LLU: // 999999996M'''''''''''''''
6680+ {
6681+ state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 13LLU, 12LLU), &*LOCAL_ACCESS(heap.data, 13LLU, 9LLU), 8) ? 18446744073709551376LLU : 18446744073709551375LLU;
6682+ break;
6683+ }
6684+ case 18446744073709551376LLU: // 999999996P'''''''''''''''
6685+ {
6686+ {
6687+ fprintf(stderr, "%s\n", "INTERNAL ERROR in FunctionCp: out of dynamic heap - recompile compiler to reserve more dynamic heap");
6688+ exit(-1);
6689+ }
6690+ // emitted destructur for type resdest___
6691+ // ACCUMULATE ARGUMENTS - BEGIN
6692+ {
6693+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 13LLU, 12LLU);
6694+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6695+ }
6696+ // ACCUMULATE ARGUMENTS - END
6697+ uint64_t return_to = 18446744073709551372LLU;
6698+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6699+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6700+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
6701+ heap.data[0].elem1 = heap.data[0].elem0;
6702+ heap.data[0].elem0 = restore;
6703+ state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
6704+ break;
6705+ }
6706+ case 18446744073709551372LLU: // 999999996L'''''''''''''''
6707+ {
6708+ // parameter resdest___ RP________ goes out of scope
6709+ state.addr = 18446744073709551374LLU; // 999999996N'''''''''''''''
6710+ break;
6711+ }
6712+ case 18446744073709551375LLU: // 999999996O'''''''''''''''
6713+ {
6714+ state.addr = 18446744073709551374LLU; // 999999996N'''''''''''''''
6715+ break;
6716+ }
6717+ case 18446744073709551374LLU: // 999999996N'''''''''''''''
6718+ {
6719+ (void)LOCAL_POP_MOVE(&heap, 13LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 13
6720+ // parameter-reference resdest___ rp________ goes out of scope
6721+ // parameter-reference list<resdest___> resultpars goes out of scope
6722+ state.addr = 18446744073709551378LLU; // 999999996R'''''''''''''''
6723+ break;
6724+ }
6725+ case 18446744073709551377LLU: // 999999996Q'''''''''''''''
6726+ {
6727+ list_reverse(heap.data, &/*RESULTPARS*/*LOCAL_ACCESS(heap.data, 10LLU, 9LLU));
6728+ {
6729+ uint64_t arg = 0;
6730+ LOCAL_PUSH_MOVE(&heap, 10, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6731+ }
6732+ {
6733+ uint64_t arg = /*defpars___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 11LLU, 3LLU));
6734+ LOCAL_PUSH_MOVE(&heap, 11, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6735+ }
6736+ {
6737+ uint64_t arg = 0;
6738+ LOCAL_PUSH_MOVE(&heap, 12, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6739+ }
6740+ state.addr = 18446744073709551371LLU; // 999999996K'''''''''''''''
6741+ break;
6742+ }
6743+ case 18446744073709551371LLU: // 999999996K'''''''''''''''
6744+ {
6745+ if(!*LOCAL_ACCESS(heap.data, 13LLU, 11LLU))
6746+ {
6747+ (void)LOCAL_POP_MOVE(&heap, 13LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 13
6748+ (void)LOCAL_POP_MOVE(&heap, 12LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 12
6749+ {
6750+ state.addr = 18446744073709551370LLU; // 999999996J'''''''''''''''
6751+ break;
6752+ }
6753+ }
6754+ /*direct*/*LOCAL_ACCESS(heap.data, 13LLU, 12LLU) = (*LOCAL_ACCESS(heap.data, 13LLU, 11LLU) << 1) + 1LLU;
6755+ *LOCAL_ACCESS(heap.data, 13LLU, 11LLU) = heap.data[*LOCAL_ACCESS(heap.data, 13LLU, 11LLU)].elem0;
6756+ {
6757+ uint64_t arg = 0;
6758+ LOCAL_PUSH_MOVE(&heap, 13, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6759+ }
6760+ // ACCUMULATE ARGUMENTS - BEGIN
6761+ {
6762+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 14LLU, 13LLU);
6763+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6764+ }
6765+ {
6766+ uint64_t arg = /*dp________*/*LOCAL_ACCESS(heap.data, 14LLU, 12LLU);
6767+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6768+ }
6769+ // ACCUMULATE ARGUMENTS - END
6770+ uint64_t return_to = 18446744073709551366LLU;
6771+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
6772+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6773+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
6774+ heap.data[0].elem1 = heap.data[0].elem0;
6775+ heap.data[0].elem0 = restore;
6776+ state.addr = 296309897384864500LLU; // ParDefCopy
6777+ break;
6778+ }
6779+ case 18446744073709551366LLU: // 999999996F'''''''''''''''
6780+ {
6781+ state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 14LLU, 13LLU), &*LOCAL_ACCESS(heap.data, 14LLU, 10LLU), 11) ? 18446744073709551369LLU : 18446744073709551368LLU;
6782+ break;
6783+ }
6784+ case 18446744073709551369LLU: // 999999996I'''''''''''''''
6785+ {
6786+ {
6787+ fprintf(stderr, "%s\n", "INTERNAL ERROR in FunctionCp: out of dynamic heap - recompile compiler to reserve more dynamic heap");
6788+ exit(-1);
6789+ }
6790+ // emitted destructur for type pardef____
6791+ // ACCUMULATE ARGUMENTS - BEGIN
6792+ {
6793+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 14LLU, 13LLU);
6794+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6795+ }
6796+ // ACCUMULATE ARGUMENTS - END
6797+ uint64_t return_to = 18446744073709551365LLU;
6798+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6799+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6800+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
6801+ heap.data[0].elem1 = heap.data[0].elem0;
6802+ heap.data[0].elem0 = restore;
6803+ state.addr = 18446744073709551468LLU; // 999999997q'''''''''''''''
6804+ break;
6805+ }
6806+ case 18446744073709551365LLU: // 999999996E'''''''''''''''
6807+ {
6808+ // parameter pardef____ DP________ goes out of scope
6809+ state.addr = 18446744073709551367LLU; // 999999996G'''''''''''''''
6810+ break;
6811+ }
6812+ case 18446744073709551368LLU: // 999999996H'''''''''''''''
6813+ {
6814+ state.addr = 18446744073709551367LLU; // 999999996G'''''''''''''''
6815+ break;
6816+ }
6817+ case 18446744073709551367LLU: // 999999996G'''''''''''''''
6818+ {
6819+ (void)LOCAL_POP_MOVE(&heap, 14LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 14
6820+ // parameter-reference pardef____ dp________ goes out of scope
6821+ // parameter-reference list<pardef____> defpars___ goes out of scope
6822+ state.addr = 18446744073709551371LLU; // 999999996K'''''''''''''''
6823+ break;
6824+ }
6825+ case 18446744073709551370LLU: // 999999996J'''''''''''''''
6826+ {
6827+ list_reverse(heap.data, &/*DEFPARS___*/*LOCAL_ACCESS(heap.data, 11LLU, 10LLU));
6828+ // ACCUMULATE ARGUMENTS - BEGIN
6829+ {
6830+ uint64_t arg = *LOCAL_ACCESS(heap.data, 11LLU, 0LLU);
6831+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6832+ }
6833+ {
6834+ uint64_t arg = /*RESULTPARS*/*LOCAL_ACCESS(heap.data, 11LLU, 9LLU);
6835+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6836+ }
6837+ {
6838+ uint64_t arg = /*DEFPARS___*/*LOCAL_ACCESS(heap.data, 11LLU, 10LLU);
6839+ LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6840+ }
6841+ {
6842+ uint64_t arg = heap.data[0].elem0;
6843+ LOCAL_PUSH_MOVE(&heap, 11, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6844+ }
6845+ {
6846+ uint64_t arg = 0;
6847+ LOCAL_PUSH_MOVE(&heap, 12, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6848+ }
6849+ // ACCUMULATE ARGUMENTS - BEGIN
6850+ {
6851+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 13LLU, 12LLU);
6852+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6853+ }
6854+ {
6855+ uint64_t arg = /*sizeonheap*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 13LLU, 4LLU));
6856+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6857+ }
6858+ // ACCUMULATE ARGUMENTS - END
6859+ uint64_t return_to = 18446744073709551363LLU;
6860+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
6861+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6862+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
6863+ heap.data[0].elem1 = heap.data[0].elem0;
6864+ heap.data[0].elem0 = restore;
6865+ state.addr = 552446646280519680LLU; // copyu64___
6866+ break;
6867+ }
6868+ case 18446744073709551363LLU: // 999999996C'''''''''''''''
6869+ {
6870+ {
6871+ uint64_t exchange = LOCAL_POP_MOVE(&heap, 13LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 13*/;
6872+ heap.data[0].elem0 = LOCAL_POP_MOVE(&heap, 12LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 12*/;
6873+
6874+ {
6875+ uint64_t arg = exchange;
6876+ LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6877+ }
6878+ }
6879+ {
6880+ uint64_t arg = heap.data[0].elem0;
6881+ LOCAL_PUSH_MOVE(&heap, 11, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6882+ }
6883+ {
6884+ uint64_t arg = 0;
6885+ LOCAL_PUSH_MOVE(&heap, 12, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6886+ }
6887+ // ACCUMULATE ARGUMENTS - BEGIN
6888+ {
6889+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 13LLU, 12LLU);
6890+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6891+ }
6892+ {
6893+ uint64_t arg = /*defbodysz_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 13LLU, 5LLU));
6894+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6895+ }
6896+ // ACCUMULATE ARGUMENTS - END
6897+ uint64_t return_to = 18446744073709551362LLU;
6898+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
6899+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6900+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
6901+ heap.data[0].elem1 = heap.data[0].elem0;
6902+ heap.data[0].elem0 = restore;
6903+ state.addr = 552446646280519680LLU; // copyu64___
6904+ break;
6905+ }
6906+ case 18446744073709551362LLU: // 999999996B'''''''''''''''
6907+ {
6908+ {
6909+ uint64_t exchange = LOCAL_POP_MOVE(&heap, 13LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 13*/;
6910+ heap.data[0].elem0 = LOCAL_POP_MOVE(&heap, 12LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 12*/;
6911+
6912+ {
6913+ uint64_t arg = exchange;
6914+ LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6915+ }
6916+ }
6917+ {
6918+ uint64_t arg = heap.data[0].elem0;
6919+ LOCAL_PUSH_MOVE(&heap, 11, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6920+ }
6921+ {
6922+ uint64_t arg = 0;
6923+ LOCAL_PUSH_MOVE(&heap, 12, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6924+ }
6925+ // ACCUMULATE ARGUMENTS - BEGIN
6926+ {
6927+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 13LLU, 12LLU);
6928+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6929+ }
6930+ {
6931+ uint64_t arg = /*complete__*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 13LLU, 6LLU));
6932+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6933+ }
6934+ // ACCUMULATE ARGUMENTS - END
6935+ uint64_t return_to = 18446744073709551361LLU;
6936+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
6937+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6938+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
6939+ heap.data[0].elem1 = heap.data[0].elem0;
6940+ heap.data[0].elem0 = restore;
6941+ state.addr = 552446646280519680LLU; // copyu64___
6942+ break;
6943+ }
6944+ case 18446744073709551361LLU: // 999999996A'''''''''''''''
6945+ {
6946+ {
6947+ uint64_t exchange = LOCAL_POP_MOVE(&heap, 13LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 13*/;
6948+ heap.data[0].elem0 = LOCAL_POP_MOVE(&heap, 12LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 12*/;
6949+
6950+ {
6951+ uint64_t arg = exchange;
6952+ LOCAL_PUSH_MOVE(&heap, 5LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6953+ }
6954+ }
6955+ {
6956+ uint64_t arg = heap.data[0].elem0;
6957+ LOCAL_PUSH_MOVE(&heap, 11, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6958+ }
6959+ {
6960+ uint64_t arg = 0;
6961+ LOCAL_PUSH_MOVE(&heap, 12, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6962+ }
6963+ // ACCUMULATE ARGUMENTS - BEGIN
6964+ {
6965+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 13LLU, 12LLU);
6966+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6967+ }
6968+ {
6969+ uint64_t arg = /*finite____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 13LLU, 7LLU));
6970+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6971+ }
6972+ // ACCUMULATE ARGUMENTS - END
6973+ uint64_t return_to = 18446744073709551360LLU;
6974+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
6975+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6976+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
6977+ heap.data[0].elem1 = heap.data[0].elem0;
6978+ heap.data[0].elem0 = restore;
6979+ state.addr = 552446646280519680LLU; // copyu64___
6980+ break;
6981+ }
6982+ case 18446744073709551360LLU: // 999999996_'''''''''''''''
6983+ {
6984+ {
6985+ uint64_t exchange = LOCAL_POP_MOVE(&heap, 13LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 13*/;
6986+ heap.data[0].elem0 = LOCAL_POP_MOVE(&heap, 12LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 12*/;
6987+
6988+ {
6989+ uint64_t arg = exchange;
6990+ LOCAL_PUSH_MOVE(&heap, 6LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6991+ }
6992+ }
6993+ {
6994+ uint64_t arg = heap.data[0].elem0;
6995+ LOCAL_PUSH_MOVE(&heap, 11, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6996+ }
6997+ {
6998+ uint64_t arg = 0;
6999+ LOCAL_PUSH_MOVE(&heap, 12, &(heap.data[0].elem1)/*address of current closure*/, &arg);
7000+ }
7001+ // ACCUMULATE ARGUMENTS - BEGIN
7002+ {
7003+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 13LLU, 12LLU);
7004+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
7005+ }
7006+ {
7007+ uint64_t arg = /*safe______*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 13LLU, 8LLU));
7008+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
7009+ }
7010+ // ACCUMULATE ARGUMENTS - END
7011+ uint64_t return_to = 18446744073709551359LLU;
7012+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
7013+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
7014+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
7015+ heap.data[0].elem1 = heap.data[0].elem0;
7016+ heap.data[0].elem0 = restore;
7017+ state.addr = 552446646280519680LLU; // copyu64___
7018+ break;
7019+ }
7020+ case 18446744073709551359LLU: // 9999999959'''''''''''''''
7021+ {
7022+ {
7023+ uint64_t exchange = LOCAL_POP_MOVE(&heap, 13LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 13*/;
7024+ heap.data[0].elem0 = LOCAL_POP_MOVE(&heap, 12LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 12*/;
7025+
7026+ {
7027+ uint64_t arg = exchange;
7028+ LOCAL_PUSH_MOVE(&heap, 7LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
7029+ }
7030+ }
7031+ // ACCUMULATE ARGUMENTS - END
7032+ uint64_t return_to = 18446744073709551364LLU;
7033+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 8LLU, 0/*address of closure-in-construction*/, 0));
7034+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
7035+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 8LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
7036+ heap.data[0].elem1 = heap.data[0].elem0;
7037+ heap.data[0].elem0 = restore;
7038+ state.addr = 608168382267297792LLU; // function__
7039+ break;
7040+ }
7041+ case 18446744073709551364LLU: // 999999996D'''''''''''''''
7042+ {
7043+ // variable list<pardef____> DEFPARS___ goes out of scope
7044+ // (uninitialized -> no destructor-call)
7045+ (void)LOCAL_POP_MOVE(&heap, 11LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference DEFPARS___ at 11
7046+ // variable list<resdest___> RESULTPARS goes out of scope
7047+ // (uninitialized -> no destructor-call)
7048+ (void)LOCAL_POP_MOVE(&heap, 10LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference RESULTPARS at 10
7049+ // parameter-reference u64 safe______ goes out of scope
7050+ (void)LOCAL_POP_MOVE(&heap, 9LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference safe______ at 9
7051+ // parameter-reference u64 finite____ goes out of scope
7052+ (void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference finite____ at 8
7053+ // parameter-reference u64 complete__ goes out of scope
7054+ (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference complete__ at 7
7055+ // parameter-reference u64 defbodysz_ goes out of scope
7056+ (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference defbodysz_ at 6
7057+ // parameter-reference u64 sizeonheap goes out of scope
7058+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference sizeonheap at 5
7059+ // parameter-reference list<pardef____> defpars___ goes out of scope
7060+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference defpars___ at 4
7061+ // parameter-reference list<resdest___> resultpars goes out of scope
7062+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference resultpars at 3
7063+ // parameter-reference function__ __________ goes out of scope
7064+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
7065+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
7066+ {
7067+ uint64_t baseinfo = heap.data[0].elem1;
7068+ struct pair pair = unpair(&heap, &baseinfo);
7069+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
7070+ state.addr = pair.elem1;
7071+ }
7072+ break;
7073+ }
7074+ case 606150496152849376LLU: // fncomplete
7075+ {
7076+ {
7077+ uint64_t arg = 0;
7078+ LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
7079+ }
7080+ *LOCAL_ACCESS(heap.data, 3LLU, 2LLU) = /*fn________*/*access_heap(heap.data, tree_elem_addr(heap.data, 7LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 4LLU));
7081+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU)) = /*result____*/*LOCAL_ACCESS(heap.data, 3LLU, 2LLU);
7082+ // variable u64 result____ goes out of scope
7083+ // emitted destructur for type u64
7084+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference result____ at 3
7085+ // parameter-reference function__ fn________ goes out of scope
7086+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference fn________ at 2
7087+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
7088+ {
7089+ uint64_t baseinfo = heap.data[0].elem1;
7090+ struct pair pair = unpair(&heap, &baseinfo);
7091+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
7092+ state.addr = pair.elem1;
7093+ }
7094+ break;
7095+ }
7096+ case 606163278933917696LLU: // fnfinite__
7097+ {
7098+ {
7099+ uint64_t arg = 0;
7100+ LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
7101+ }
7102+ *LOCAL_ACCESS(heap.data, 3LLU, 2LLU) = /*fn________*/*access_heap(heap.data, tree_elem_addr(heap.data, 7LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 5LLU));
7103+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU)) = /*result____*/*LOCAL_ACCESS(heap.data, 3LLU, 2LLU);
7104+ // variable u64 result____ goes out of scope
7105+ // emitted destructur for type u64
7106+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference result____ at 3
7107+ // parameter-reference function__ fn________ goes out of scope
7108+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference fn________ at 2
7109+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
7110+ {
7111+ uint64_t baseinfo = heap.data[0].elem1;
7112+ struct pair pair = unpair(&heap, &baseinfo);
7113+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
7114+ state.addr = pair.elem1;
7115+ }
7116+ break;
7117+ }
7118+ case 606219895113252864LLU: // fnsafe____
7119+ {
7120+ {
7121+ uint64_t arg = 0;
7122+ LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
7123+ }
7124+ *LOCAL_ACCESS(heap.data, 3LLU, 2LLU) = /*fn________*/*access_heap(heap.data, tree_elem_addr(heap.data, 7LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 6LLU));
7125+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU)) = /*result____*/*LOCAL_ACCESS(heap.data, 3LLU, 2LLU);
7126+ // variable u64 result____ goes out of scope
7127+ // emitted destructur for type u64
7128+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference result____ at 3
7129+ // parameter-reference function__ fn________ goes out of scope
7130+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference fn________ at 2
7131+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
7132+ {
7133+ uint64_t baseinfo = heap.data[0].elem1;
7134+ struct pair pair = unpair(&heap, &baseinfo);
7135+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
7136+ state.addr = pair.elem1;
7137+ }
7138+ break;
7139+ }
7140+ case 94950668770481299LLU: // EQURESPARS
7141+ {
7142+
7143+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 0LLU)) = 1;
7144+ {
7145+ uint64_t arg = 0;
7146+ LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg);
7147+ }
7148+ {
7149+ uint64_t arg = /*yresults__*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 6LLU, 2LLU));
7150+ LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg);
7151+ }
7152+ {
7153+ uint64_t arg = 0;
7154+ LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/*address of current closure*/, &arg);
7155+ }
7156+ state.addr = 18446744073709551358LLU; // 9999999958'''''''''''''''
7157+ break;
7158+ }
7159+ case 18446744073709551358LLU: // 9999999958'''''''''''''''
7160+ {
7161+ if(!*LOCAL_ACCESS(heap.data, 8LLU, 6LLU))
7162+ {
7163+ (void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 8
7164+ (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 7
7165+ {
7166+ state.addr = 18446744073709551357LLU; // 9999999957'''''''''''''''
7167+ break;
7168+ }
7169+ }
7170+ /*direct*/*LOCAL_ACCESS(heap.data, 8LLU, 7LLU) = (*LOCAL_ACCESS(heap.data, 8LLU, 6LLU) << 1) + 1LLU;
7171+ *LOCAL_ACCESS(heap.data, 8LLU, 6LLU) = heap.data[*LOCAL_ACCESS(heap.data, 8LLU, 6LLU)].elem0;
7172+ {
7173+ uint64_t arg = 0;
7174+ LOCAL_PUSH_MOVE(&heap, 8, &(heap.data[0].elem1)/*address of current closure*/, &arg);
7175+ }
7176+ // ACCUMULATE ARGUMENTS - BEGIN
7177+ {
7178+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 9LLU, 8LLU);
7179+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
7180+ }
7181+ {
7182+ uint64_t arg = /*respar1___*/*LOCAL_ACCESS(heap.data, 9LLU, 7LLU);
7183+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
7184+ }
7185+ // ACCUMULATE ARGUMENTS - END
7186+ uint64_t return_to = 18446744073709551353LLU;
7187+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
7188+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
7189+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
7190+ heap.data[0].elem1 = heap.data[0].elem0;
7191+ heap.data[0].elem0 = restore;
7192+ state.addr = 325750391286068249LLU; // RESDEFCOPY
7193+ break;
7194+ }
7195+ case 18446744073709551353LLU: // 9999999953'''''''''''''''
7196+ {
7197+ state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 9LLU, 8LLU), &*LOCAL_ACCESS(heap.data, 9LLU, 5LLU), 8) ? 18446744073709551356LLU : 18446744073709551355LLU;
7198+ break;
7199+ }
7200+ case 18446744073709551356LLU: // 9999999956'''''''''''''''
7201+ {
7202+ {
7203+ fprintf(stderr, "%s\n", "out of dynamic heap in equfndef - recompile compiler with more dynamic heap memory");
7204+ exit(-1);
7205+ }
7206+ // emitted destructur for type resdest___
7207+ // ACCUMULATE ARGUMENTS - BEGIN
7208+ {
7209+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 9LLU, 8LLU);
7210+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
7211+ }
7212+ // ACCUMULATE ARGUMENTS - END
7213+ uint64_t return_to = 18446744073709551352LLU;
7214+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
7215+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
7216+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
7217+ heap.data[0].elem1 = heap.data[0].elem0;
7218+ heap.data[0].elem0 = restore;
7219+ state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
7220+ break;
7221+ }
7222+ case 18446744073709551352LLU: // 9999999952'''''''''''''''
7223+ {
7224+ // parameter resdest___ new_______ goes out of scope
7225+ state.addr = 18446744073709551354LLU; // 9999999954'''''''''''''''
7226+ break;
7227+ }
7228+ case 18446744073709551355LLU: // 9999999955'''''''''''''''
7229+ {
7230+ state.addr = 18446744073709551354LLU; // 9999999954'''''''''''''''
7231+ break;
7232+ }
7233+ case 18446744073709551354LLU: // 9999999954'''''''''''''''
7234+ {
7235+ (void)LOCAL_POP_MOVE(&heap, 9LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 9
7236+ // parameter-reference resdest___ respar1___ goes out of scope
7237+ // parameter-reference list<resdest___> yresults__ goes out of scope
7238+ state.addr = 18446744073709551358LLU; // 9999999958'''''''''''''''
7239+ break;
7240+ }
7241+ case 18446744073709551357LLU: // 9999999957'''''''''''''''
7242+ {
7243+ list_reverse(heap.data, &/*yres______*/*LOCAL_ACCESS(heap.data, 6LLU, 5LLU));
7244+ {
7245+ uint64_t arg = /*xresults__*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 6LLU, 1LLU));
7246+ LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg);
7247+ }
7248+ {
7249+ uint64_t arg = 0;
7250+ LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/*address of current closure*/, &arg);
7251+ }
7252+ state.addr = 18446744073709551351LLU; // 9999999951'''''''''''''''
7253+ break;
7254+ }
7255+ case 18446744073709551351LLU: // 9999999951'''''''''''''''
7256+ {
7257+ if(!*LOCAL_ACCESS(heap.data, 8LLU, 6LLU))
7258+ {
7259+ (void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 8
7260+ (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 7
7261+ {
7262+ state.addr = 18446744073709551350LLU; // 9999999950'''''''''''''''
7263+ break;
7264+ }
7265+ }
7266+ /*direct*/*LOCAL_ACCESS(heap.data, 8LLU, 7LLU) = (*LOCAL_ACCESS(heap.data, 8LLU, 6LLU) << 1) + 1LLU;
7267+ *LOCAL_ACCESS(heap.data, 8LLU, 6LLU) = heap.data[*LOCAL_ACCESS(heap.data, 8LLU, 6LLU)].elem0;
7268+ state.addr = /*yres______*/*LOCAL_ACCESS(heap.data, 8LLU, 5LLU) ? 18446744073709551349LLU : 18446744073709551348LLU;
7269+ break;
7270+ }
7271+ case 18446744073709551349LLU: // 999999995z'''''''''''''''
7272+ {
7273+ {
7274+ uint64_t arg = list_pop_move(&heap, &*LOCAL_ACCESS(heap.data, 8LLU, 5LLU)/*list*/, 8);
7275+ LOCAL_PUSH_MOVE(&heap, 8, &(heap.data[0].elem1)/*address of current closure*/, &arg);
7276+ }
7277+ {
7278+ uint64_t arg = 0;
7279+ LOCAL_PUSH_MOVE(&heap, 9, &(heap.data[0].elem1)/*address of current closure*/, &arg);
7280+ }
7281+ *LOCAL_ACCESS(heap.data, 10LLU, 9LLU) = 0;
7282+ // ACCUMULATE ARGUMENTS - BEGIN
7283+ {
7284+ uint64_t arg = /*EQUAL_____*/LOCAL_ACCESS_ADDR(heap.data, 10LLU, 9LLU);
7285+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
7286+ }
7287+ {
7288+ uint64_t arg = /*res0______*/*LOCAL_ACCESS(heap.data, 10LLU, 7LLU);
7289+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
7290+ }
7291+ {
7292+ uint64_t arg = /*res1______*/LOCAL_ACCESS_ADDR(heap.data, 10LLU, 8LLU);
7293+ LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
7294+ }
7295+ // ACCUMULATE ARGUMENTS - END
7296+ uint64_t return_to = 18446744073709551346LLU;
7297+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0));
7298+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
7299+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
7300+ heap.data[0].elem1 = heap.data[0].elem0;
7301+ heap.data[0].elem0 = restore;
7302+ state.addr = 589059885019168768LLU; // equres____
7303+ break;
7304+ }
7305+ case 18446744073709551346LLU: // 999999995w'''''''''''''''
7306+ {
7307+
7308+ *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);
7309+ // variable u64 EQUAL_____ goes out of scope
7310+ // emitted destructur for type u64
7311+ (void)LOCAL_POP_MOVE(&heap, 10LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference EQUAL_____ at 10
7312+ // variable resdest___ res1______ goes out of scope
7313+ // emitted destructur for type resdest___
7314+ // ACCUMULATE ARGUMENTS - BEGIN
7315+ {
7316+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 9LLU, 8LLU);
7317+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
7318+ }
7319+ // ACCUMULATE ARGUMENTS - END
7320+ uint64_t return_to = 18446744073709551345LLU;
7321+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
7322+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
7323+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
7324+ heap.data[0].elem1 = heap.data[0].elem0;
7325+ heap.data[0].elem0 = restore;
7326+ state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
7327+ break;
7328+ }
7329+ case 18446744073709551345LLU: // 999999995v'''''''''''''''
7330+ {
7331+ (void)LOCAL_POP_MOVE(&heap, 9LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference res1______ at 9
7332+ state.addr = 18446744073709551347LLU; // 999999995x'''''''''''''''
7333+ break;
7334+ }
7335+ case 18446744073709551348LLU: // 999999995y'''''''''''''''
7336+ {
7337+
7338+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 8LLU, 0LLU)) = 0;
7339+ state.addr = 18446744073709551347LLU; // 999999995x'''''''''''''''
7340+ break;
7341+ }
7342+ case 18446744073709551347LLU: // 999999995x'''''''''''''''
7343+ {
7344+ // parameter-reference resdest___ res0______ goes out of scope
7345+ // parameter-reference list<resdest___> xresults__ goes out of scope
7346+ state.addr = 18446744073709551351LLU; // 9999999951'''''''''''''''
7347+ break;
7348+ }
7349+ case 18446744073709551350LLU: // 9999999950'''''''''''''''
7350+ {
7351+ state.addr = /*yres______*/*LOCAL_ACCESS(heap.data, 6LLU, 5LLU) ? 18446744073709551344LLU : 18446744073709551343LLU;
7352+ break;
7353+ }
7354+ case 18446744073709551344LLU: // 999999995u'''''''''''''''
7355+ {
7356+ {
7357+ uint64_t arg = list_pop_move(&heap, &*LOCAL_ACCESS(heap.data, 6LLU, 5LLU)/*list*/, 8);
7358+ LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg);
7359+ }
7360+
7361+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 7LLU, 0LLU)) = 0;
7362+ // variable resdest___ res1______ goes out of scope
7363+ // emitted destructur for type resdest___
7364+ // ACCUMULATE ARGUMENTS - BEGIN
7365+ {
7366+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 7LLU, 6LLU);
7367+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
7368+ }
7369+ // ACCUMULATE ARGUMENTS - END
7370+ uint64_t return_to = 18446744073709551341LLU;
7371+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
7372+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
7373+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
7374+ heap.data[0].elem1 = heap.data[0].elem0;
7375+ heap.data[0].elem0 = restore;
7376+ state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
7377+ break;
7378+ }
7379+ case 18446744073709551341LLU: // 999999995r'''''''''''''''
7380+ {
7381+ (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference res1______ at 7
7382+ state.addr = 18446744073709551342LLU; // 999999995s'''''''''''''''
7383+ break;
7384+ }
7385+ case 18446744073709551343LLU: // 999999995t'''''''''''''''
7386+ {
7387+ state.addr = 18446744073709551342LLU; // 999999995s'''''''''''''''
7388+ break;
7389+ }
7390+ case 18446744073709551342LLU: // 999999995s'''''''''''''''
7391+ {
7392+ // variable list<resdest___> yres______ goes out of scope
7393+ // emitted destructur for type list<resdest___>
7394+ state.addr = 18446744073709551339LLU; // 999999995p'''''''''''''''
7395+ break;
7396+ }
7397+ case 18446744073709551339LLU: // 999999995p'''''''''''''''
7398+ {
7399+ if(!*LOCAL_ACCESS(heap.data, 6LLU, 5LLU)/*list*/)
7400+ {
7401+ state.addr = 18446744073709551340LLU; // 999999995q'''''''''''''''
7402+ break;
7403+ }
7404+ // temporary list-element
7405+ {
7406+ uint64_t arg = list_pop_move(&heap, &*LOCAL_ACCESS(heap.data, 6LLU, 5LLU)/*list*/, 8);
7407+ LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg);
7408+ }
7409+ // ACCUMULATE ARGUMENTS - BEGIN
7410+ {
7411+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 7LLU, 6LLU);
7412+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
7413+ }
7414+ // ACCUMULATE ARGUMENTS - END
7415+ uint64_t return_to = 18446744073709551338LLU;
7416+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
7417+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
7418+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
7419+ heap.data[0].elem1 = heap.data[0].elem0;
7420+ heap.data[0].elem0 = restore;
7421+ state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
7422+ break;
7423+ }
7424+ case 18446744073709551338LLU: // 999999995o'''''''''''''''
7425+ {
7426+ // RELEASE temporary destructor-variable
7427+ (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 7
7428+ state.addr = 18446744073709551339LLU; // 999999995p'''''''''''''''
7429+ break;
7430+ }
7431+ case 18446744073709551340LLU: // 999999995q'''''''''''''''
7432+ {
7433+ (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference yres______ at 6
7434+ {
7435+ uint64_t arg = 0;
7436+ LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg);
7437+ }
7438+ {
7439+ uint64_t arg = /*ydefpars__*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 6LLU, 4LLU));
7440+ LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg);
7441+ }
7442+ {
7443+ uint64_t arg = 0;
7444+ LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/*address of current closure*/, &arg);
7445+ }
7446+ state.addr = 18446744073709551337LLU; // 999999995n'''''''''''''''
7447+ break;
7448+ }
7449+ case 18446744073709551337LLU: // 999999995n'''''''''''''''
7450+ {
7451+ if(!*LOCAL_ACCESS(heap.data, 8LLU, 6LLU))
7452+ {
7453+ (void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 8
7454+ (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 7
7455+ {
7456+ state.addr = 18446744073709551336LLU; // 999999995m'''''''''''''''
7457+ break;
7458+ }
7459+ }
7460+ /*direct*/*LOCAL_ACCESS(heap.data, 8LLU, 7LLU) = (*LOCAL_ACCESS(heap.data, 8LLU, 6LLU) << 1) + 1LLU;
7461+ *LOCAL_ACCESS(heap.data, 8LLU, 6LLU) = heap.data[*LOCAL_ACCESS(heap.data, 8LLU, 6LLU)].elem0;
7462+ {
7463+ uint64_t arg = 0;
7464+ LOCAL_PUSH_MOVE(&heap, 8, &(heap.data[0].elem1)/*address of current closure*/, &arg);
7465+ }
7466+ // ACCUMULATE ARGUMENTS - BEGIN
7467+ {
7468+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 9LLU, 8LLU);
7469+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
7470+ }
7471+ {
7472+ uint64_t arg = /*par1______*/*LOCAL_ACCESS(heap.data, 9LLU, 7LLU);
7473+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
7474+ }
7475+ // ACCUMULATE ARGUMENTS - END
7476+ uint64_t return_to = 18446744073709551332LLU;
7477+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
7478+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
7479+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
7480+ heap.data[0].elem1 = heap.data[0].elem0;
7481+ heap.data[0].elem0 = restore;
7482+ state.addr = 296309897384864500LLU; // ParDefCopy
7483+ break;
7484+ }
7485+ case 18446744073709551332LLU: // 999999995i'''''''''''''''
7486+ {
7487+ state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 9LLU, 8LLU), &*LOCAL_ACCESS(heap.data, 9LLU, 5LLU), 11) ? 18446744073709551335LLU : 18446744073709551334LLU;
7488+ break;
7489+ }
7490+ case 18446744073709551335LLU: // 999999995l'''''''''''''''
7491+ {
7492+ {
7493+ fprintf(stderr, "%s\n", "out of dynamic heap in equfndef - recompile compiler with more dynamic heap memory");
7494+ exit(-1);
7495+ }
7496+ // emitted destructur for type pardef____
7497+ // ACCUMULATE ARGUMENTS - BEGIN
7498+ {
7499+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 9LLU, 8LLU);
7500+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
7501+ }
7502+ // ACCUMULATE ARGUMENTS - END
7503+ uint64_t return_to = 18446744073709551331LLU;
7504+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
7505+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
7506+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
7507+ heap.data[0].elem1 = heap.data[0].elem0;
7508+ heap.data[0].elem0 = restore;
7509+ state.addr = 18446744073709551468LLU; // 999999997q'''''''''''''''
7510+ break;
7511+ }
7512+ case 18446744073709551331LLU: // 999999995h'''''''''''''''
7513+ {
7514+ // parameter pardef____ new_______ goes out of scope
7515+ state.addr = 18446744073709551333LLU; // 999999995j'''''''''''''''
7516+ break;
7517+ }
7518+ case 18446744073709551334LLU: // 999999995k'''''''''''''''
7519+ {
7520+ state.addr = 18446744073709551333LLU; // 999999995j'''''''''''''''
7521+ break;
7522+ }
7523+ case 18446744073709551333LLU: // 999999995j'''''''''''''''
7524+ {
7525+ (void)LOCAL_POP_MOVE(&heap, 9LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 9
7526+ // parameter-reference pardef____ par1______ goes out of scope
7527+ // parameter-reference list<pardef____> ydefpars__ goes out of scope
7528+ state.addr = 18446744073709551337LLU; // 999999995n'''''''''''''''
7529+ break;
7530+ }
7531+ case 18446744073709551336LLU: // 999999995m'''''''''''''''
7532+ {
7533+ list_reverse(heap.data, &/*ypars_____*/*LOCAL_ACCESS(heap.data, 6LLU, 5LLU));
7534+ {
7535+ uint64_t arg = /*xdefpars__*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 6LLU, 3LLU));
7536+ LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg);
7537+ }
7538+ {
7539+ uint64_t arg = 0;
7540+ LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/*address of current closure*/, &arg);
7541+ }
7542+ state.addr = 18446744073709551330LLU; // 999999995g'''''''''''''''
7543+ break;
7544+ }
7545+ case 18446744073709551330LLU: // 999999995g'''''''''''''''
7546+ {
7547+ if(!*LOCAL_ACCESS(heap.data, 8LLU, 6LLU))
7548+ {
7549+ (void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 8
7550+ (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 7
7551+ {
7552+ state.addr = 18446744073709551329LLU; // 999999995f'''''''''''''''
7553+ break;
7554+ }
7555+ }
7556+ /*direct*/*LOCAL_ACCESS(heap.data, 8LLU, 7LLU) = (*LOCAL_ACCESS(heap.data, 8LLU, 6LLU) << 1) + 1LLU;
7557+ *LOCAL_ACCESS(heap.data, 8LLU, 6LLU) = heap.data[*LOCAL_ACCESS(heap.data, 8LLU, 6LLU)].elem0;
7558+ state.addr = /*ypars_____*/*LOCAL_ACCESS(heap.data, 8LLU, 5LLU) ? 18446744073709551328LLU : 18446744073709551327LLU;
7559+ break;
7560+ }
7561+ case 18446744073709551328LLU: // 999999995e'''''''''''''''
7562+ {
7563+ {
7564+ uint64_t arg = list_pop_move(&heap, &*LOCAL_ACCESS(heap.data, 8LLU, 5LLU)/*list*/, 11);
7565+ LOCAL_PUSH_MOVE(&heap, 8, &(heap.data[0].elem1)/*address of current closure*/, &arg);
7566+ }
7567+ {
7568+ uint64_t arg = 0;
7569+ LOCAL_PUSH_MOVE(&heap, 9, &(heap.data[0].elem1)/*address of current closure*/, &arg);
7570+ }
7571+ *LOCAL_ACCESS(heap.data, 10LLU, 9LLU) = 0;
7572+ // ACCUMULATE ARGUMENTS - BEGIN
7573+ {
7574+ uint64_t arg = /*EQUAL_____*/LOCAL_ACCESS_ADDR(heap.data, 10LLU, 9LLU);
7575+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
7576+ }
7577+ {
7578+ uint64_t arg = /*par0______*/*LOCAL_ACCESS(heap.data, 10LLU, 7LLU);
7579+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
7580+ }
7581+ {
7582+ uint64_t arg = /*par1______*/LOCAL_ACCESS_ADDR(heap.data, 10LLU, 8LLU);
7583+ LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
7584+ }
7585+ // ACCUMULATE ARGUMENTS - END
7586+ uint64_t return_to = 18446744073709551325LLU;
7587+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0));
7588+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
7589+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
7590+ heap.data[0].elem1 = heap.data[0].elem0;
7591+ heap.data[0].elem0 = restore;
7592+ state.addr = 589059743276730432LLU; // equpardef_
7593+ break;
7594+ }
7595+ case 18446744073709551325LLU: // 999999995b'''''''''''''''
7596+ {
7597+
7598+ *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);
7599+ // variable u64 EQUAL_____ goes out of scope
7600+ // emitted destructur for type u64
7601+ (void)LOCAL_POP_MOVE(&heap, 10LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference EQUAL_____ at 10
7602+ // variable pardef____ par1______ goes out of scope
7603+ // emitted destructur for type pardef____
7604+ // ACCUMULATE ARGUMENTS - BEGIN
7605+ {
7606+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 9LLU, 8LLU);
7607+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
7608+ }
7609+ // ACCUMULATE ARGUMENTS - END
7610+ uint64_t return_to = 18446744073709551324LLU;
7611+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
7612+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
7613+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
7614+ heap.data[0].elem1 = heap.data[0].elem0;
7615+ heap.data[0].elem0 = restore;
7616+ state.addr = 18446744073709551468LLU; // 999999997q'''''''''''''''
7617+ break;
7618+ }
7619+ case 18446744073709551324LLU: // 999999995a'''''''''''''''
7620+ {
7621+ (void)LOCAL_POP_MOVE(&heap, 9LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference par1______ at 9
7622+ state.addr = 18446744073709551326LLU; // 999999995c'''''''''''''''
7623+ break;
7624+ }
7625+ case 18446744073709551327LLU: // 999999995d'''''''''''''''
7626+ {
7627+
7628+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 8LLU, 0LLU)) = 0;
7629+ state.addr = 18446744073709551326LLU; // 999999995c'''''''''''''''
7630+ break;
7631+ }
7632+ case 18446744073709551326LLU: // 999999995c'''''''''''''''
7633+ {
7634+ // parameter-reference pardef____ par0______ goes out of scope
7635+ // parameter-reference list<pardef____> xdefpars__ goes out of scope
7636+ state.addr = 18446744073709551330LLU; // 999999995g'''''''''''''''
7637+ break;
7638+ }
7639+ case 18446744073709551329LLU: // 999999995f'''''''''''''''
7640+ {
7641+ state.addr = /*ypars_____*/*LOCAL_ACCESS(heap.data, 6LLU, 5LLU) ? 18446744073709551323LLU : 18446744073709551322LLU;
7642+ break;
7643+ }
7644+ case 18446744073709551323LLU: // 999999995$'''''''''''''''
7645+ {
7646+ {
7647+ uint64_t arg = list_pop_move(&heap, &*LOCAL_ACCESS(heap.data, 6LLU, 5LLU)/*list*/, 11);
7648+ LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg);
7649+ }
7650+
7651+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 7LLU, 0LLU)) = 0;
7652+ // variable pardef____ par1______ goes out of scope
7653+ // emitted destructur for type pardef____
7654+ // ACCUMULATE ARGUMENTS - BEGIN
7655+ {
7656+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 7LLU, 6LLU);
7657+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
7658+ }
7659+ // ACCUMULATE ARGUMENTS - END
7660+ uint64_t return_to = 18446744073709551320LLU;
7661+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
7662+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
7663+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
7664+ heap.data[0].elem1 = heap.data[0].elem0;
7665+ heap.data[0].elem0 = restore;
7666+ state.addr = 18446744073709551468LLU; // 999999997q'''''''''''''''
7667+ break;
7668+ }
7669+ case 18446744073709551320LLU: // 999999995X'''''''''''''''
7670+ {
7671+ (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference par1______ at 7
7672+ state.addr = 18446744073709551321LLU; // 999999995Y'''''''''''''''
7673+ break;
7674+ }
7675+ case 18446744073709551322LLU: // 999999995Z'''''''''''''''
7676+ {
7677+ state.addr = 18446744073709551321LLU; // 999999995Y'''''''''''''''
7678+ break;
7679+ }
7680+ case 18446744073709551321LLU: // 999999995Y'''''''''''''''
7681+ {
7682+ // variable list<pardef____> ypars_____ goes out of scope
7683+ // emitted destructur for type list<pardef____>
7684+ state.addr = 18446744073709551318LLU; // 999999995V'''''''''''''''
7685+ break;
7686+ }
7687+ case 18446744073709551318LLU: // 999999995V'''''''''''''''
7688+ {
7689+ if(!*LOCAL_ACCESS(heap.data, 6LLU, 5LLU)/*list*/)
7690+ {
7691+ state.addr = 18446744073709551319LLU; // 999999995W'''''''''''''''
7692+ break;
7693+ }
7694+ // temporary list-element
7695+ {
7696+ uint64_t arg = list_pop_move(&heap, &*LOCAL_ACCESS(heap.data, 6LLU, 5LLU)/*list*/, 11);
7697+ LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg);
7698+ }
7699+ // ACCUMULATE ARGUMENTS - BEGIN
7700+ {
7701+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 7LLU, 6LLU);
7702+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
7703+ }
7704+ // ACCUMULATE ARGUMENTS - END
7705+ uint64_t return_to = 18446744073709551317LLU;
7706+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
7707+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
7708+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
7709+ heap.data[0].elem1 = heap.data[0].elem0;
7710+ heap.data[0].elem0 = restore;
7711+ state.addr = 18446744073709551468LLU; // 999999997q'''''''''''''''
7712+ break;
7713+ }
7714+ case 18446744073709551317LLU: // 999999995U'''''''''''''''
7715+ {
7716+ // RELEASE temporary destructor-variable
7717+ (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 7
7718+ state.addr = 18446744073709551318LLU; // 999999995V'''''''''''''''
7719+ break;
7720+ }
7721+ case 18446744073709551319LLU: // 999999995W'''''''''''''''
7722+ {
7723+ (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference ypars_____ at 6
7724+ // parameter-reference list<pardef____> ydefpars__ goes out of scope
7725+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference ydefpars__ at 5
7726+ // parameter-reference list<pardef____> xdefpars__ goes out of scope
7727+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference xdefpars__ at 4
7728+ // parameter-reference list<resdest___> yresults__ goes out of scope
7729+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference yresults__ at 3
7730+ // parameter-reference list<resdest___> xresults__ goes out of scope
7731+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference xresults__ at 2
7732+ // parameter-reference u64 equal_____ goes out of scope
7733+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference equal_____ at 1
7734+ {
7735+ uint64_t baseinfo = heap.data[0].elem1;
7736+ struct pair pair = unpair(&heap, &baseinfo);
7737+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
7738+ state.addr = pair.elem1;
7739+ }
7740+ break;
7741+ }
7742+ case 94949853545914368LLU: // EQUFNDEF__
7743+ {
7744+
7745+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) = 1;
7746+ {
7747+ uint64_t arg = 0;
7748+ LOCAL_PUSH_MOVE(&heap, 15, &(heap.data[0].elem1)/*address of current closure*/, &arg);
7749+ }
7750+ {
7751+ uint64_t arg = /*yresults__*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 16LLU, 2LLU));
7752+ LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/*address of current closure*/, &arg);
7753+ }
7754+ {
7755+ uint64_t arg = 0;
7756+ LOCAL_PUSH_MOVE(&heap, 17, &(heap.data[0].elem1)/*address of current closure*/, &arg);
7757+ }
7758+ state.addr = 18446744073709551316LLU; // 999999995T'''''''''''''''
7759+ break;
7760+ }
7761+ case 18446744073709551316LLU: // 999999995T'''''''''''''''
7762+ {
7763+ if(!*LOCAL_ACCESS(heap.data, 18LLU, 16LLU))
7764+ {
7765+ (void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 18
7766+ (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 17
7767+ {
7768+ state.addr = 18446744073709551315LLU; // 999999995S'''''''''''''''
7769+ break;
7770+ }
7771+ }
7772+ /*direct*/*LOCAL_ACCESS(heap.data, 18LLU, 17LLU) = (*LOCAL_ACCESS(heap.data, 18LLU, 16LLU) << 1) + 1LLU;
7773+ *LOCAL_ACCESS(heap.data, 18LLU, 16LLU) = heap.data[*LOCAL_ACCESS(heap.data, 18LLU, 16LLU)].elem0;
7774+ {
7775+ uint64_t arg = 0;
7776+ LOCAL_PUSH_MOVE(&heap, 18, &(heap.data[0].elem1)/*address of current closure*/, &arg);
7777+ }
7778+ // ACCUMULATE ARGUMENTS - BEGIN
7779+ {
7780+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 19LLU, 18LLU);
7781+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
7782+ }
7783+ {
7784+ uint64_t arg = /*respar1___*/*LOCAL_ACCESS(heap.data, 19LLU, 17LLU);
7785+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
7786+ }
7787+ // ACCUMULATE ARGUMENTS - END
7788+ uint64_t return_to = 18446744073709551311LLU;
7789+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
7790+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
7791+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
7792+ heap.data[0].elem1 = heap.data[0].elem0;
7793+ heap.data[0].elem0 = restore;
7794+ state.addr = 325750391286068249LLU; // RESDEFCOPY
7795+ break;
7796+ }
7797+ case 18446744073709551311LLU: // 999999995O'''''''''''''''
7798+ {
7799+ state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 19LLU, 18LLU), &*LOCAL_ACCESS(heap.data, 19LLU, 15LLU), 8) ? 18446744073709551314LLU : 18446744073709551313LLU;
7800+ break;
7801+ }
7802+ case 18446744073709551314LLU: // 999999995R'''''''''''''''
7803+ {
7804+ {
7805+ fprintf(stderr, "%s\n", "out of dynamic heap in equfndef - recompile compiler with more dynamic heap memory");
7806+ exit(-1);
7807+ }
7808+ // emitted destructur for type resdest___
7809+ // ACCUMULATE ARGUMENTS - BEGIN
7810+ {
7811+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 19LLU, 18LLU);
7812+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
7813+ }
7814+ // ACCUMULATE ARGUMENTS - END
7815+ uint64_t return_to = 18446744073709551310LLU;
7816+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
7817+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
7818+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
7819+ heap.data[0].elem1 = heap.data[0].elem0;
7820+ heap.data[0].elem0 = restore;
7821+ state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
7822+ break;
7823+ }
7824+ case 18446744073709551310LLU: // 999999995N'''''''''''''''
7825+ {
7826+ // parameter resdest___ new_______ goes out of scope
7827+ state.addr = 18446744073709551312LLU; // 999999995P'''''''''''''''
7828+ break;
7829+ }
7830+ case 18446744073709551313LLU: // 999999995Q'''''''''''''''
7831+ {
7832+ state.addr = 18446744073709551312LLU; // 999999995P'''''''''''''''
7833+ break;
7834+ }
7835+ case 18446744073709551312LLU: // 999999995P'''''''''''''''
7836+ {
7837+ (void)LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 19
7838+ // parameter-reference resdest___ respar1___ goes out of scope
7839+ // parameter-reference list<resdest___> yresults__ goes out of scope
7840+ state.addr = 18446744073709551316LLU; // 999999995T'''''''''''''''
7841+ break;
7842+ }
7843+ case 18446744073709551315LLU: // 999999995S'''''''''''''''
7844+ {
7845+ list_reverse(heap.data, &/*yres______*/*LOCAL_ACCESS(heap.data, 16LLU, 15LLU));
7846+ {
7847+ uint64_t arg = /*xresults__*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 16LLU, 1LLU));
7848+ LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/*address of current closure*/, &arg);
7849+ }
7850+ {
7851+ uint64_t arg = 0;
7852+ LOCAL_PUSH_MOVE(&heap, 17, &(heap.data[0].elem1)/*address of current closure*/, &arg);
7853+ }
7854+ state.addr = 18446744073709551309LLU; // 999999995M'''''''''''''''
7855+ break;
7856+ }
7857+ case 18446744073709551309LLU: // 999999995M'''''''''''''''
7858+ {
7859+ if(!*LOCAL_ACCESS(heap.data, 18LLU, 16LLU))
7860+ {
7861+ (void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 18
7862+ (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 17
7863+ {
7864+ state.addr = 18446744073709551308LLU; // 999999995L'''''''''''''''
7865+ break;
7866+ }
7867+ }
7868+ /*direct*/*LOCAL_ACCESS(heap.data, 18LLU, 17LLU) = (*LOCAL_ACCESS(heap.data, 18LLU, 16LLU) << 1) + 1LLU;
7869+ *LOCAL_ACCESS(heap.data, 18LLU, 16LLU) = heap.data[*LOCAL_ACCESS(heap.data, 18LLU, 16LLU)].elem0;
7870+ state.addr = /*yres______*/*LOCAL_ACCESS(heap.data, 18LLU, 15LLU) ? 18446744073709551307LLU : 18446744073709551306LLU;
7871+ break;
7872+ }
7873+ case 18446744073709551307LLU: // 999999995K'''''''''''''''
7874+ {
7875+ {
7876+ uint64_t arg = list_pop_move(&heap, &*LOCAL_ACCESS(heap.data, 18LLU, 15LLU)/*list*/, 8);
7877+ LOCAL_PUSH_MOVE(&heap, 18, &(heap.data[0].elem1)/*address of current closure*/, &arg);
7878+ }
7879+ {
7880+ uint64_t arg = 0;
7881+ LOCAL_PUSH_MOVE(&heap, 19, &(heap.data[0].elem1)/*address of current closure*/, &arg);
7882+ }
7883+ *LOCAL_ACCESS(heap.data, 20LLU, 19LLU) = 0;
7884+ // ACCUMULATE ARGUMENTS - BEGIN
7885+ {
7886+ uint64_t arg = /*EQUAL_____*/LOCAL_ACCESS_ADDR(heap.data, 20LLU, 19LLU);
7887+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
7888+ }
7889+ {
7890+ uint64_t arg = /*res0______*/*LOCAL_ACCESS(heap.data, 20LLU, 17LLU);
7891+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
7892+ }
7893+ {
7894+ uint64_t arg = /*res1______*/LOCAL_ACCESS_ADDR(heap.data, 20LLU, 18LLU);
7895+ LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
7896+ }
7897+ // ACCUMULATE ARGUMENTS - END
7898+ uint64_t return_to = 18446744073709551304LLU;
7899+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0));
7900+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
7901+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
7902+ heap.data[0].elem1 = heap.data[0].elem0;
7903+ heap.data[0].elem0 = restore;
7904+ state.addr = 589059885019168768LLU; // equres____
7905+ break;
7906+ }
7907+ case 18446744073709551304LLU: // 999999995H'''''''''''''''
7908+ {
7909+
7910+ *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);
7911+ // variable u64 EQUAL_____ goes out of scope
7912+ // emitted destructur for type u64
7913+ (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference EQUAL_____ at 20
7914+ // variable resdest___ res1______ goes out of scope
7915+ // emitted destructur for type resdest___
7916+ // ACCUMULATE ARGUMENTS - BEGIN
7917+ {
7918+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 19LLU, 18LLU);
7919+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
7920+ }
7921+ // ACCUMULATE ARGUMENTS - END
7922+ uint64_t return_to = 18446744073709551303LLU;
7923+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
7924+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
7925+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
7926+ heap.data[0].elem1 = heap.data[0].elem0;
7927+ heap.data[0].elem0 = restore;
7928+ state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
7929+ break;
7930+ }
7931+ case 18446744073709551303LLU: // 999999995G'''''''''''''''
7932+ {
7933+ (void)LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference res1______ at 19
7934+ state.addr = 18446744073709551305LLU; // 999999995I'''''''''''''''
7935+ break;
7936+ }
7937+ case 18446744073709551306LLU: // 999999995J'''''''''''''''
7938+ {
7939+
7940+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 18LLU, 0LLU)) = 0;
7941+ state.addr = 18446744073709551305LLU; // 999999995I'''''''''''''''
7942+ break;
7943+ }
7944+ case 18446744073709551305LLU: // 999999995I'''''''''''''''
7945+ {
7946+ // parameter-reference resdest___ res0______ goes out of scope
7947+ // parameter-reference list<resdest___> xresults__ goes out of scope
7948+ state.addr = 18446744073709551309LLU; // 999999995M'''''''''''''''
7949+ break;
7950+ }
7951+ case 18446744073709551308LLU: // 999999995L'''''''''''''''
7952+ {
7953+ state.addr = /*yres______*/*LOCAL_ACCESS(heap.data, 16LLU, 15LLU) ? 18446744073709551302LLU : 18446744073709551301LLU;
7954+ break;
7955+ }
7956+ case 18446744073709551302LLU: // 999999995F'''''''''''''''
7957+ {
7958+ {
7959+ uint64_t arg = list_pop_move(&heap, &*LOCAL_ACCESS(heap.data, 16LLU, 15LLU)/*list*/, 8);
7960+ LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/*address of current closure*/, &arg);
7961+ }
7962+
7963+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 0LLU)) = 0;
7964+ // variable resdest___ res1______ goes out of scope
7965+ // emitted destructur for type resdest___
7966+ // ACCUMULATE ARGUMENTS - BEGIN
7967+ {
7968+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 17LLU, 16LLU);
7969+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
7970+ }
7971+ // ACCUMULATE ARGUMENTS - END
7972+ uint64_t return_to = 18446744073709551299LLU;
7973+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
7974+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
7975+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
7976+ heap.data[0].elem1 = heap.data[0].elem0;
7977+ heap.data[0].elem0 = restore;
7978+ state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
7979+ break;
7980+ }
7981+ case 18446744073709551299LLU: // 999999995C'''''''''''''''
7982+ {
7983+ (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference res1______ at 17
7984+ state.addr = 18446744073709551300LLU; // 999999995D'''''''''''''''
7985+ break;
7986+ }
7987+ case 18446744073709551301LLU: // 999999995E'''''''''''''''
7988+ {
7989+ state.addr = 18446744073709551300LLU; // 999999995D'''''''''''''''
7990+ break;
7991+ }
7992+ case 18446744073709551300LLU: // 999999995D'''''''''''''''
7993+ {
7994+ // variable list<resdest___> yres______ goes out of scope
7995+ // emitted destructur for type list<resdest___>
7996+ state.addr = 18446744073709551297LLU; // 999999995A'''''''''''''''
7997+ break;
7998+ }
7999+ case 18446744073709551297LLU: // 999999995A'''''''''''''''
8000+ {
8001+ if(!*LOCAL_ACCESS(heap.data, 16LLU, 15LLU)/*list*/)
8002+ {
8003+ state.addr = 18446744073709551298LLU; // 999999995B'''''''''''''''
8004+ break;
8005+ }
8006+ // temporary list-element
8007+ {
8008+ uint64_t arg = list_pop_move(&heap, &*LOCAL_ACCESS(heap.data, 16LLU, 15LLU)/*list*/, 8);
8009+ LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/*address of current closure*/, &arg);
8010+ }
8011+ // ACCUMULATE ARGUMENTS - BEGIN
8012+ {
8013+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 17LLU, 16LLU);
8014+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
8015+ }
8016+ // ACCUMULATE ARGUMENTS - END
8017+ uint64_t return_to = 18446744073709551296LLU;
8018+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
8019+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
8020+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
8021+ heap.data[0].elem1 = heap.data[0].elem0;
8022+ heap.data[0].elem0 = restore;
8023+ state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
8024+ break;
8025+ }
8026+ case 18446744073709551296LLU: // 999999995_'''''''''''''''
8027+ {
8028+ // RELEASE temporary destructor-variable
8029+ (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 17
8030+ state.addr = 18446744073709551297LLU; // 999999995A'''''''''''''''
8031+ break;
8032+ }
8033+ case 18446744073709551298LLU: // 999999995B'''''''''''''''
8034+ {
8035+ (void)LOCAL_POP_MOVE(&heap, 16LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference yres______ at 16
8036+ {
8037+ uint64_t arg = 0;
8038+ LOCAL_PUSH_MOVE(&heap, 15, &(heap.data[0].elem1)/*address of current closure*/, &arg);
8039+ }
8040+ {
8041+ uint64_t arg = /*ydefpars__*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 16LLU, 4LLU));
8042+ LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/*address of current closure*/, &arg);
8043+ }
8044+ {
8045+ uint64_t arg = 0;
8046+ LOCAL_PUSH_MOVE(&heap, 17, &(heap.data[0].elem1)/*address of current closure*/, &arg);
8047+ }
8048+ state.addr = 18446744073709551295LLU; // 9999999949'''''''''''''''
8049+ break;
8050+ }
8051+ case 18446744073709551295LLU: // 9999999949'''''''''''''''
8052+ {
8053+ if(!*LOCAL_ACCESS(heap.data, 18LLU, 16LLU))
8054+ {
8055+ (void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 18
8056+ (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 17
8057+ {
8058+ state.addr = 18446744073709551294LLU; // 9999999948'''''''''''''''
8059+ break;
8060+ }
8061+ }
8062+ /*direct*/*LOCAL_ACCESS(heap.data, 18LLU, 17LLU) = (*LOCAL_ACCESS(heap.data, 18LLU, 16LLU) << 1) + 1LLU;
8063+ *LOCAL_ACCESS(heap.data, 18LLU, 16LLU) = heap.data[*LOCAL_ACCESS(heap.data, 18LLU, 16LLU)].elem0;
8064+ {
8065+ uint64_t arg = 0;
8066+ LOCAL_PUSH_MOVE(&heap, 18, &(heap.data[0].elem1)/*address of current closure*/, &arg);
8067+ }
8068+ // ACCUMULATE ARGUMENTS - BEGIN
8069+ {
8070+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 19LLU, 18LLU);
8071+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
8072+ }
8073+ {
8074+ uint64_t arg = /*par1______*/*LOCAL_ACCESS(heap.data, 19LLU, 17LLU);
8075+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
8076+ }
8077+ // ACCUMULATE ARGUMENTS - END
8078+ uint64_t return_to = 18446744073709551290LLU;
8079+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
8080+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
8081+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
8082+ heap.data[0].elem1 = heap.data[0].elem0;
8083+ heap.data[0].elem0 = restore;
8084+ state.addr = 296309897384864500LLU; // ParDefCopy
8085+ break;
8086+ }
8087+ case 18446744073709551290LLU: // 9999999944'''''''''''''''
8088+ {
8089+ state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 19LLU, 18LLU), &*LOCAL_ACCESS(heap.data, 19LLU, 15LLU), 11) ? 18446744073709551293LLU : 18446744073709551292LLU;
8090+ break;
8091+ }
8092+ case 18446744073709551293LLU: // 9999999947'''''''''''''''
8093+ {
8094+ {
8095+ fprintf(stderr, "%s\n", "out of dynamic heap in equfndef - recompile compiler with more dynamic heap memory");
8096+ exit(-1);
8097+ }
8098+ // emitted destructur for type pardef____
8099+ // ACCUMULATE ARGUMENTS - BEGIN
8100+ {
8101+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 19LLU, 18LLU);
8102+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
8103+ }
8104+ // ACCUMULATE ARGUMENTS - END
8105+ uint64_t return_to = 18446744073709551289LLU;
8106+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
8107+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
8108+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
8109+ heap.data[0].elem1 = heap.data[0].elem0;
8110+ heap.data[0].elem0 = restore;
8111+ state.addr = 18446744073709551468LLU; // 999999997q'''''''''''''''
8112+ break;
8113+ }
8114+ case 18446744073709551289LLU: // 9999999943'''''''''''''''
8115+ {
8116+ // parameter pardef____ new_______ goes out of scope
8117+ state.addr = 18446744073709551291LLU; // 9999999945'''''''''''''''
8118+ break;
8119+ }
8120+ case 18446744073709551292LLU: // 9999999946'''''''''''''''
8121+ {
8122+ state.addr = 18446744073709551291LLU; // 9999999945'''''''''''''''
8123+ break;
8124+ }
8125+ case 18446744073709551291LLU: // 9999999945'''''''''''''''
8126+ {
8127+ (void)LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 19
8128+ // parameter-reference pardef____ par1______ goes out of scope
8129+ // parameter-reference list<pardef____> ydefpars__ goes out of scope
8130+ state.addr = 18446744073709551295LLU; // 9999999949'''''''''''''''
8131+ break;
8132+ }
8133+ case 18446744073709551294LLU: // 9999999948'''''''''''''''
8134+ {
8135+ list_reverse(heap.data, &/*ypars_____*/*LOCAL_ACCESS(heap.data, 16LLU, 15LLU));
8136+ {
8137+ uint64_t arg = /*xdefpars__*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 16LLU, 3LLU));
8138+ LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/*address of current closure*/, &arg);
8139+ }
8140+ {
8141+ uint64_t arg = 0;
8142+ LOCAL_PUSH_MOVE(&heap, 17, &(heap.data[0].elem1)/*address of current closure*/, &arg);
8143+ }
8144+ state.addr = 18446744073709551288LLU; // 9999999942'''''''''''''''
8145+ break;
8146+ }
8147+ case 18446744073709551288LLU: // 9999999942'''''''''''''''
8148+ {
8149+ if(!*LOCAL_ACCESS(heap.data, 18LLU, 16LLU))
8150+ {
8151+ (void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 18
8152+ (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 17
8153+ {
8154+ state.addr = 18446744073709551287LLU; // 9999999941'''''''''''''''
8155+ break;
8156+ }
8157+ }
8158+ /*direct*/*LOCAL_ACCESS(heap.data, 18LLU, 17LLU) = (*LOCAL_ACCESS(heap.data, 18LLU, 16LLU) << 1) + 1LLU;
8159+ *LOCAL_ACCESS(heap.data, 18LLU, 16LLU) = heap.data[*LOCAL_ACCESS(heap.data, 18LLU, 16LLU)].elem0;
8160+ state.addr = /*ypars_____*/*LOCAL_ACCESS(heap.data, 18LLU, 15LLU) ? 18446744073709551286LLU : 18446744073709551285LLU;
8161+ break;
8162+ }
8163+ case 18446744073709551286LLU: // 9999999940'''''''''''''''
8164+ {
8165+ {
8166+ uint64_t arg = list_pop_move(&heap, &*LOCAL_ACCESS(heap.data, 18LLU, 15LLU)/*list*/, 11);
8167+ LOCAL_PUSH_MOVE(&heap, 18, &(heap.data[0].elem1)/*address of current closure*/, &arg);
8168+ }
8169+ {
8170+ uint64_t arg = 0;
8171+ LOCAL_PUSH_MOVE(&heap, 19, &(heap.data[0].elem1)/*address of current closure*/, &arg);
8172+ }
8173+ *LOCAL_ACCESS(heap.data, 20LLU, 19LLU) = 0;
8174+ // ACCUMULATE ARGUMENTS - BEGIN
8175+ {
8176+ uint64_t arg = /*EQUAL_____*/LOCAL_ACCESS_ADDR(heap.data, 20LLU, 19LLU);
8177+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
8178+ }
8179+ {
8180+ uint64_t arg = /*par0______*/*LOCAL_ACCESS(heap.data, 20LLU, 17LLU);
8181+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
8182+ }
8183+ {
8184+ uint64_t arg = /*par1______*/LOCAL_ACCESS_ADDR(heap.data, 20LLU, 18LLU);
8185+ LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
8186+ }
8187+ // ACCUMULATE ARGUMENTS - END
8188+ uint64_t return_to = 18446744073709551283LLU;
8189+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0));
8190+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
8191+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
8192+ heap.data[0].elem1 = heap.data[0].elem0;
8193+ heap.data[0].elem0 = restore;
8194+ state.addr = 589059743276730432LLU; // equpardef_
8195+ break;
8196+ }
8197+ case 18446744073709551283LLU: // 999999994x'''''''''''''''
8198+ {
8199+
8200+ *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);
8201+ // variable u64 EQUAL_____ goes out of scope
8202+ // emitted destructur for type u64
8203+ (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference EQUAL_____ at 20
8204+ // variable pardef____ par1______ goes out of scope
8205+ // emitted destructur for type pardef____
8206+ // ACCUMULATE ARGUMENTS - BEGIN
8207+ {
8208+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 19LLU, 18LLU);
8209+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
8210+ }
8211+ // ACCUMULATE ARGUMENTS - END
8212+ uint64_t return_to = 18446744073709551282LLU;
8213+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
8214+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
8215+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
8216+ heap.data[0].elem1 = heap.data[0].elem0;
8217+ heap.data[0].elem0 = restore;
8218+ state.addr = 18446744073709551468LLU; // 999999997q'''''''''''''''
8219+ break;
8220+ }
8221+ case 18446744073709551282LLU: // 999999994w'''''''''''''''
8222+ {
8223+ (void)LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference par1______ at 19
8224+ state.addr = 18446744073709551284LLU; // 999999994y'''''''''''''''
8225+ break;
8226+ }
8227+ case 18446744073709551285LLU: // 999999994z'''''''''''''''
8228+ {
8229+
8230+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 18LLU, 0LLU)) = 0;
8231+ state.addr = 18446744073709551284LLU; // 999999994y'''''''''''''''
8232+ break;
8233+ }
8234+ case 18446744073709551284LLU: // 999999994y'''''''''''''''
8235+ {
8236+ // parameter-reference pardef____ par0______ goes out of scope
8237+ // parameter-reference list<pardef____> xdefpars__ goes out of scope
8238+ state.addr = 18446744073709551288LLU; // 9999999942'''''''''''''''
8239+ break;
8240+ }
8241+ case 18446744073709551287LLU: // 9999999941'''''''''''''''
8242+ {
8243+ state.addr = /*ypars_____*/*LOCAL_ACCESS(heap.data, 16LLU, 15LLU) ? 18446744073709551281LLU : 18446744073709551280LLU;
8244+ break;
8245+ }
8246+ case 18446744073709551281LLU: // 999999994v'''''''''''''''
8247+ {
8248+ {
8249+ uint64_t arg = list_pop_move(&heap, &*LOCAL_ACCESS(heap.data, 16LLU, 15LLU)/*list*/, 11);
8250+ LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/*address of current closure*/, &arg);
8251+ }
8252+
8253+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 0LLU)) = 0;
8254+ // variable pardef____ par1______ goes out of scope
8255+ // emitted destructur for type pardef____
8256+ // ACCUMULATE ARGUMENTS - BEGIN
8257+ {
8258+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 17LLU, 16LLU);
8259+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
8260+ }
8261+ // ACCUMULATE ARGUMENTS - END
8262+ uint64_t return_to = 18446744073709551278LLU;
8263+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
8264+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
8265+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
8266+ heap.data[0].elem1 = heap.data[0].elem0;
8267+ heap.data[0].elem0 = restore;
8268+ state.addr = 18446744073709551468LLU; // 999999997q'''''''''''''''
8269+ break;
8270+ }
8271+ case 18446744073709551278LLU: // 999999994s'''''''''''''''
8272+ {
8273+ (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference par1______ at 17
8274+ state.addr = 18446744073709551279LLU; // 999999994t'''''''''''''''
8275+ break;
8276+ }
8277+ case 18446744073709551280LLU: // 999999994u'''''''''''''''
8278+ {
8279+ state.addr = 18446744073709551279LLU; // 999999994t'''''''''''''''
8280+ break;
8281+ }
8282+ case 18446744073709551279LLU: // 999999994t'''''''''''''''
8283+ {
8284+ // variable list<pardef____> ypars_____ goes out of scope
8285+ // emitted destructur for type list<pardef____>
8286+ state.addr = 18446744073709551276LLU; // 999999994q'''''''''''''''
8287+ break;
8288+ }
8289+ case 18446744073709551276LLU: // 999999994q'''''''''''''''
8290+ {
8291+ if(!*LOCAL_ACCESS(heap.data, 16LLU, 15LLU)/*list*/)
8292+ {
8293+ state.addr = 18446744073709551277LLU; // 999999994r'''''''''''''''
8294+ break;
8295+ }
8296+ // temporary list-element
8297+ {
8298+ uint64_t arg = list_pop_move(&heap, &*LOCAL_ACCESS(heap.data, 16LLU, 15LLU)/*list*/, 11);
8299+ LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/*address of current closure*/, &arg);
8300+ }
8301+ // ACCUMULATE ARGUMENTS - BEGIN
8302+ {
8303+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 17LLU, 16LLU);
8304+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
8305+ }
8306+ // ACCUMULATE ARGUMENTS - END
8307+ uint64_t return_to = 18446744073709551275LLU;
8308+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
8309+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
8310+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
8311+ heap.data[0].elem1 = heap.data[0].elem0;
8312+ heap.data[0].elem0 = restore;
8313+ state.addr = 18446744073709551468LLU; // 999999997q'''''''''''''''
8314+ break;
8315+ }
8316+ case 18446744073709551275LLU: // 999999994p'''''''''''''''
8317+ {
8318+ // RELEASE temporary destructor-variable
8319+ (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 17
8320+ state.addr = 18446744073709551276LLU; // 999999994q'''''''''''''''
8321+ break;
8322+ }
8323+ case 18446744073709551277LLU: // 999999994r'''''''''''''''
8324+ {
8325+ (void)LOCAL_POP_MOVE(&heap, 16LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference ypars_____ at 16
8326+ {
8327+ uint64_t arg = 0;
8328+ LOCAL_PUSH_MOVE(&heap, 15, &(heap.data[0].elem1)/*address of current closure*/, &arg);
8329+ }
8330+ *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));
8331+
8332+ *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);
8333+ // variable u64 EQUAL_____ goes out of scope
8334+ // emitted destructur for type u64
8335+ (void)LOCAL_POP_MOVE(&heap, 16LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference EQUAL_____ at 16
8336+ {
8337+ uint64_t arg = 0;
8338+ LOCAL_PUSH_MOVE(&heap, 15, &(heap.data[0].elem1)/*address of current closure*/, &arg);
8339+ }
8340+ *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));
8341+
8342+ *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);
8343+ // variable u64 EQUAL_____ goes out of scope
8344+ // emitted destructur for type u64
8345+ (void)LOCAL_POP_MOVE(&heap, 16LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference EQUAL_____ at 16
8346+ {
8347+ uint64_t arg = 0;
8348+ LOCAL_PUSH_MOVE(&heap, 15, &(heap.data[0].elem1)/*address of current closure*/, &arg);
8349+ }
8350+ *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));
8351+
8352+ *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);
8353+ // variable u64 EQUAL_____ goes out of scope
8354+ // emitted destructur for type u64
8355+ (void)LOCAL_POP_MOVE(&heap, 16LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference EQUAL_____ at 16
8356+ {
8357+ uint64_t arg = 0;
8358+ LOCAL_PUSH_MOVE(&heap, 15, &(heap.data[0].elem1)/*address of current closure*/, &arg);
8359+ }
8360+ *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));
8361+
8362+ *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);
8363+ // variable u64 EQUAL_____ goes out of scope
8364+ // emitted destructur for type u64
8365+ (void)LOCAL_POP_MOVE(&heap, 16LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference EQUAL_____ at 16
8366+ {
8367+ uint64_t arg = 0;
8368+ LOCAL_PUSH_MOVE(&heap, 15, &(heap.data[0].elem1)/*address of current closure*/, &arg);
8369+ }
8370+ *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));
8371+
8372+ *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);
8373+ // variable u64 EQUAL_____ goes out of scope
8374+ // emitted destructur for type u64
8375+ (void)LOCAL_POP_MOVE(&heap, 16LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference EQUAL_____ at 16
8376+ // parameter-reference u64 ysafe_____ goes out of scope
8377+ (void)LOCAL_POP_MOVE(&heap, 15LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference ysafe_____ at 15
8378+ // parameter-reference u64 xsafe_____ goes out of scope
8379+ (void)LOCAL_POP_MOVE(&heap, 14LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference xsafe_____ at 14
8380+ // parameter-reference u64 yfinite___ goes out of scope
8381+ (void)LOCAL_POP_MOVE(&heap, 13LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference yfinite___ at 13
8382+ // parameter-reference u64 xfinite___ goes out of scope
8383+ (void)LOCAL_POP_MOVE(&heap, 12LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference xfinite___ at 12
8384+ // parameter-reference u64 ycomplete_ goes out of scope
8385+ (void)LOCAL_POP_MOVE(&heap, 11LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference ycomplete_ at 11
8386+ // parameter-reference u64 xcomplete_ goes out of scope
8387+ (void)LOCAL_POP_MOVE(&heap, 10LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference xcomplete_ at 10
8388+ // parameter-reference u64 ydefbodysz goes out of scope
8389+ (void)LOCAL_POP_MOVE(&heap, 9LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference ydefbodysz at 9
8390+ // parameter-reference u64 xdefbodysz goes out of scope
8391+ (void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference xdefbodysz at 8
8392+ // parameter-reference u64 ysizeoheap goes out of scope
8393+ (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference ysizeoheap at 7
8394+ // parameter-reference u64 xsizeoheap goes out of scope
8395+ (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference xsizeoheap at 6
8396+ // parameter-reference list<pardef____> ydefpars__ goes out of scope
8397+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference ydefpars__ at 5
8398+ // parameter-reference list<pardef____> xdefpars__ goes out of scope
8399+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference xdefpars__ at 4
8400+ // parameter-reference list<resdest___> yresults__ goes out of scope
8401+ (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference yresults__ at 3
8402+ // parameter-reference list<resdest___> xresults__ goes out of scope
8403+ (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference xresults__ at 2
8404+ // parameter-reference u64 equal_____ goes out of scope
8405+ (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference equal_____ at 1
8406+ {
8407+ uint64_t baseinfo = heap.data[0].elem1;
8408+ struct pair pair = unpair(&heap, &baseinfo);
8409+ *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
8410+ state.addr = pair.elem1;
8411+ }
8412+ break;
8413+ }
8414+ case 589059069805989888LLU: // equfndef__
8415+ {
8416+
8417+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU)) = 1;
8418+ {
8419+ uint64_t arg = 0;
8420+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
8421+ }
8422+ {
8423+ uint64_t arg = /*y_________*/*access_heap(heap.data, tree_elem_addr(heap.data, 7LLU, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU), 0LLU));
8424+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
8425+ }
8426+ {
8427+ uint64_t arg = 0;
8428+ LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg);
8429+ }
8430+ state.addr = 18446744073709551274LLU; // 999999994o'''''''''''''''
8431+ break;
8432+ }
8433+ case 18446744073709551274LLU: // 999999994o'''''''''''''''
8434+ {
8435+ if(!*LOCAL_ACCESS(heap.data, 6LLU, 4LLU))
8436+ {
8437+ (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 6
8438+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 5
8439+ {
8440+ state.addr = 18446744073709551273LLU; // 999999994n'''''''''''''''
8441+ break;
8442+ }
8443+ }
8444+ /*direct*/*LOCAL_ACCESS(heap.data, 6LLU, 5LLU) = (*LOCAL_ACCESS(heap.data, 6LLU, 4LLU) << 1) + 1LLU;
8445+ *LOCAL_ACCESS(heap.data, 6LLU, 4LLU) = heap.data[*LOCAL_ACCESS(heap.data, 6LLU, 4LLU)].elem0;
8446+ {
8447+ uint64_t arg = 0;
8448+ LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg);
8449+ }
8450+ // ACCUMULATE ARGUMENTS - BEGIN
8451+ {
8452+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 7LLU, 6LLU);
8453+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
8454+ }
8455+ {
8456+ uint64_t arg = /*respar1___*/*LOCAL_ACCESS(heap.data, 7LLU, 5LLU);
8457+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
8458+ }
8459+ // ACCUMULATE ARGUMENTS - END
8460+ uint64_t return_to = 18446744073709551269LLU;
8461+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
8462+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
8463+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
8464+ heap.data[0].elem1 = heap.data[0].elem0;
8465+ heap.data[0].elem0 = restore;
8466+ state.addr = 325750391286068249LLU; // RESDEFCOPY
8467+ break;
8468+ }
8469+ case 18446744073709551269LLU: // 999999994j'''''''''''''''
8470+ {
8471+ state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 7LLU, 6LLU), &*LOCAL_ACCESS(heap.data, 7LLU, 3LLU), 8) ? 18446744073709551272LLU : 18446744073709551271LLU;
8472+ break;
8473+ }
8474+ case 18446744073709551272LLU: // 999999994m'''''''''''''''
8475+ {
8476+ {
8477+ fprintf(stderr, "%s\n", "out of dynamic heap in equfndef - recompile compiler with more dynamic heap memory");
8478+ exit(-1);
8479+ }
8480+ // emitted destructur for type resdest___
8481+ // ACCUMULATE ARGUMENTS - BEGIN
8482+ {
8483+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 7LLU, 6LLU);
8484+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
8485+ }
8486+ // ACCUMULATE ARGUMENTS - END
8487+ uint64_t return_to = 18446744073709551268LLU;
8488+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
8489+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
8490+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
8491+ heap.data[0].elem1 = heap.data[0].elem0;
8492+ heap.data[0].elem0 = restore;
8493+ state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
8494+ break;
8495+ }
8496+ case 18446744073709551268LLU: // 999999994i'''''''''''''''
8497+ {
8498+ // parameter resdest___ new_______ goes out of scope
8499+ state.addr = 18446744073709551270LLU; // 999999994k'''''''''''''''
8500+ break;
8501+ }
8502+ case 18446744073709551271LLU: // 999999994l'''''''''''''''
8503+ {
8504+ state.addr = 18446744073709551270LLU; // 999999994k'''''''''''''''
8505+ break;
8506+ }
8507+ case 18446744073709551270LLU: // 999999994k'''''''''''''''
8508+ {
8509+ (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 7
8510+ // parameter-reference resdest___ respar1___ goes out of scope
8511+ // parameter-reference function__ y_________ goes out of scope
8512+ state.addr = 18446744073709551274LLU; // 999999994o'''''''''''''''
8513+ break;
8514+ }
8515+ case 18446744073709551273LLU: // 999999994n'''''''''''''''
8516+ {
8517+ list_reverse(heap.data, &/*yres______*/*LOCAL_ACCESS(heap.data, 4LLU, 3LLU));
8518+ {
8519+ uint64_t arg = /*x_________*/*access_heap(heap.data, tree_elem_addr(heap.data, 7LLU, *LOCAL_ACCESS(heap.data, 4LLU, 1LLU), 0LLU));
8520+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
8521+ }
8522+ {
8523+ uint64_t arg = 0;
8524+ LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg);
8525+ }
8526+ state.addr = 18446744073709551267LLU; // 999999994h'''''''''''''''
8527+ break;
8528+ }
8529+ case 18446744073709551267LLU: // 999999994h'''''''''''''''
8530+ {
8531+ if(!*LOCAL_ACCESS(heap.data, 6LLU, 4LLU))
8532+ {
8533+ (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 6
8534+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 5
8535+ {
8536+ state.addr = 18446744073709551266LLU; // 999999994g'''''''''''''''
8537+ break;
8538+ }
8539+ }
8540+ /*direct*/*LOCAL_ACCESS(heap.data, 6LLU, 5LLU) = (*LOCAL_ACCESS(heap.data, 6LLU, 4LLU) << 1) + 1LLU;
8541+ *LOCAL_ACCESS(heap.data, 6LLU, 4LLU) = heap.data[*LOCAL_ACCESS(heap.data, 6LLU, 4LLU)].elem0;
8542+ state.addr = /*yres______*/*LOCAL_ACCESS(heap.data, 6LLU, 3LLU) ? 18446744073709551265LLU : 18446744073709551264LLU;
8543+ break;
8544+ }
8545+ case 18446744073709551265LLU: // 999999994f'''''''''''''''
8546+ {
8547+ {
8548+ uint64_t arg = list_pop_move(&heap, &*LOCAL_ACCESS(heap.data, 6LLU, 3LLU)/*list*/, 8);
8549+ LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg);
8550+ }
8551+ {
8552+ uint64_t arg = 0;
8553+ LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/*address of current closure*/, &arg);
8554+ }
8555+ *LOCAL_ACCESS(heap.data, 8LLU, 7LLU) = 0;
8556+ // ACCUMULATE ARGUMENTS - BEGIN
8557+ {
8558+ uint64_t arg = /*EQUAL_____*/LOCAL_ACCESS_ADDR(heap.data, 8LLU, 7LLU);
8559+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
8560+ }
8561+ {
8562+ uint64_t arg = /*res0______*/*LOCAL_ACCESS(heap.data, 8LLU, 5LLU);
8563+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
8564+ }
8565+ {
8566+ uint64_t arg = /*res1______*/LOCAL_ACCESS_ADDR(heap.data, 8LLU, 6LLU);
8567+ LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
8568+ }
8569+ // ACCUMULATE ARGUMENTS - END
8570+ uint64_t return_to = 18446744073709551262LLU;
8571+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0));
8572+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
8573+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
8574+ heap.data[0].elem1 = heap.data[0].elem0;
8575+ heap.data[0].elem0 = restore;
8576+ state.addr = 589059885019168768LLU; // equres____
8577+ break;
8578+ }
8579+ case 18446744073709551262LLU: // 999999994c'''''''''''''''
8580+ {
8581+
8582+ *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);
8583+ // variable u64 EQUAL_____ goes out of scope
8584+ // emitted destructur for type u64
8585+ (void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference EQUAL_____ at 8
8586+ // variable resdest___ res1______ goes out of scope
8587+ // emitted destructur for type resdest___
8588+ // ACCUMULATE ARGUMENTS - BEGIN
8589+ {
8590+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 7LLU, 6LLU);
8591+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
8592+ }
8593+ // ACCUMULATE ARGUMENTS - END
8594+ uint64_t return_to = 18446744073709551261LLU;
8595+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
8596+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
8597+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
8598+ heap.data[0].elem1 = heap.data[0].elem0;
8599+ heap.data[0].elem0 = restore;
8600+ state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
8601+ break;
8602+ }
8603+ case 18446744073709551261LLU: // 999999994b'''''''''''''''
8604+ {
8605+ (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference res1______ at 7
8606+ state.addr = 18446744073709551263LLU; // 999999994d'''''''''''''''
8607+ break;
8608+ }
8609+ case 18446744073709551264LLU: // 999999994e'''''''''''''''
8610+ {
8611+
8612+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 6LLU, 0LLU)) = 0;
8613+ state.addr = 18446744073709551263LLU; // 999999994d'''''''''''''''
8614+ break;
8615+ }
8616+ case 18446744073709551263LLU: // 999999994d'''''''''''''''
8617+ {
8618+ // parameter-reference resdest___ res0______ goes out of scope
8619+ // parameter-reference function__ x_________ goes out of scope
8620+ state.addr = 18446744073709551267LLU; // 999999994h'''''''''''''''
8621+ break;
8622+ }
8623+ case 18446744073709551266LLU: // 999999994g'''''''''''''''
8624+ {
8625+ state.addr = /*yres______*/*LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551260LLU : 18446744073709551259LLU;
8626+ break;
8627+ }
8628+ case 18446744073709551260LLU: // 999999994a'''''''''''''''
8629+ {
8630+ {
8631+ uint64_t arg = list_pop_move(&heap, &*LOCAL_ACCESS(heap.data, 4LLU, 3LLU)/*list*/, 8);
8632+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
8633+ }
8634+
8635+ *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 0LLU)) = 0;
8636+ // variable resdest___ res1______ goes out of scope
8637+ // emitted destructur for type resdest___
8638+ // ACCUMULATE ARGUMENTS - BEGIN
8639+ {
8640+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 5LLU, 4LLU);
8641+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
8642+ }
8643+ // ACCUMULATE ARGUMENTS - END
8644+ uint64_t return_to = 18446744073709551257LLU;
8645+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
8646+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
8647+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
8648+ heap.data[0].elem1 = heap.data[0].elem0;
8649+ heap.data[0].elem0 = restore;
8650+ state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
8651+ break;
8652+ }
8653+ case 18446744073709551257LLU: // 999999994Y'''''''''''''''
8654+ {
8655+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference res1______ at 5
8656+ state.addr = 18446744073709551258LLU; // 999999994Z'''''''''''''''
8657+ break;
8658+ }
8659+ case 18446744073709551259LLU: // 999999994$'''''''''''''''
8660+ {
8661+ state.addr = 18446744073709551258LLU; // 999999994Z'''''''''''''''
8662+ break;
8663+ }
8664+ case 18446744073709551258LLU: // 999999994Z'''''''''''''''
8665+ {
8666+ // variable list<resdest___> yres______ goes out of scope
8667+ // emitted destructur for type list<resdest___>
8668+ state.addr = 18446744073709551255LLU; // 999999994W'''''''''''''''
8669+ break;
8670+ }
8671+ case 18446744073709551255LLU: // 999999994W'''''''''''''''
8672+ {
8673+ if(!*LOCAL_ACCESS(heap.data, 4LLU, 3LLU)/*list*/)
8674+ {
8675+ state.addr = 18446744073709551256LLU; // 999999994X'''''''''''''''
8676+ break;
8677+ }
8678+ // temporary list-element
8679+ {
8680+ uint64_t arg = list_pop_move(&heap, &*LOCAL_ACCESS(heap.data, 4LLU, 3LLU)/*list*/, 8);
8681+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
8682+ }
8683+ // ACCUMULATE ARGUMENTS - BEGIN
8684+ {
8685+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 5LLU, 4LLU);
8686+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
8687+ }
8688+ // ACCUMULATE ARGUMENTS - END
8689+ uint64_t return_to = 18446744073709551254LLU;
8690+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
8691+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
8692+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
8693+ heap.data[0].elem1 = heap.data[0].elem0;
8694+ heap.data[0].elem0 = restore;
8695+ state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
8696+ break;
8697+ }
8698+ case 18446744073709551254LLU: // 999999994V'''''''''''''''
8699+ {
8700+ // RELEASE temporary destructor-variable
8701+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 5
8702+ state.addr = 18446744073709551255LLU; // 999999994W'''''''''''''''
8703+ break;
8704+ }
8705+ case 18446744073709551256LLU: // 999999994X'''''''''''''''
8706+ {
8707+ (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference yres______ at 4
8708+ {
8709+ uint64_t arg = 0;
8710+ LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
8711+ }
8712+ {
8713+ uint64_t arg = /*y_________*/*access_heap(heap.data, tree_elem_addr(heap.data, 7LLU, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU), 1LLU));
8714+ LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
8715+ }
8716+ {
8717+ uint64_t arg = 0;
8718+ LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg);
8719+ }
8720+ state.addr = 18446744073709551253LLU; // 999999994U'''''''''''''''
8721+ break;
8722+ }
8723+ case 18446744073709551253LLU: // 999999994U'''''''''''''''
8724+ {
8725+ if(!*LOCAL_ACCESS(heap.data, 6LLU, 4LLU))
8726+ {
8727+ (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 6
8728+ (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 5
8729+ {
8730+ state.addr = 18446744073709551252LLU; // 999999994T'''''''''''''''
8731+ break;
8732+ }
8733+ }
8734+ /*direct*/*LOCAL_ACCESS(heap.data, 6LLU, 5LLU) = (*LOCAL_ACCESS(heap.data, 6LLU, 4LLU) << 1) + 1LLU;
8735+ *LOCAL_ACCESS(heap.data, 6LLU, 4LLU) = heap.data[*LOCAL_ACCESS(heap.data, 6LLU, 4LLU)].elem0;
8736+ {
8737+ uint64_t arg = 0;
8738+ LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg);
8739+ }
8740+ // ACCUMULATE ARGUMENTS - BEGIN
8741+ {
8742+ uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 7LLU, 6LLU);
8743+ LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
8744+ }
8745+ {
8746+ uint64_t arg = /*par1______*/*LOCAL_ACCESS(heap.data, 7LLU, 5LLU);
8747+ LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
8748+ }
8749+ // ACCUMULATE ARGUMENTS - END
8750+ uint64_t return_to = 18446744073709551248LLU;
8751+ const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
8752+ uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
8753+ *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
8754+ heap.data[0].elem1 = heap.data[0].elem0;
8755+ heap.data[0].elem0 = restore;
8756+ state.addr = 296309897384864500LLU; // ParDefCopy
8757+ break;
8758+ }
8759+ case 18446744073709551248LLU: // 999999994P'''''''''''''''
8760+ {
8761+ state.addr = !list_push_move(&heap, &*

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

Show on old repository browser