• R/O
  • SSH
  • HTTPS

jpl: Commit


Commit MetaInfo

Revision1001 (tree)
Time2020-05-02 06:05:33
Authorjakobthomsen

Log Message

tag produce-version

Change Summary

Incremental Difference

--- 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].elem