• R/O
  • SSH
  • HTTPS

jpl: Commit


Commit MetaInfo

Revision989 (tree)
Time2020-04-29 09:47:12
Authorjakobthomsen

Log Message

rename to mark recursive parser milestone

Change Summary

Incremental Difference

--- trunk/jpl_compiler_own_stack_and_heap(tree-closures-memory)-variant-using-constructor-functions/info.txt (revision 988)
+++ trunk/jpl_compiler_own_stack_and_heap(tree-closures-memory)-variant-using-constructor-functions/info.txt (nonexistent)
@@ -1,16 +0,0 @@
1-Jakob's Programming Language (working title) -
2-a self-hosting compiler for a total imperative/procedural programming language,
3-i.e. compile-time safe language (no space-leaks, no time-leaks).
4-To be self-hosting verifies the languages capability and acts as additional regression-test.
5-This version was started 2019-03-08 and is based on previous attempts (dating back to 2008).
6-Stack-safety & heap-safety implemented.
7-Uses references with allocation/initialization tracking (rather than call-by-value),
8-combined with linear types/sub-structural types (consume/produce annotations).
9-All functions must be marked total/partial & are compile-time verified to be so.
10-Memory (based on binary number trees) organized in closures rather than monolithic stack.
11-Recursion allows programmer to handle overflow SAFELY (instead of crashing program).
12-The compiler verifies itself to be finite
13-(i.e. always halts when input ends - Turing-completeness NOT required for compiler!).
14-Syntax supports (non-recursive) pattern-matching (with basic exhaustiveness-check).
15-Currently with limited support for recursive types in compound-types
16-(non-mutually recursive occurrences only & must be wrapped in list).
--- trunk/jpl_compiler_own_stack_and_heap(tree-closures-memory)-variant-using-constructor-functions/jpl_compiler.c (revision 988)
+++ trunk/jpl_compiler_own_stack_and_heap(tree-closures-memory)-variant-using-constructor-functions/jpl_compiler.c (nonexistent)
@@ -1,100150 +0,0 @@
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 list, uint64_t *const size)
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()
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-
658- *LOCAL_ACCESS(heap.data, 3LLU, 2LLU) = /*lookahead_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU)) > /*result____*/*LOCAL_ACCESS(heap.data, 3LLU, 2LLU);
659- *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU)) = /*result____*/*LOCAL_ACCESS(heap.data, 3LLU, 2LLU);
660- // variable u64 result____ goes out of scope
661- // emitted destructur for type u64
662- (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference result____ at 3
663- // parameter-reference u64 lookahead_ goes out of scope
664- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference lookahead_ at 2
665- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
666- {
667- uint64_t baseinfo = heap.data[0].elem1;
668- struct pair pair = unpair(&heap, &baseinfo);
669- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
670- state.addr = pair.elem1;
671- }
672- break;
673- }
674- case 661649452408901632LLU: // isnoteof__
675- {
676- {
677- uint64_t arg = 0;
678- LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
679- }
680- *LOCAL_ACCESS(heap.data, 3LLU, 2LLU) = 255;
681-
682- *LOCAL_ACCESS(heap.data, 3LLU, 2LLU) = /*lookahead_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU)) <= /*result____*/*LOCAL_ACCESS(heap.data, 3LLU, 2LLU);
683- *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU)) = /*result____*/*LOCAL_ACCESS(heap.data, 3LLU, 2LLU);
684- // variable u64 result____ goes out of scope
685- // emitted destructur for type u64
686- (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference result____ at 3
687- // parameter-reference u64 lookahead_ goes out of scope
688- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference lookahead_ at 2
689- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
690- {
691- uint64_t baseinfo = heap.data[0].elem1;
692- struct pair pair = unpair(&heap, &baseinfo);
693- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
694- state.addr = pair.elem1;
695- }
696- break;
697- }
698- case 661648768551262208LLU: // isnewline_
699- {
700- if(*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU)) != 10)
701- {
702- state.addr = 18446744073709551614LLU; // 9999999998'''''''''''''''
703- break;
704- }
705- *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 0LLU)) = 1LLU;
706- // parameter-reference u64 __________ goes out of scope
707- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
708- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
709- {
710- uint64_t baseinfo = heap.data[0].elem1;
711- struct pair pair = unpair(&heap, &baseinfo);
712- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
713- state.addr = pair.elem1;
714- }
715- break;
716- }
717- case 18446744073709551614LLU: // 9999999998'''''''''''''''
718- {
719- *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 0LLU)) = 0LLU;
720- // parameter-reference u64 __________ goes out of scope
721- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
722- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
723- {
724- uint64_t baseinfo = heap.data[0].elem1;
725- struct pair pair = unpair(&heap, &baseinfo);
726- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
727- state.addr = pair.elem1;
728- }
729- break;
730- }
731- case 661671490923528192LLU: // isspace___
732- {
733- if(*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU)) != 9)
734- {
735- state.addr = 18446744073709551612LLU; // 9999999996'''''''''''''''
736- break;
737- }
738- *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 0LLU)) = 1LLU;
739- // parameter-reference u64 __________ goes out of scope
740- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
741- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
742- {
743- uint64_t baseinfo = heap.data[0].elem1;
744- struct pair pair = unpair(&heap, &baseinfo);
745- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
746- state.addr = pair.elem1;
747- }
748- break;
749- }
750- case 18446744073709551612LLU: // 9999999996'''''''''''''''
751- {
752- if(*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU)) != 10)
753- {
754- state.addr = 18446744073709551611LLU; // 9999999995'''''''''''''''
755- break;
756- }
757- *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 0LLU)) = 1LLU;
758- // parameter-reference u64 __________ goes out of scope
759- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
760- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
761- {
762- uint64_t baseinfo = heap.data[0].elem1;
763- struct pair pair = unpair(&heap, &baseinfo);
764- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
765- state.addr = pair.elem1;
766- }
767- break;
768- }
769- case 18446744073709551611LLU: // 9999999995'''''''''''''''
770- {
771- if(*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU)) != 11)
772- {
773- state.addr = 18446744073709551610LLU; // 9999999994'''''''''''''''
774- break;
775- }
776- *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 0LLU)) = 1LLU;
777- // parameter-reference u64 __________ goes out of scope
778- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
779- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
780- {
781- uint64_t baseinfo = heap.data[0].elem1;
782- struct pair pair = unpair(&heap, &baseinfo);
783- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
784- state.addr = pair.elem1;
785- }
786- break;
787- }
788- case 18446744073709551610LLU: // 9999999994'''''''''''''''
789- {
790- if(*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU)) != 12)
791- {
792- state.addr = 18446744073709551609LLU; // 9999999993'''''''''''''''
793- break;
794- }
795- *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 0LLU)) = 1LLU;
796- // parameter-reference u64 __________ goes out of scope
797- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
798- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
799- {
800- uint64_t baseinfo = heap.data[0].elem1;
801- struct pair pair = unpair(&heap, &baseinfo);
802- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
803- state.addr = pair.elem1;
804- }
805- break;
806- }
807- case 18446744073709551609LLU: // 9999999993'''''''''''''''
808- {
809- if(*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU)) != 13)
810- {
811- state.addr = 18446744073709551608LLU; // 9999999992'''''''''''''''
812- break;
813- }
814- *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 0LLU)) = 1LLU;
815- // parameter-reference u64 __________ goes out of scope
816- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
817- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
818- {
819- uint64_t baseinfo = heap.data[0].elem1;
820- struct pair pair = unpair(&heap, &baseinfo);
821- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
822- state.addr = pair.elem1;
823- }
824- break;
825- }
826- case 18446744073709551608LLU: // 9999999992'''''''''''''''
827- {
828- if(*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU)) != 32)
829- {
830- state.addr = 18446744073709551607LLU; // 9999999991'''''''''''''''
831- break;
832- }
833- *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 0LLU)) = 1LLU;
834- // parameter-reference u64 __________ goes out of scope
835- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
836- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
837- {
838- uint64_t baseinfo = heap.data[0].elem1;
839- struct pair pair = unpair(&heap, &baseinfo);
840- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
841- state.addr = pair.elem1;
842- }
843- break;
844- }
845- case 18446744073709551607LLU: // 9999999991'''''''''''''''
846- {
847- *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 0LLU)) = 0LLU;
848- // parameter-reference u64 __________ goes out of scope
849- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
850- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
851- {
852- uint64_t baseinfo = heap.data[0].elem1;
853- struct pair pair = unpair(&heap, &baseinfo);
854- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
855- state.addr = pair.elem1;
856- }
857- break;
858- }
859- case 661680303159640064LLU: // isupper___
860- {
861- {
862- uint64_t arg = 0;
863- LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
864- }
865- *LOCAL_ACCESS(heap.data, 3LLU, 2LLU) = 65;
866- {
867- uint64_t arg = 0;
868- LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
869- }
870- *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = 0;
871- {
872- uint64_t arg = 0;
873- LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
874- }
875- *LOCAL_ACCESS(heap.data, 5LLU, 4LLU) = /*lookahead_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 1LLU)) >= /*sym_______*/*LOCAL_ACCESS(heap.data, 5LLU, 2LLU);
876- state.addr = *LOCAL_ACCESS(heap.data, 5LLU, 4LLU) ? 18446744073709551605LLU : 18446744073709551604LLU;
877- (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 5
878- break;
879- }
880- case 18446744073709551605LLU: // 999999999z'''''''''''''''
881- {
882-
883- *LOCAL_ACCESS(heap.data, 4LLU, 2LLU) = 90;
884- {
885- uint64_t arg = 0;
886- LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
887- }
888- *LOCAL_ACCESS(heap.data, 5LLU, 4LLU) = /*lookahead_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 1LLU)) <= /*sym_______*/*LOCAL_ACCESS(heap.data, 5LLU, 2LLU);
889- state.addr = *LOCAL_ACCESS(heap.data, 5LLU, 4LLU) ? 18446744073709551603LLU : 18446744073709551602LLU;
890- (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 5
891- break;
892- }
893- case 18446744073709551603LLU: // 999999999x'''''''''''''''
894- {
895-
896- *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = 1;
897- state.addr = 18446744073709551602LLU; // 999999999w'''''''''''''''
898- break;
899- }
900- case 18446744073709551602LLU: // 999999999w'''''''''''''''
901- {
902- state.addr = 18446744073709551604LLU; // 999999999y'''''''''''''''
903- break;
904- }
905- case 18446744073709551604LLU: // 999999999y'''''''''''''''
906- {
907- *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU)) = /*result____*/*LOCAL_ACCESS(heap.data, 4LLU, 3LLU);
908- // variable u64 result____ goes out of scope
909- // emitted destructur for type u64
910- (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference result____ at 4
911- // variable u64 sym_______ goes out of scope
912- // emitted destructur for type u64
913- (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference sym_______ at 3
914- // parameter-reference u64 lookahead_ goes out of scope
915- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference lookahead_ at 2
916- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
917- {
918- uint64_t baseinfo = heap.data[0].elem1;
919- struct pair pair = unpair(&heap, &baseinfo);
920- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
921- state.addr = pair.elem1;
922- }
923- break;
924- }
925- case 661640659537756160LLU: // islower___
926- {
927- {
928- uint64_t arg = 0;
929- LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
930- }
931- *LOCAL_ACCESS(heap.data, 3LLU, 2LLU) = 97;
932- {
933- uint64_t arg = 0;
934- LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
935- }
936- *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = 0;
937- {
938- uint64_t arg = 0;
939- LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
940- }
941- *LOCAL_ACCESS(heap.data, 5LLU, 4LLU) = /*lookahead_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 1LLU)) >= /*sym_______*/*LOCAL_ACCESS(heap.data, 5LLU, 2LLU);
942- state.addr = *LOCAL_ACCESS(heap.data, 5LLU, 4LLU) ? 18446744073709551601LLU : 18446744073709551600LLU;
943- (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 5
944- break;
945- }
946- case 18446744073709551601LLU: // 999999999v'''''''''''''''
947- {
948-
949- *LOCAL_ACCESS(heap.data, 4LLU, 2LLU) = 122;
950- {
951- uint64_t arg = 0;
952- LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
953- }
954- *LOCAL_ACCESS(heap.data, 5LLU, 4LLU) = /*lookahead_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 1LLU)) <= /*sym_______*/*LOCAL_ACCESS(heap.data, 5LLU, 2LLU);
955- state.addr = *LOCAL_ACCESS(heap.data, 5LLU, 4LLU) ? 18446744073709551599LLU : 18446744073709551598LLU;
956- (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 5
957- break;
958- }
959- case 18446744073709551599LLU: // 999999999t'''''''''''''''
960- {
961-
962- *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = 1;
963- state.addr = 18446744073709551598LLU; // 999999999s'''''''''''''''
964- break;
965- }
966- case 18446744073709551598LLU: // 999999999s'''''''''''''''
967- {
968- state.addr = 18446744073709551600LLU; // 999999999u'''''''''''''''
969- break;
970- }
971- case 18446744073709551600LLU: // 999999999u'''''''''''''''
972- {
973- *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU)) = /*result____*/*LOCAL_ACCESS(heap.data, 4LLU, 3LLU);
974- // variable u64 result____ goes out of scope
975- // emitted destructur for type u64
976- (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference result____ at 4
977- // variable u64 sym_______ goes out of scope
978- // emitted destructur for type u64
979- (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference sym_______ at 3
980- // parameter-reference u64 lookahead_ goes out of scope
981- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference lookahead_ at 2
982- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
983- {
984- uint64_t baseinfo = heap.data[0].elem1;
985- struct pair pair = unpair(&heap, &baseinfo);
986- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
987- state.addr = pair.elem1;
988- }
989- break;
990- }
991- case 661592067397386240LLU: // isalpha___
992- {
993- {
994- uint64_t arg = 0;
995- LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
996- }
997- *LOCAL_ACCESS(heap.data, 3LLU, 2LLU) = 0;
998- {
999- uint64_t arg = 0;
1000- LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1001- }
1002- // ACCUMULATE ARGUMENTS - BEGIN
1003- {
1004- uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 4LLU, 3LLU);
1005- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
1006- }
1007- {
1008- uint64_t arg = /*lookahead_*/*LOCAL_ACCESS(heap.data, 4LLU, 1LLU);
1009- LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
1010- }
1011- // ACCUMULATE ARGUMENTS - END
1012- uint64_t return_to = 18446744073709551594LLU;
1013- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
1014- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
1015- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
1016- heap.data[0].elem1 = heap.data[0].elem0;
1017- heap.data[0].elem0 = restore;
1018- state.addr = 661680303159640064LLU; // isupper___
1019- break;
1020- }
1021- case 18446744073709551594LLU: // 999999999o'''''''''''''''
1022- {
1023- state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551597LLU : 18446744073709551596LLU;
1024- (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
1025- break;
1026- }
1027- case 18446744073709551597LLU: // 999999999r'''''''''''''''
1028- {
1029-
1030- *LOCAL_ACCESS(heap.data, 3LLU, 2LLU) = 1;
1031- state.addr = 18446744073709551595LLU; // 999999999p'''''''''''''''
1032- break;
1033- }
1034- case 18446744073709551596LLU: // 999999999q'''''''''''''''
1035- {
1036- {
1037- uint64_t arg = 0;
1038- LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1039- }
1040- // ACCUMULATE ARGUMENTS - BEGIN
1041- {
1042- uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 4LLU, 3LLU);
1043- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
1044- }
1045- {
1046- uint64_t arg = /*lookahead_*/*LOCAL_ACCESS(heap.data, 4LLU, 1LLU);
1047- LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
1048- }
1049- // ACCUMULATE ARGUMENTS - END
1050- uint64_t return_to = 18446744073709551591LLU;
1051- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
1052- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
1053- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
1054- heap.data[0].elem1 = heap.data[0].elem0;
1055- heap.data[0].elem0 = restore;
1056- state.addr = 661640659537756160LLU; // islower___
1057- break;
1058- }
1059- case 18446744073709551591LLU: // 999999999l'''''''''''''''
1060- {
1061- state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551593LLU : 18446744073709551592LLU;
1062- (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
1063- break;
1064- }
1065- case 18446744073709551593LLU: // 999999999n'''''''''''''''
1066- {
1067-
1068- *LOCAL_ACCESS(heap.data, 3LLU, 2LLU) = 1;
1069- state.addr = 18446744073709551592LLU; // 999999999m'''''''''''''''
1070- break;
1071- }
1072- case 18446744073709551592LLU: // 999999999m'''''''''''''''
1073- {
1074- state.addr = 18446744073709551595LLU; // 999999999p'''''''''''''''
1075- break;
1076- }
1077- case 18446744073709551595LLU: // 999999999p'''''''''''''''
1078- {
1079- *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU)) = /*result____*/*LOCAL_ACCESS(heap.data, 3LLU, 2LLU);
1080- // variable u64 result____ goes out of scope
1081- // emitted destructur for type u64
1082- (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference result____ at 3
1083- // parameter-reference u64 lookahead_ goes out of scope
1084- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference lookahead_ at 2
1085- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
1086- {
1087- uint64_t baseinfo = heap.data[0].elem1;
1088- struct pair pair = unpair(&heap, &baseinfo);
1089- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
1090- state.addr = pair.elem1;
1091- }
1092- break;
1093- }
1094- case 661605045736570880LLU: // isdigit___
1095- {
1096- {
1097- uint64_t arg = 0;
1098- LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1099- }
1100- *LOCAL_ACCESS(heap.data, 3LLU, 2LLU) = 48;
1101- {
1102- uint64_t arg = 0;
1103- LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1104- }
1105- *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /*lookahead_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 1LLU)) >= /*result____*/*LOCAL_ACCESS(heap.data, 4LLU, 2LLU);
1106- state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551590LLU : 18446744073709551589LLU;
1107- (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
1108- break;
1109- }
1110- case 18446744073709551590LLU: // 999999999k'''''''''''''''
1111- {
1112-
1113- *LOCAL_ACCESS(heap.data, 3LLU, 2LLU) = 57;
1114-
1115- *LOCAL_ACCESS(heap.data, 3LLU, 2LLU) = /*lookahead_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU)) <= /*result____*/*LOCAL_ACCESS(heap.data, 3LLU, 2LLU);
1116- {
1117- uint64_t arg = 0;
1118- LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1119- }
1120- *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /*result____*/*LOCAL_ACCESS(heap.data, 4LLU, 2LLU);
1121- state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551588LLU : 18446744073709551587LLU;
1122- (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
1123- break;
1124- }
1125- case 18446744073709551588LLU: // 999999999i'''''''''''''''
1126- {
1127- state.addr = 18446744073709551587LLU; // 999999999h'''''''''''''''
1128- break;
1129- }
1130- case 18446744073709551587LLU: // 999999999h'''''''''''''''
1131- {
1132- state.addr = 18446744073709551589LLU; // 999999999j'''''''''''''''
1133- break;
1134- }
1135- case 18446744073709551589LLU: // 999999999j'''''''''''''''
1136- {
1137- *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU)) = /*result____*/*LOCAL_ACCESS(heap.data, 3LLU, 2LLU);
1138- // variable u64 result____ goes out of scope
1139- // emitted destructur for type u64
1140- (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference result____ at 3
1141- // parameter-reference u64 lookahead_ goes out of scope
1142- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference lookahead_ at 2
1143- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
1144- {
1145- uint64_t baseinfo = heap.data[0].elem1;
1146- struct pair pair = unpair(&heap, &baseinfo);
1147- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
1148- state.addr = pair.elem1;
1149- }
1150- break;
1151- }
1152- case 839519719621918720LLU: // skipws____
1153- {
1154- {
1155- uint64_t arg = 0;
1156- LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1157- }
1158- // ACCUMULATE ARGUMENTS - BEGIN
1159- {
1160- uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 2LLU, 1LLU);
1161- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
1162- }
1163- {
1164- uint64_t arg = /*lookahead_*/*LOCAL_ACCESS(heap.data, 2LLU, 0LLU);
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 = 18446744073709551584LLU;
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 18446744073709551584LLU: // 999999999e'''''''''''''''
1178- {
1179- state.addr = *LOCAL_ACCESS(heap.data, 2LLU, 1LLU) ? 18446744073709551586LLU : 18446744073709551585LLU;
1180- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
1181- break;
1182- }
1183- case 18446744073709551586LLU: // 999999999g'''''''''''''''
1184- {
1185- {
1186- uint64_t arg = 0;
1187- LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1188- }
1189- *LOCAL_ACCESS(heap.data, 2LLU, 1LLU) = 0;
1190- state.addr = 18446744073709551583LLU; // 999999999d'''''''''''''''
1191- break;
1192- }
1193- case 18446744073709551583LLU: // 999999999d'''''''''''''''
1194- {
1195- *LOCAL_ACCESS(heap.data, 2LLU, 1LLU) = (uint64_t)getchar();
1196- if(!*LOCAL_ACCESS(heap.data, 2LLU, 1LLU) || *LOCAL_ACCESS(heap.data, 2LLU, 1LLU) > 255)
1197- {
1198- state.addr = 18446744073709551582LLU; // 999999999c'''''''''''''''
1199- break;
1200- }
1201- {
1202- uint64_t arg = 0;
1203- LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1204- }
1205- // ACCUMULATE ARGUMENTS - BEGIN
1206- {
1207- uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 3LLU, 2LLU);
1208- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
1209- }
1210- {
1211- uint64_t arg = /*c_________*/LOCAL_ACCESS_ADDR(heap.data, 3LLU, 1LLU);
1212- LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
1213- }
1214- // ACCUMULATE ARGUMENTS - END
1215- uint64_t return_to = 18446744073709551578LLU;
1216- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
1217- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
1218- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
1219- heap.data[0].elem1 = heap.data[0].elem0;
1220- heap.data[0].elem0 = restore;
1221- state.addr = 661671490923528192LLU; // isspace___
1222- break;
1223- }
1224- case 18446744073709551578LLU: // 999999999Z'''''''''''''''
1225- {
1226- state.addr = *LOCAL_ACCESS(heap.data, 3LLU, 2LLU) ? 18446744073709551581LLU : 18446744073709551580LLU;
1227- (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 3
1228- break;
1229- }
1230- case 18446744073709551581LLU: // 999999999b'''''''''''''''
1231- {
1232- state.addr = 18446744073709551579LLU; // 999999999$'''''''''''''''
1233- break;
1234- }
1235- case 18446744073709551580LLU: // 999999999a'''''''''''''''
1236- {
1237-
1238- *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 0LLU)) = /*c_________*/*LOCAL_ACCESS(heap.data, 2LLU, 1LLU);
1239- ungetc(0, stdin);
1240- state.addr = 18446744073709551579LLU; // 999999999$'''''''''''''''
1241- break;
1242- }
1243- case 18446744073709551579LLU: // 999999999$'''''''''''''''
1244- {
1245- state.addr = 18446744073709551583LLU; // 999999999d'''''''''''''''
1246- break;
1247- }
1248- case 18446744073709551582LLU: // 999999999c'''''''''''''''
1249- {
1250- // variable u64 c_________ goes out of scope
1251- // emitted destructur for type u64
1252- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference c_________ at 2
1253- state.addr = 18446744073709551585LLU; // 999999999f'''''''''''''''
1254- break;
1255- }
1256- case 18446744073709551585LLU: // 999999999f'''''''''''''''
1257- {
1258- // parameter-reference u64 lookahead_ goes out of scope
1259- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference lookahead_ at 1
1260- {
1261- uint64_t baseinfo = heap.data[0].elem1;
1262- struct pair pair = unpair(&heap, &baseinfo);
1263- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
1264- state.addr = pair.elem1;
1265- }
1266- break;
1267- }
1268- case 728666047794575267LLU: // matchoptch
1269- {
1270- {
1271- uint64_t arg = 0;
1272- LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1273- }
1274- *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));
1275- state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551577LLU : 18446744073709551576LLU;
1276- (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
1277- break;
1278- }
1279- case 18446744073709551577LLU: // 999999999Y'''''''''''''''
1280- {
1281-
1282- *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 2LLU)) = (uint64_t)getchar();
1283-
1284- *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU)) = 1;
1285- state.addr = 18446744073709551575LLU; // 999999999W'''''''''''''''
1286- break;
1287- }
1288- case 18446744073709551576LLU: // 999999999X'''''''''''''''
1289- {
1290-
1291- *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU)) = 0;
1292- state.addr = 18446744073709551575LLU; // 999999999W'''''''''''''''
1293- break;
1294- }
1295- case 18446744073709551575LLU: // 999999999W'''''''''''''''
1296- {
1297- // parameter-reference u64 lookahead_ goes out of scope
1298- (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference lookahead_ at 3
1299- // parameter-reference u64 expected__ goes out of scope
1300- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference expected__ at 2
1301- // parameter-reference u64 result____ goes out of scope
1302- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference result____ at 1
1303- {
1304- uint64_t baseinfo = heap.data[0].elem1;
1305- struct pair pair = unpair(&heap, &baseinfo);
1306- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
1307- state.addr = pair.elem1;
1308- }
1309- break;
1310- }
1311- case 891913148528723755LLU: // verifyheap
1312- {
1313- fprintf(stdout, "%s", "\n uint64_t node = heap.freelist;");
1314- fprintf(stdout, "%s", "\n for(uint64_t count = 0; count < ");
1315- // ACCUMULATE ARGUMENTS - BEGIN
1316- {
1317- uint64_t arg = /*heapsize__*/*LOCAL_ACCESS(heap.data, 1LLU, 0LLU);
1318- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
1319- }
1320- // ACCUMULATE ARGUMENTS - END
1321- uint64_t return_to = 18446744073709551574LLU;
1322- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
1323- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
1324- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
1325- heap.data[0].elem1 = heap.data[0].elem0;
1326- heap.data[0].elem0 = restore;
1327- state.addr = 787446708198178816LLU; // printnr___
1328- break;
1329- }
1330- case 18446744073709551574LLU: // 999999999V'''''''''''''''
1331- {
1332- fprintf(stdout, "%s", "; count++)");
1333- fprintf(stdout, "%s", "\n {");
1334- fprintf(stdout, "%s", "\n if(0 == node)");
1335- fprintf(stdout, "%s", "\n {");
1336- fprintf(stdout, "%s", "\n for(uint64_t i = ");
1337- // ACCUMULATE ARGUMENTS - BEGIN
1338- {
1339- uint64_t arg = /*heapsize__*/*LOCAL_ACCESS(heap.data, 1LLU, 0LLU);
1340- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
1341- }
1342- // ACCUMULATE ARGUMENTS - END
1343- uint64_t return_to = 18446744073709551573LLU;
1344- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
1345- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
1346- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
1347- heap.data[0].elem1 = heap.data[0].elem0;
1348- heap.data[0].elem0 = restore;
1349- state.addr = 787446708198178816LLU; // printnr___
1350- break;
1351- }
1352- case 18446744073709551573LLU: // 999999999U'''''''''''''''
1353- {
1354- fprintf(stdout, "%s", "; i > 0; i--)");
1355- fprintf(stdout, "%s", "\n {");
1356- 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);");
1357- fprintf(stdout, "%s", "\n }");
1358- fprintf(stdout, "%s", "\n fprintf(stderr, \"FREE-LIST TRUNCATED (memory-leak?): zero-entry at length %llu\\n\", (unsigned long long)count);");
1359- fprintf(stdout, "%s", "\n exit(-1);");
1360- fprintf(stdout, "%s", "\n }");
1361- fprintf(stdout, "%s", "\n node = heap.data[node].elem0;");
1362- fprintf(stdout, "%s", "\n if(node > ");
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 = 18446744073709551572LLU;
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 18446744073709551572LLU: // 999999999T'''''''''''''''
1379- {
1380- fprintf(stdout, "%s", ")");
1381- fprintf(stdout, "%s", "\n {");
1382- fprintf(stdout, "%s", "\n for(uint64_t i = ");
1383- // ACCUMULATE ARGUMENTS - BEGIN
1384- {
1385- uint64_t arg = /*heapsize__*/*LOCAL_ACCESS(heap.data, 1LLU, 0LLU);
1386- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
1387- }
1388- // ACCUMULATE ARGUMENTS - END
1389- uint64_t return_to = 18446744073709551571LLU;
1390- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
1391- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
1392- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
1393- heap.data[0].elem1 = heap.data[0].elem0;
1394- heap.data[0].elem0 = restore;
1395- state.addr = 787446708198178816LLU; // printnr___
1396- break;
1397- }
1398- case 18446744073709551571LLU: // 999999999S'''''''''''''''
1399- {
1400- fprintf(stdout, "%s", "; i > 0; i--)");
1401- fprintf(stdout, "%s", "\n {");
1402- 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);");
1403- fprintf(stdout, "%s", "\n }");
1404- fprintf(stdout, "%s", "\n fprintf(stderr, \"FREE-LIST CORRUPTED: entry %llu at length %llu exceeds bounds ");
1405- fprintf(stdout, "%llu", (unsigned long long)/*heapsize__*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
1406- fprintf(stdout, "%s", "\\n\", (unsigned long long)node, (unsigned long long)count);");
1407- fprintf(stdout, "%s", "\n exit(-1);");
1408- fprintf(stdout, "%s", "\n }");
1409- fprintf(stdout, "%s", "\n }");
1410- fprintf(stdout, "%s", "\n if(node)");
1411- fprintf(stdout, "%s", "\n {");
1412- fprintf(stdout, "%s", "\n for(uint64_t i = ");
1413- // ACCUMULATE ARGUMENTS - BEGIN
1414- {
1415- uint64_t arg = /*heapsize__*/*LOCAL_ACCESS(heap.data, 1LLU, 0LLU);
1416- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
1417- }
1418- // ACCUMULATE ARGUMENTS - END
1419- uint64_t return_to = 18446744073709551570LLU;
1420- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
1421- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
1422- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
1423- heap.data[0].elem1 = heap.data[0].elem0;
1424- heap.data[0].elem0 = restore;
1425- state.addr = 787446708198178816LLU; // printnr___
1426- break;
1427- }
1428- case 18446744073709551570LLU: // 999999999R'''''''''''''''
1429- {
1430- fprintf(stdout, "%s", "; i > 0; i--)");
1431- fprintf(stdout, "%s", "\n {");
1432- 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);");
1433- fprintf(stdout, "%s", "\n }");
1434- fprintf(stdout, "%s", "\n fprintf(stderr, \"FREE-LIST CIRCULAR\\n\");");
1435- fprintf(stdout, "%s", "\n exit(-1);");
1436- fprintf(stdout, "%s", "\n }");
1437- fprintf(stdout, "%s", "\n");
1438- // parameter-reference u64 heapsize__ goes out of scope
1439- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference heapsize__ at 1
1440- {
1441- uint64_t baseinfo = heap.data[0].elem1;
1442- struct pair pair = unpair(&heap, &baseinfo);
1443- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
1444- state.addr = pair.elem1;
1445- }
1446- break;
1447- }
1448- case 18446744073709551568LLU: // 999999999P'''''''''''''''
1449- {
1450- // destructor for variant typelist__
1451- {
1452- uint64_t arg = tree_pop_move(&heap, 1LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
1453- LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1454- }
1455- // emitted destructur for type u64
1456- // RELEASE temporary destructor-variable
1457- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
1458- // RELEASE destructor-argument
1459- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 1
1460- {
1461- uint64_t baseinfo = heap.data[0].elem1;
1462- struct pair pair = unpair(&heap, &baseinfo);
1463- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
1464- state.addr = pair.elem1;
1465- }
1466- break;
1467- }
1468- case 18446744073709551567LLU: // 999999999O'''''''''''''''
1469- {
1470- // destructor for variant typename__
1471- {
1472- uint64_t arg = tree_pop_move(&heap, 1LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
1473- LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1474- }
1475- // emitted destructur for type u64
1476- // RELEASE temporary destructor-variable
1477- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
1478- // RELEASE destructor-argument
1479- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 1
1480- {
1481- uint64_t baseinfo = heap.data[0].elem1;
1482- struct pair pair = unpair(&heap, &baseinfo);
1483- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
1484- state.addr = pair.elem1;
1485- }
1486- break;
1487- }
1488- case 18446744073709551566LLU: // 999999999N'''''''''''''''
1489- {
1490- // destructor for variant typeu64___
1491- // RELEASE destructor-argument
1492- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 1
1493- {
1494- uint64_t baseinfo = heap.data[0].elem1;
1495- struct pair pair = unpair(&heap, &baseinfo);
1496- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
1497- state.addr = pair.elem1;
1498- }
1499- break;
1500- }
1501- case 18446744073709551569LLU: // 999999999Q'''''''''''''''
1502- {
1503- struct pair type_data = unpair(&heap, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
1504- *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)) = type_data.elem1;
1505- state.addr = 18446744073709551566LLU + type_data.elem0;
1506- break;
1507- }
1508- case 861504786250002432LLU: // typelist__
1509- {
1510- // union-constructor typelist__
1511- {
1512- uint64_t result_tuple = 0;
1513- // copy references
1514- {
1515- uint64_t elem = *LOCAL_ACCESS(heap.data, 1LLU + 1, 0LLU + 1);
1516- tree_push_move(&heap, 0LLU, &result_tuple, &elem);
1517- }
1518- // release parameters
1519- {
1520- (void)LOCAL_POP_MOVE(&heap, 1LLU + 1, &(heap.data[0].elem1)/*memory root*/);
1521- }
1522- {
1523- uint64_t constridx = 2LLU;
1524- uint64_t root = pair_move(&heap, &constridx, &result_tuple);
1525- *access_heap(heap.data, LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*memory root*/)) = root;
1526- }
1527- }
1528- {
1529- uint64_t baseinfo = heap.data[0].elem1;
1530- struct pair pair = unpair(&heap, &baseinfo);
1531- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
1532- state.addr = pair.elem1;
1533- }
1534- break;
1535- }
1536- case 861504788261634048LLU: // typename__
1537- {
1538- // union-constructor typename__
1539- {
1540- uint64_t result_tuple = 0;
1541- // copy references
1542- {
1543- uint64_t elem = *LOCAL_ACCESS(heap.data, 1LLU + 1, 0LLU + 1);
1544- tree_push_move(&heap, 0LLU, &result_tuple, &elem);
1545- }
1546- // release parameters
1547- {
1548- (void)LOCAL_POP_MOVE(&heap, 1LLU + 1, &(heap.data[0].elem1)/*memory root*/);
1549- }
1550- {
1551- uint64_t constridx = 1LLU;
1552- uint64_t root = pair_move(&heap, &constridx, &result_tuple);
1553- *access_heap(heap.data, LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*memory root*/)) = root;
1554- }
1555- }
1556- {
1557- uint64_t baseinfo = heap.data[0].elem1;
1558- struct pair pair = unpair(&heap, &baseinfo);
1559- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
1560- state.addr = pair.elem1;
1561- }
1562- break;
1563- }
1564- case 861504796319285248LLU: // typeu64___
1565- {
1566- // union-constructor typeu64___
1567- {
1568- uint64_t result_tuple = 0;
1569- // copy references
1570- // release parameters
1571- {
1572- uint64_t constridx = 0LLU;
1573- uint64_t root = pair_move(&heap, &constridx, &result_tuple);
1574- *access_heap(heap.data, LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*memory root*/)) = root;
1575- }
1576- }
1577- {
1578- uint64_t baseinfo = heap.data[0].elem1;
1579- struct pair pair = unpair(&heap, &baseinfo);
1580- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
1581- state.addr = pair.elem1;
1582- }
1583- break;
1584- }
1585- case 589060043891015680LLU: // equtype___
1586- {
1587- if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU))].elem0 != 0/*typeu64___*/)
1588- {
1589- state.addr = 18446744073709551565LLU; // 999999999M'''''''''''''''
1590- break;
1591- }
1592- {
1593- uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 1LLU);
1594- LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1595- }
1596- if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU))].elem0 != 0/*typeu64___*/)
1597- {
1598- (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
1599- state.addr = 18446744073709551565LLU; // 999999999M'''''''''''''''
1600- break;
1601- }
1602- {
1603- uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU), 1LLU);
1604- LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1605- }
1606- *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 0LLU)) = 1LLU;
1607- // parameter-reference type______ __________ goes out of scope
1608- (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 5
1609- // parameter type______ __________ goes out of scope
1610- (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 4
1611- // parameter-reference type______ __________ goes out of scope
1612- (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3
1613- // parameter type______ __________ goes out of scope
1614- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
1615- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
1616- {
1617- uint64_t baseinfo = heap.data[0].elem1;
1618- struct pair pair = unpair(&heap, &baseinfo);
1619- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
1620- state.addr = pair.elem1;
1621- }
1622- break;
1623- }
1624- case 18446744073709551565LLU: // 999999999M'''''''''''''''
1625- {
1626- if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU))].elem0 != 1/*typename__*/)
1627- {
1628- state.addr = 18446744073709551564LLU; // 999999999L'''''''''''''''
1629- break;
1630- }
1631- {
1632- uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 1LLU);
1633- LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1634- }
1635- if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU))].elem0 != 0/*typeu64___*/)
1636- {
1637- (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
1638- state.addr = 18446744073709551564LLU; // 999999999L'''''''''''''''
1639- break;
1640- }
1641- {
1642- uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU), 1LLU);
1643- LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1644- }
1645- *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 0LLU)) = 0LLU;
1646- // parameter-reference type______ __________ goes out of scope
1647- (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 5
1648- // parameter type______ __________ goes out of scope
1649- (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 4
1650- // parameter-reference type______ __________ goes out of scope
1651- (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3
1652- // parameter type______ __________ goes out of scope
1653- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
1654- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
1655- {
1656- uint64_t baseinfo = heap.data[0].elem1;
1657- struct pair pair = unpair(&heap, &baseinfo);
1658- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
1659- state.addr = pair.elem1;
1660- }
1661- break;
1662- }
1663- case 18446744073709551564LLU: // 999999999L'''''''''''''''
1664- {
1665- if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU))].elem0 != 2/*typelist__*/)
1666- {
1667- state.addr = 18446744073709551563LLU; // 999999999K'''''''''''''''
1668- break;
1669- }
1670- {
1671- uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 1LLU);
1672- LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1673- }
1674- if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU))].elem0 != 0/*typeu64___*/)
1675- {
1676- (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
1677- state.addr = 18446744073709551563LLU; // 999999999K'''''''''''''''
1678- break;
1679- }
1680- {
1681- uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU), 1LLU);
1682- LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1683- }
1684- *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 0LLU)) = 0LLU;
1685- // parameter-reference type______ __________ goes out of scope
1686- (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 5
1687- // parameter type______ __________ goes out of scope
1688- (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 4
1689- // parameter-reference type______ __________ goes out of scope
1690- (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3
1691- // parameter type______ __________ goes out of scope
1692- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
1693- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
1694- {
1695- uint64_t baseinfo = heap.data[0].elem1;
1696- struct pair pair = unpair(&heap, &baseinfo);
1697- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
1698- state.addr = pair.elem1;
1699- }
1700- break;
1701- }
1702- case 18446744073709551563LLU: // 999999999K'''''''''''''''
1703- {
1704- if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU))].elem0 != 0/*typeu64___*/)
1705- {
1706- state.addr = 18446744073709551562LLU; // 999999999J'''''''''''''''
1707- break;
1708- }
1709- {
1710- uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 1LLU);
1711- LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1712- }
1713- if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU))].elem0 != 1/*typename__*/)
1714- {
1715- (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
1716- state.addr = 18446744073709551562LLU; // 999999999J'''''''''''''''
1717- break;
1718- }
1719- {
1720- uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU), 1LLU);
1721- LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1722- }
1723- *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 0LLU)) = 0LLU;
1724- // parameter-reference type______ __________ goes out of scope
1725- (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 5
1726- // parameter type______ __________ goes out of scope
1727- (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 4
1728- // parameter-reference type______ __________ goes out of scope
1729- (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3
1730- // parameter type______ __________ goes out of scope
1731- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
1732- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
1733- {
1734- uint64_t baseinfo = heap.data[0].elem1;
1735- struct pair pair = unpair(&heap, &baseinfo);
1736- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
1737- state.addr = pair.elem1;
1738- }
1739- break;
1740- }
1741- case 18446744073709551562LLU: // 999999999J'''''''''''''''
1742- {
1743- if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU))].elem0 != 1/*typename__*/)
1744- {
1745- state.addr = 18446744073709551561LLU; // 999999999I'''''''''''''''
1746- break;
1747- }
1748- {
1749- uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 1LLU);
1750- LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1751- }
1752- {
1753- uint64_t arg = tree_elem_addr(heap.data, 1LLU, *LOCAL_ACCESS(heap.data, 4LLU, 3LLU), 0LLU);
1754- LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1755- }
1756- if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 2LLU))].elem0 != 1/*typename__*/)
1757- {
1758- (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 5
1759- (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
1760- state.addr = 18446744073709551561LLU; // 999999999I'''''''''''''''
1761- break;
1762- }
1763- {
1764- uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 5LLU, 2LLU), 1LLU);
1765- LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1766- }
1767- {
1768- uint64_t arg = tree_elem_addr(heap.data, 1LLU, *LOCAL_ACCESS(heap.data, 6LLU, 5LLU), 0LLU);
1769- LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1770- }
1771- *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));
1772- // parameter-reference u64 y_________ goes out of scope
1773- (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference y_________ at 7
1774- // parameter-reference type______ __________ goes out of scope
1775- (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 6
1776- // parameter type______ __________ goes out of scope
1777- (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 5
1778- // parameter-reference u64 x_________ goes out of scope
1779- (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference x_________ at 4
1780- // parameter-reference type______ __________ goes out of scope
1781- (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3
1782- // parameter type______ __________ goes out of scope
1783- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
1784- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
1785- {
1786- uint64_t baseinfo = heap.data[0].elem1;
1787- struct pair pair = unpair(&heap, &baseinfo);
1788- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
1789- state.addr = pair.elem1;
1790- }
1791- break;
1792- }
1793- case 18446744073709551561LLU: // 999999999I'''''''''''''''
1794- {
1795- if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU))].elem0 != 2/*typelist__*/)
1796- {
1797- state.addr = 18446744073709551560LLU; // 999999999H'''''''''''''''
1798- break;
1799- }
1800- {
1801- uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 1LLU);
1802- LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1803- }
1804- if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU))].elem0 != 1/*typename__*/)
1805- {
1806- (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
1807- state.addr = 18446744073709551560LLU; // 999999999H'''''''''''''''
1808- break;
1809- }
1810- {
1811- uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU), 1LLU);
1812- LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1813- }
1814- *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 0LLU)) = 0LLU;
1815- // parameter-reference type______ __________ goes out of scope
1816- (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 5
1817- // parameter type______ __________ goes out of scope
1818- (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 4
1819- // parameter-reference type______ __________ goes out of scope
1820- (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3
1821- // parameter type______ __________ goes out of scope
1822- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
1823- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
1824- {
1825- uint64_t baseinfo = heap.data[0].elem1;
1826- struct pair pair = unpair(&heap, &baseinfo);
1827- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
1828- state.addr = pair.elem1;
1829- }
1830- break;
1831- }
1832- case 18446744073709551560LLU: // 999999999H'''''''''''''''
1833- {
1834- if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU))].elem0 != 0/*typeu64___*/)
1835- {
1836- state.addr = 18446744073709551559LLU; // 999999999G'''''''''''''''
1837- break;
1838- }
1839- {
1840- uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 1LLU);
1841- LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1842- }
1843- if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU))].elem0 != 2/*typelist__*/)
1844- {
1845- (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
1846- state.addr = 18446744073709551559LLU; // 999999999G'''''''''''''''
1847- break;
1848- }
1849- {
1850- uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU), 1LLU);
1851- LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1852- }
1853- *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 0LLU)) = 0LLU;
1854- // parameter-reference type______ __________ goes out of scope
1855- (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 5
1856- // parameter type______ __________ goes out of scope
1857- (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 4
1858- // parameter-reference type______ __________ goes out of scope
1859- (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3
1860- // parameter type______ __________ goes out of scope
1861- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
1862- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
1863- {
1864- uint64_t baseinfo = heap.data[0].elem1;
1865- struct pair pair = unpair(&heap, &baseinfo);
1866- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
1867- state.addr = pair.elem1;
1868- }
1869- break;
1870- }
1871- case 18446744073709551559LLU: // 999999999G'''''''''''''''
1872- {
1873- if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU))].elem0 != 1/*typename__*/)
1874- {
1875- state.addr = 18446744073709551558LLU; // 999999999F'''''''''''''''
1876- break;
1877- }
1878- {
1879- uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 1LLU);
1880- LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1881- }
1882- if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU))].elem0 != 2/*typelist__*/)
1883- {
1884- (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
1885- state.addr = 18446744073709551558LLU; // 999999999F'''''''''''''''
1886- break;
1887- }
1888- {
1889- uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU), 1LLU);
1890- LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1891- }
1892- *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 0LLU)) = 0LLU;
1893- // parameter-reference type______ __________ goes out of scope
1894- (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 5
1895- // parameter type______ __________ goes out of scope
1896- (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 4
1897- // parameter-reference type______ __________ goes out of scope
1898- (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3
1899- // parameter type______ __________ goes out of scope
1900- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
1901- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
1902- {
1903- uint64_t baseinfo = heap.data[0].elem1;
1904- struct pair pair = unpair(&heap, &baseinfo);
1905- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
1906- state.addr = pair.elem1;
1907- }
1908- break;
1909- }
1910- case 18446744073709551558LLU: // 999999999F'''''''''''''''
1911- {
1912- if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU))].elem0 != 2/*typelist__*/)
1913- {
1914- state.addr = 18446744073709551557LLU; // 999999999E'''''''''''''''
1915- break;
1916- }
1917- {
1918- uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 1LLU);
1919- LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1920- }
1921- {
1922- uint64_t arg = tree_elem_addr(heap.data, 1LLU, *LOCAL_ACCESS(heap.data, 4LLU, 3LLU), 0LLU);
1923- LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1924- }
1925- if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 2LLU))].elem0 != 2/*typelist__*/)
1926- {
1927- (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 5
1928- (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
1929- state.addr = 18446744073709551557LLU; // 999999999E'''''''''''''''
1930- break;
1931- }
1932- {
1933- uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 5LLU, 2LLU), 1LLU);
1934- LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1935- }
1936- {
1937- uint64_t arg = tree_elem_addr(heap.data, 1LLU, *LOCAL_ACCESS(heap.data, 6LLU, 5LLU), 0LLU);
1938- LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1939- }
1940- *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));
1941- // parameter-reference u64 y_________ goes out of scope
1942- (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference y_________ at 7
1943- // parameter-reference type______ __________ goes out of scope
1944- (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 6
1945- // parameter type______ __________ goes out of scope
1946- (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 5
1947- // parameter-reference u64 x_________ goes out of scope
1948- (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference x_________ at 4
1949- // parameter-reference type______ __________ goes out of scope
1950- (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3
1951- // parameter type______ __________ goes out of scope
1952- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
1953- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
1954- {
1955- uint64_t baseinfo = heap.data[0].elem1;
1956- struct pair pair = unpair(&heap, &baseinfo);
1957- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
1958- state.addr = pair.elem1;
1959- }
1960- break;
1961- }
1962- case 18446744073709551557LLU: // 999999999E'''''''''''''''
1963- {
1964- fprintf(stderr, "INTERNAL COMPILER ERROR: missing pattern-match-case in definition of equtype___\n");
1965- exit(-1);
1966- break;
1967- }
1968- case 861504787186880512LLU: // typemain__
1969- {
1970- if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 != 0/*typeu64___*/)
1971- {
1972- state.addr = 18446744073709551556LLU; // 999999999D'''''''''''''''
1973- break;
1974- }
1975- {
1976- uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU), 1LLU);
1977- LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
1978- }
1979-
1980- *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU)) = 881834713755418624;
1981- // parameter-reference type______ __________ goes out of scope
1982- (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3
1983- // parameter type______ __________ goes out of scope
1984- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
1985- // parameter-reference u64 maintype__ goes out of scope
1986- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference maintype__ at 1
1987- {
1988- uint64_t baseinfo = heap.data[0].elem1;
1989- struct pair pair = unpair(&heap, &baseinfo);
1990- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
1991- state.addr = pair.elem1;
1992- }
1993- break;
1994- }
1995- case 18446744073709551556LLU: // 999999999D'''''''''''''''
1996- {
1997- if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 != 1/*typename__*/)
1998- {
1999- state.addr = 18446744073709551555LLU; // 999999999C'''''''''''''''
2000- break;
2001- }
2002- {
2003- uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU), 1LLU);
2004- LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2005- }
2006- {
2007- uint64_t arg = tree_elem_addr(heap.data, 1LLU, *LOCAL_ACCESS(heap.data, 3LLU, 2LLU), 0LLU);
2008- LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2009- }
2010-
2011- *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU)) = /*name______*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 3LLU));
2012- // parameter-reference u64 name______ goes out of scope
2013- (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference name______ at 4
2014- // parameter-reference type______ __________ goes out of scope
2015- (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3
2016- // parameter type______ __________ goes out of scope
2017- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
2018- // parameter-reference u64 maintype__ goes out of scope
2019- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference maintype__ at 1
2020- {
2021- uint64_t baseinfo = heap.data[0].elem1;
2022- struct pair pair = unpair(&heap, &baseinfo);
2023- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
2024- state.addr = pair.elem1;
2025- }
2026- break;
2027- }
2028- case 18446744073709551555LLU: // 999999999C'''''''''''''''
2029- {
2030- if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 != 2/*typelist__*/)
2031- {
2032- state.addr = 18446744073709551554LLU; // 999999999B'''''''''''''''
2033- break;
2034- }
2035- {
2036- uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU), 1LLU);
2037- LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2038- }
2039-
2040- *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU)) = 712900180986298368;
2041- // parameter-reference type______ __________ goes out of scope
2042- (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3
2043- // parameter type______ __________ goes out of scope
2044- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
2045- // parameter-reference u64 maintype__ goes out of scope
2046- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference maintype__ at 1
2047- {
2048- uint64_t baseinfo = heap.data[0].elem1;
2049- struct pair pair = unpair(&heap, &baseinfo);
2050- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
2051- state.addr = pair.elem1;
2052- }
2053- break;
2054- }
2055- case 18446744073709551554LLU: // 999999999B'''''''''''''''
2056- {
2057- fprintf(stderr, "INTERNAL COMPILER ERROR: missing pattern-match-case in definition of typemain__\n");
2058- exit(-1);
2059- break;
2060- }
2061- case 861504793962872832LLU: // typesub___
2062- {
2063- if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 != 0/*typeu64___*/)
2064- {
2065- state.addr = 18446744073709551553LLU; // 999999999A'''''''''''''''
2066- break;
2067- }
2068- {
2069- uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU), 1LLU);
2070- LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2071- }
2072-
2073- *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU)) = 0;
2074- // parameter-reference type______ __________ goes out of scope
2075- (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3
2076- // parameter type______ __________ goes out of scope
2077- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
2078- // parameter-reference u64 subtype___ goes out of scope
2079- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference subtype___ at 1
2080- {
2081- uint64_t baseinfo = heap.data[0].elem1;
2082- struct pair pair = unpair(&heap, &baseinfo);
2083- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
2084- state.addr = pair.elem1;
2085- }
2086- break;
2087- }
2088- case 18446744073709551553LLU: // 999999999A'''''''''''''''
2089- {
2090- if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 != 1/*typename__*/)
2091- {
2092- state.addr = 18446744073709551552LLU; // 999999999_'''''''''''''''
2093- break;
2094- }
2095- {
2096- uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU), 1LLU);
2097- LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2098- }
2099-
2100- *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU)) = 0;
2101- // parameter-reference type______ __________ goes out of scope
2102- (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3
2103- // parameter type______ __________ goes out of scope
2104- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
2105- // parameter-reference u64 subtype___ goes out of scope
2106- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference subtype___ at 1
2107- {
2108- uint64_t baseinfo = heap.data[0].elem1;
2109- struct pair pair = unpair(&heap, &baseinfo);
2110- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
2111- state.addr = pair.elem1;
2112- }
2113- break;
2114- }
2115- case 18446744073709551552LLU: // 999999999_'''''''''''''''
2116- {
2117- if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 != 2/*typelist__*/)
2118- {
2119- state.addr = 18446744073709551551LLU; // 9999999989'''''''''''''''
2120- break;
2121- }
2122- {
2123- uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU), 1LLU);
2124- LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2125- }
2126- {
2127- uint64_t arg = tree_elem_addr(heap.data, 1LLU, *LOCAL_ACCESS(heap.data, 3LLU, 2LLU), 0LLU);
2128- LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2129- }
2130-
2131- *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU)) = /*name______*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 3LLU));
2132- // parameter-reference u64 name______ goes out of scope
2133- (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference name______ at 4
2134- // parameter-reference type______ __________ goes out of scope
2135- (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3
2136- // parameter type______ __________ goes out of scope
2137- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
2138- // parameter-reference u64 subtype___ goes out of scope
2139- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference subtype___ at 1
2140- {
2141- uint64_t baseinfo = heap.data[0].elem1;
2142- struct pair pair = unpair(&heap, &baseinfo);
2143- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
2144- state.addr = pair.elem1;
2145- }
2146- break;
2147- }
2148- case 18446744073709551551LLU: // 9999999989'''''''''''''''
2149- {
2150- fprintf(stderr, "INTERNAL COMPILER ERROR: missing pattern-match-case in definition of typesub___\n");
2151- exit(-1);
2152- break;
2153- }
2154- case 861504783110041600LLU: // typeinit__
2155- {
2156- if(*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU)) != 881834713755418624)
2157- {
2158- state.addr = 18446744073709551550LLU; // 9999999988'''''''''''''''
2159- break;
2160- }
2161- // ACCUMULATE ARGUMENTS - BEGIN
2162- {
2163- uint64_t arg = *LOCAL_ACCESS(heap.data, 3LLU, 0LLU);
2164- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
2165- }
2166- // ACCUMULATE ARGUMENTS - END
2167- uint64_t return_to = 18446744073709551549LLU;
2168- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
2169- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
2170- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
2171- heap.data[0].elem1 = heap.data[0].elem0;
2172- heap.data[0].elem0 = restore;
2173- state.addr = 861504796319285248LLU; // typeu64___
2174- break;
2175- }
2176- case 18446744073709551549LLU: // 9999999987'''''''''''''''
2177- {
2178- // parameter-reference u64 subtype___ goes out of scope
2179- (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference subtype___ at 3
2180- // parameter-reference u64 __________ goes out of scope
2181- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
2182- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
2183- {
2184- uint64_t baseinfo = heap.data[0].elem1;
2185- struct pair pair = unpair(&heap, &baseinfo);
2186- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
2187- state.addr = pair.elem1;
2188- }
2189- break;
2190- }
2191- case 18446744073709551550LLU: // 9999999988'''''''''''''''
2192- {
2193- if(*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU)) != 712900180986298368)
2194- {
2195- state.addr = 18446744073709551548LLU; // 9999999986'''''''''''''''
2196- break;
2197- }
2198- {
2199- uint64_t arg = 0;
2200- LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2201- }
2202- *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /*subtype___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU));
2203- // ACCUMULATE ARGUMENTS - BEGIN
2204- {
2205- uint64_t arg = *LOCAL_ACCESS(heap.data, 4LLU, 0LLU);
2206- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
2207- }
2208- {
2209- uint64_t arg = /*subtype___*/*LOCAL_ACCESS(heap.data, 4LLU, 3LLU);
2210- LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
2211- }
2212- // ACCUMULATE ARGUMENTS - END
2213- uint64_t return_to = 18446744073709551547LLU;
2214- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
2215- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
2216- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
2217- heap.data[0].elem1 = heap.data[0].elem0;
2218- heap.data[0].elem0 = restore;
2219- state.addr = 861504786250002432LLU; // typelist__
2220- break;
2221- }
2222- case 18446744073709551547LLU: // 9999999985'''''''''''''''
2223- {
2224- // variable u64 subtype___ goes out of scope
2225- // (uninitialized -> no destructor-call)
2226- (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference subtype___ at 4
2227- // parameter-reference u64 subtype___ goes out of scope
2228- (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference subtype___ at 3
2229- // parameter-reference u64 __________ goes out of scope
2230- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
2231- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
2232- {
2233- uint64_t baseinfo = heap.data[0].elem1;
2234- struct pair pair = unpair(&heap, &baseinfo);
2235- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
2236- state.addr = pair.elem1;
2237- }
2238- break;
2239- }
2240- case 18446744073709551548LLU: // 9999999986'''''''''''''''
2241- {
2242- {
2243- uint64_t arg = 0;
2244- LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2245- }
2246- *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /*subtype___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU));
2247- state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551545LLU : 18446744073709551544LLU;
2248- (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
2249- break;
2250- }
2251- case 18446744073709551545LLU: // 9999999983'''''''''''''''
2252- {
2253- fprintf(stderr, "%s", "typeinit: struct/union ");
2254- printid(stderr, /*maintype__*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU)));
2255- fprintf(stderr, "%s", " must not have subtype but found ");
2256- printid(stderr, /*subtype___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 2LLU)));
2257- state.addr = 18446744073709551544LLU; // 9999999982'''''''''''''''
2258- break;
2259- }
2260- case 18446744073709551544LLU: // 9999999982'''''''''''''''
2261- {
2262- {
2263- uint64_t arg = 0;
2264- LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2265- }
2266- *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /*maintype__*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 1LLU));
2267- // ACCUMULATE ARGUMENTS - BEGIN
2268- {
2269- uint64_t arg = *LOCAL_ACCESS(heap.data, 4LLU, 0LLU);
2270- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
2271- }
2272- {
2273- uint64_t arg = /*maintype__*/*LOCAL_ACCESS(heap.data, 4LLU, 3LLU);
2274- LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
2275- }
2276- // ACCUMULATE ARGUMENTS - END
2277- uint64_t return_to = 18446744073709551543LLU;
2278- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
2279- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
2280- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
2281- heap.data[0].elem1 = heap.data[0].elem0;
2282- heap.data[0].elem0 = restore;
2283- state.addr = 861504788261634048LLU; // typename__
2284- break;
2285- }
2286- case 18446744073709551543LLU: // 9999999981'''''''''''''''
2287- {
2288- // variable u64 maintype__ goes out of scope
2289- // (uninitialized -> no destructor-call)
2290- (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference maintype__ at 4
2291- // parameter-reference u64 subtype___ goes out of scope
2292- (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference subtype___ at 3
2293- // parameter-reference u64 maintype__ goes out of scope
2294- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference maintype__ at 2
2295- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
2296- {
2297- uint64_t baseinfo = heap.data[0].elem1;
2298- struct pair pair = unpair(&heap, &baseinfo);
2299- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
2300- state.addr = pair.elem1;
2301- }
2302- break;
2303- }
2304- case 367395560426147840LLU: // TYPECOPY__
2305- {
2306- if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 != 0/*typeu64___*/)
2307- {
2308- state.addr = 18446744073709551542LLU; // 9999999980'''''''''''''''
2309- break;
2310- }
2311- {
2312- uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU), 1LLU);
2313- LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2314- }
2315- // ACCUMULATE ARGUMENTS - BEGIN
2316- {
2317- uint64_t arg = *LOCAL_ACCESS(heap.data, 3LLU, 0LLU);
2318- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
2319- }
2320- // ACCUMULATE ARGUMENTS - END
2321- uint64_t return_to = 18446744073709551541LLU;
2322- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
2323- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
2324- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
2325- heap.data[0].elem1 = heap.data[0].elem0;
2326- heap.data[0].elem0 = restore;
2327- state.addr = 861504796319285248LLU; // typeu64___
2328- break;
2329- }
2330- case 18446744073709551541LLU: // 999999998z'''''''''''''''
2331- {
2332- // parameter-reference type______ __________ goes out of scope
2333- (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3
2334- // parameter type______ __________ goes out of scope
2335- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
2336- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
2337- {
2338- uint64_t baseinfo = heap.data[0].elem1;
2339- struct pair pair = unpair(&heap, &baseinfo);
2340- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
2341- state.addr = pair.elem1;
2342- }
2343- break;
2344- }
2345- case 18446744073709551542LLU: // 9999999980'''''''''''''''
2346- {
2347- if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 != 1/*typename__*/)
2348- {
2349- state.addr = 18446744073709551540LLU; // 999999998y'''''''''''''''
2350- break;
2351- }
2352- {
2353- uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU), 1LLU);
2354- LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2355- }
2356- {
2357- uint64_t arg = tree_elem_addr(heap.data, 1LLU, *LOCAL_ACCESS(heap.data, 3LLU, 2LLU), 0LLU);
2358- LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2359- }
2360- {
2361- uint64_t arg = 0;
2362- LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2363- }
2364- *LOCAL_ACCESS(heap.data, 5LLU, 4LLU) = /*name______*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 3LLU));
2365- // ACCUMULATE ARGUMENTS - BEGIN
2366- {
2367- uint64_t arg = *LOCAL_ACCESS(heap.data, 5LLU, 0LLU);
2368- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
2369- }
2370- {
2371- uint64_t arg = /*tmp_______*/*LOCAL_ACCESS(heap.data, 5LLU, 4LLU);
2372- LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
2373- }
2374- // ACCUMULATE ARGUMENTS - END
2375- uint64_t return_to = 18446744073709551539LLU;
2376- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
2377- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
2378- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
2379- heap.data[0].elem1 = heap.data[0].elem0;
2380- heap.data[0].elem0 = restore;
2381- state.addr = 861504788261634048LLU; // typename__
2382- break;
2383- }
2384- case 18446744073709551539LLU: // 999999998x'''''''''''''''
2385- {
2386- // variable u64 tmp_______ goes out of scope
2387- // (uninitialized -> no destructor-call)
2388- (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference tmp_______ at 5
2389- // parameter-reference u64 name______ goes out of scope
2390- (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference name______ at 4
2391- // parameter-reference type______ __________ goes out of scope
2392- (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3
2393- // parameter type______ __________ goes out of scope
2394- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
2395- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
2396- {
2397- uint64_t baseinfo = heap.data[0].elem1;
2398- struct pair pair = unpair(&heap, &baseinfo);
2399- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
2400- state.addr = pair.elem1;
2401- }
2402- break;
2403- }
2404- case 18446744073709551540LLU: // 999999998y'''''''''''''''
2405- {
2406- if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 != 2/*typelist__*/)
2407- {
2408- state.addr = 18446744073709551538LLU; // 999999998w'''''''''''''''
2409- break;
2410- }
2411- {
2412- uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU), 1LLU);
2413- LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2414- }
2415- {
2416- uint64_t arg = tree_elem_addr(heap.data, 1LLU, *LOCAL_ACCESS(heap.data, 3LLU, 2LLU), 0LLU);
2417- LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2418- }
2419- {
2420- uint64_t arg = 0;
2421- LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2422- }
2423- *LOCAL_ACCESS(heap.data, 5LLU, 4LLU) = /*name______*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 3LLU));
2424- // ACCUMULATE ARGUMENTS - BEGIN
2425- {
2426- uint64_t arg = *LOCAL_ACCESS(heap.data, 5LLU, 0LLU);
2427- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
2428- }
2429- {
2430- uint64_t arg = /*tmp_______*/*LOCAL_ACCESS(heap.data, 5LLU, 4LLU);
2431- LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
2432- }
2433- // ACCUMULATE ARGUMENTS - END
2434- uint64_t return_to = 18446744073709551537LLU;
2435- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
2436- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
2437- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
2438- heap.data[0].elem1 = heap.data[0].elem0;
2439- heap.data[0].elem0 = restore;
2440- state.addr = 861504786250002432LLU; // typelist__
2441- break;
2442- }
2443- case 18446744073709551537LLU: // 999999998v'''''''''''''''
2444- {
2445- // variable u64 tmp_______ goes out of scope
2446- // (uninitialized -> no destructor-call)
2447- (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference tmp_______ at 5
2448- // parameter-reference u64 name______ goes out of scope
2449- (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference name______ at 4
2450- // parameter-reference type______ __________ goes out of scope
2451- (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3
2452- // parameter type______ __________ goes out of scope
2453- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
2454- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
2455- {
2456- uint64_t baseinfo = heap.data[0].elem1;
2457- struct pair pair = unpair(&heap, &baseinfo);
2458- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
2459- state.addr = pair.elem1;
2460- }
2461- break;
2462- }
2463- case 18446744073709551538LLU: // 999999998w'''''''''''''''
2464- {
2465- fprintf(stderr, "INTERNAL COMPILER ERROR: missing pattern-match-case in definition of TYPECOPY__\n");
2466- exit(-1);
2467- break;
2468- }
2469- case 819847183518878432LLU: // reporttype
2470- {
2471- if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 0/*typeu64___*/)
2472- {
2473- state.addr = 18446744073709551536LLU; // 999999998u'''''''''''''''
2474- break;
2475- }
2476- {
2477- uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU), 1LLU);
2478- LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2479- }
2480- fprintf(stderr, "%s", "u64");
2481- // parameter-reference type______ __________ goes out of scope
2482- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
2483- // parameter type______ __________ goes out of scope
2484- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
2485- {
2486- uint64_t baseinfo = heap.data[0].elem1;
2487- struct pair pair = unpair(&heap, &baseinfo);
2488- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
2489- state.addr = pair.elem1;
2490- }
2491- break;
2492- }
2493- case 18446744073709551536LLU: // 999999998u'''''''''''''''
2494- {
2495- if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 1/*typename__*/)
2496- {
2497- state.addr = 18446744073709551535LLU; // 999999998t'''''''''''''''
2498- break;
2499- }
2500- {
2501- uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU), 1LLU);
2502- LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2503- }
2504- {
2505- uint64_t arg = tree_elem_addr(heap.data, 1LLU, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU), 0LLU);
2506- LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2507- }
2508- printid(stderr, /*maintype__*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 2LLU)));
2509- // parameter-reference u64 maintype__ goes out of scope
2510- (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference maintype__ at 3
2511- // parameter-reference type______ __________ goes out of scope
2512- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
2513- // parameter type______ __________ goes out of scope
2514- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
2515- {
2516- uint64_t baseinfo = heap.data[0].elem1;
2517- struct pair pair = unpair(&heap, &baseinfo);
2518- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
2519- state.addr = pair.elem1;
2520- }
2521- break;
2522- }
2523- case 18446744073709551535LLU: // 999999998t'''''''''''''''
2524- {
2525- if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 2/*typelist__*/)
2526- {
2527- state.addr = 18446744073709551534LLU; // 999999998s'''''''''''''''
2528- break;
2529- }
2530- {
2531- uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU), 1LLU);
2532- LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2533- }
2534- {
2535- uint64_t arg = tree_elem_addr(heap.data, 1LLU, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU), 0LLU);
2536- LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2537- }
2538- {
2539- uint64_t arg = 0;
2540- LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2541- }
2542- *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /*subtype___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU));
2543- state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551533LLU : 18446744073709551532LLU;
2544- (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
2545- break;
2546- }
2547- case 18446744073709551533LLU: // 999999998r'''''''''''''''
2548- {
2549- fprintf(stderr, "%s", "list<");
2550- printid(stderr, /*subtype___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 2LLU)));
2551- fprintf(stderr, "%s", ">");
2552- state.addr = 18446744073709551531LLU; // 999999998p'''''''''''''''
2553- break;
2554- }
2555- case 18446744073709551532LLU: // 999999998q'''''''''''''''
2556- {
2557- fprintf(stderr, "%s", "list<?>");
2558- state.addr = 18446744073709551531LLU; // 999999998p'''''''''''''''
2559- break;
2560- }
2561- case 18446744073709551531LLU: // 999999998p'''''''''''''''
2562- {
2563- // parameter-reference u64 subtype___ goes out of scope
2564- (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference subtype___ at 3
2565- // parameter-reference type______ __________ goes out of scope
2566- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
2567- // parameter type______ __________ goes out of scope
2568- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
2569- {
2570- uint64_t baseinfo = heap.data[0].elem1;
2571- struct pair pair = unpair(&heap, &baseinfo);
2572- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
2573- state.addr = pair.elem1;
2574- }
2575- break;
2576- }
2577- case 18446744073709551534LLU: // 999999998s'''''''''''''''
2578- {
2579- fprintf(stderr, "INTERNAL COMPILER ERROR: missing pattern-match-case in definition of reporttype\n");
2580- exit(-1);
2581- break;
2582- }
2583- case 787446708300855296LLU: // printtype_
2584- {
2585- if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 0/*typeu64___*/)
2586- {
2587- state.addr = 18446744073709551530LLU; // 999999998o'''''''''''''''
2588- break;
2589- }
2590- {
2591- uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU), 1LLU);
2592- LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2593- }
2594- fprintf(stdout, "%s", "u64");
2595- // parameter-reference type______ __________ goes out of scope
2596- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
2597- // parameter type______ __________ goes out of scope
2598- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
2599- {
2600- uint64_t baseinfo = heap.data[0].elem1;
2601- struct pair pair = unpair(&heap, &baseinfo);
2602- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
2603- state.addr = pair.elem1;
2604- }
2605- break;
2606- }
2607- case 18446744073709551530LLU: // 999999998o'''''''''''''''
2608- {
2609- if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 1/*typename__*/)
2610- {
2611- state.addr = 18446744073709551529LLU; // 999999998n'''''''''''''''
2612- break;
2613- }
2614- {
2615- uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU), 1LLU);
2616- LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2617- }
2618- {
2619- uint64_t arg = tree_elem_addr(heap.data, 1LLU, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU), 0LLU);
2620- LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2621- }
2622- printid(stdout, /*maintype__*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 2LLU)));
2623- // parameter-reference u64 maintype__ goes out of scope
2624- (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference maintype__ at 3
2625- // parameter-reference type______ __________ goes out of scope
2626- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
2627- // parameter type______ __________ goes out of scope
2628- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
2629- {
2630- uint64_t baseinfo = heap.data[0].elem1;
2631- struct pair pair = unpair(&heap, &baseinfo);
2632- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
2633- state.addr = pair.elem1;
2634- }
2635- break;
2636- }
2637- case 18446744073709551529LLU: // 999999998n'''''''''''''''
2638- {
2639- if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 2/*typelist__*/)
2640- {
2641- state.addr = 18446744073709551528LLU; // 999999998m'''''''''''''''
2642- break;
2643- }
2644- {
2645- uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU), 1LLU);
2646- LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2647- }
2648- {
2649- uint64_t arg = tree_elem_addr(heap.data, 1LLU, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU), 0LLU);
2650- LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2651- }
2652- {
2653- uint64_t arg = 0;
2654- LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2655- }
2656- *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /*subtype___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU));
2657- state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551527LLU : 18446744073709551526LLU;
2658- (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
2659- break;
2660- }
2661- case 18446744073709551527LLU: // 999999998l'''''''''''''''
2662- {
2663- fprintf(stdout, "%s", "list<");
2664- printid(stdout, /*subtype___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 2LLU)));
2665- fprintf(stdout, "%s", ">");
2666- state.addr = 18446744073709551525LLU; // 999999998j'''''''''''''''
2667- break;
2668- }
2669- case 18446744073709551526LLU: // 999999998k'''''''''''''''
2670- {
2671- fprintf(stdout, "%s", "list<?>");
2672- state.addr = 18446744073709551525LLU; // 999999998j'''''''''''''''
2673- break;
2674- }
2675- case 18446744073709551525LLU: // 999999998j'''''''''''''''
2676- {
2677- // parameter-reference u64 subtype___ goes out of scope
2678- (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference subtype___ at 3
2679- // parameter-reference type______ __________ goes out of scope
2680- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
2681- // parameter type______ __________ goes out of scope
2682- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
2683- {
2684- uint64_t baseinfo = heap.data[0].elem1;
2685- struct pair pair = unpair(&heap, &baseinfo);
2686- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
2687- state.addr = pair.elem1;
2688- }
2689- break;
2690- }
2691- case 18446744073709551528LLU: // 999999998m'''''''''''''''
2692- {
2693- fprintf(stderr, "INTERNAL COMPILER ERROR: missing pattern-match-case in definition of printtype_\n");
2694- exit(-1);
2695- break;
2696- }
2697- case 18446744073709551524LLU: // 999999998i'''''''''''''''
2698- {
2699- {
2700- uint64_t arg = tree_pop_move(&heap, 3LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
2701- LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2702- }
2703- // emitted destructur for type u64
2704- // RELEASE temporary destructor-variable
2705- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
2706- {
2707- uint64_t arg = tree_pop_move(&heap, 2LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
2708- LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2709- }
2710- // emitted destructur for type u64
2711- // RELEASE temporary destructor-variable
2712- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
2713- {
2714- uint64_t arg = tree_pop_move(&heap, 1LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
2715- LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2716- }
2717- // emitted destructur for type type______
2718- // ACCUMULATE ARGUMENTS - BEGIN
2719- {
2720- uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 2LLU, 1LLU);
2721- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
2722- }
2723- // ACCUMULATE ARGUMENTS - END
2724- uint64_t return_to = 18446744073709551523LLU;
2725- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
2726- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
2727- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
2728- heap.data[0].elem1 = heap.data[0].elem0;
2729- heap.data[0].elem0 = restore;
2730- state.addr = 18446744073709551569LLU; // 999999999Q'''''''''''''''
2731- break;
2732- }
2733- case 18446744073709551523LLU: // 999999998h'''''''''''''''
2734- {
2735- // RELEASE temporary destructor-variable
2736- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
2737- // RELEASE destructor-argument
2738- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 1
2739- {
2740- uint64_t baseinfo = heap.data[0].elem1;
2741- struct pair pair = unpair(&heap, &baseinfo);
2742- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
2743- state.addr = pair.elem1;
2744- }
2745- break;
2746- }
2747- case 819859607768530944LLU: // resdest___
2748- {
2749- // struct-constructor resdest___
2750- {
2751- uint64_t result_tuple = 0;
2752- // copy references
2753- {
2754- uint64_t elem = *LOCAL_ACCESS(heap.data, 3LLU + 1, 0LLU + 1);
2755- tree_push_move(&heap, 0LLU, &result_tuple, &elem);
2756- }
2757- {
2758- uint64_t elem = *LOCAL_ACCESS(heap.data, 3LLU + 1, 1LLU + 1);
2759- tree_push_move(&heap, 1LLU, &result_tuple, &elem);
2760- }
2761- {
2762- uint64_t elem = *LOCAL_ACCESS(heap.data, 3LLU + 1, 2LLU + 1);
2763- tree_push_move(&heap, 2LLU, &result_tuple, &elem);
2764- }
2765- // release parameters
2766- {
2767- (void)LOCAL_POP_MOVE(&heap, 3LLU + 1, &(heap.data[0].elem1)/*memory root*/);
2768- }
2769- {
2770- (void)LOCAL_POP_MOVE(&heap, 2LLU + 1, &(heap.data[0].elem1)/*memory root*/);
2771- }
2772- {
2773- (void)LOCAL_POP_MOVE(&heap, 1LLU + 1, &(heap.data[0].elem1)/*memory root*/);
2774- }
2775- *access_heap(heap.data, LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*memory root*/)) = result_tuple;
2776- }
2777- {
2778- uint64_t baseinfo = heap.data[0].elem1;
2779- struct pair pair = unpair(&heap, &baseinfo);
2780- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
2781- state.addr = pair.elem1;
2782- }
2783- break;
2784- }
2785- case 589059885019168768LLU: // equres____
2786- {
2787-
2788- // ACCUMULATE ARGUMENTS - BEGIN
2789- {
2790- uint64_t arg = *LOCAL_ACCESS(heap.data, 3LLU, 0LLU);
2791- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
2792- }
2793- {
2794- uint64_t arg = /*x_________*/tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 0LLU);
2795- LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
2796- }
2797- {
2798- uint64_t arg = /*y_________*/tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 3LLU, 2LLU), 0LLU);
2799- LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
2800- }
2801- // ACCUMULATE ARGUMENTS - END
2802- uint64_t return_to = 18446744073709551522LLU;
2803- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0));
2804- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
2805- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
2806- heap.data[0].elem1 = heap.data[0].elem0;
2807- heap.data[0].elem0 = restore;
2808- state.addr = 589060043891015680LLU; // equtype___
2809- break;
2810- }
2811- case 18446744073709551522LLU: // 999999998g'''''''''''''''
2812- {
2813- {
2814- uint64_t arg = 0;
2815- LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2816- }
2817- *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /*equal_____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU));
2818- state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551521LLU : 18446744073709551520LLU;
2819- (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
2820- break;
2821- }
2822- case 18446744073709551521LLU: // 999999998f'''''''''''''''
2823- {
2824-
2825- *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));
2826- {
2827- uint64_t arg = 0;
2828- LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2829- }
2830- *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /*equal_____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU));
2831- state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551519LLU : 18446744073709551518LLU;
2832- (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
2833- break;
2834- }
2835- case 18446744073709551519LLU: // 999999998d'''''''''''''''
2836- {
2837-
2838- *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));
2839- state.addr = 18446744073709551518LLU; // 999999998c'''''''''''''''
2840- break;
2841- }
2842- case 18446744073709551518LLU: // 999999998c'''''''''''''''
2843- {
2844- state.addr = 18446744073709551520LLU; // 999999998e'''''''''''''''
2845- break;
2846- }
2847- case 18446744073709551520LLU: // 999999998e'''''''''''''''
2848- {
2849- // parameter-reference resdest___ y_________ goes out of scope
2850- (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference y_________ at 3
2851- // parameter-reference resdest___ x_________ goes out of scope
2852- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference x_________ at 2
2853- // parameter-reference u64 equal_____ goes out of scope
2854- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference equal_____ at 1
2855- {
2856- uint64_t baseinfo = heap.data[0].elem1;
2857- struct pair pair = unpair(&heap, &baseinfo);
2858- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
2859- state.addr = pair.elem1;
2860- }
2861- break;
2862- }
2863- case 333468934555566080LLU: // ResCopy___
2864- {
2865- {
2866- uint64_t arg = tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU), 0LLU);
2867- LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2868- }
2869- {
2870- uint64_t arg = tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 1LLU);
2871- LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2872- }
2873- {
2874- uint64_t arg = tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 4LLU, 1LLU), 2LLU);
2875- LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2876- }
2877- // ACCUMULATE ARGUMENTS - BEGIN
2878- {
2879- uint64_t arg = *LOCAL_ACCESS(heap.data, 5LLU, 0LLU);
2880- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
2881- }
2882- {
2883- uint64_t arg = heap.data[0].elem0;
2884- LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2885- }
2886- {
2887- uint64_t arg = 0;
2888- LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2889- }
2890- // ACCUMULATE ARGUMENTS - BEGIN
2891- {
2892- uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 7LLU, 6LLU);
2893- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
2894- }
2895- {
2896- uint64_t arg = /*type______*/*LOCAL_ACCESS(heap.data, 7LLU, 2LLU);
2897- LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
2898- }
2899- // ACCUMULATE ARGUMENTS - END
2900- uint64_t return_to = 18446744073709551515LLU;
2901- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
2902- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
2903- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
2904- heap.data[0].elem1 = heap.data[0].elem0;
2905- heap.data[0].elem0 = restore;
2906- state.addr = 367395560426147840LLU; // TYPECOPY__
2907- break;
2908- }
2909- case 18446744073709551515LLU: // 999999998$'''''''''''''''
2910- {
2911- {
2912- uint64_t exchange = LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 7*/;
2913- heap.data[0].elem0 = LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 6*/;
2914-
2915- {
2916- uint64_t arg = exchange;
2917- LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
2918- }
2919- }
2920- {
2921- uint64_t arg = heap.data[0].elem0;
2922- LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2923- }
2924- {
2925- uint64_t arg = 0;
2926- LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2927- }
2928- // ACCUMULATE ARGUMENTS - BEGIN
2929- {
2930- uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 7LLU, 6LLU);
2931- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
2932- }
2933- {
2934- uint64_t arg = /*idx_______*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 7LLU, 3LLU));
2935- LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
2936- }
2937- // ACCUMULATE ARGUMENTS - END
2938- uint64_t return_to = 18446744073709551514LLU;
2939- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
2940- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
2941- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
2942- heap.data[0].elem1 = heap.data[0].elem0;
2943- heap.data[0].elem0 = restore;
2944- state.addr = 552446646280519680LLU; // copyu64___
2945- break;
2946- }
2947- case 18446744073709551514LLU: // 999999998Z'''''''''''''''
2948- {
2949- {
2950- uint64_t exchange = LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 7*/;
2951- heap.data[0].elem0 = LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 6*/;
2952-
2953- {
2954- uint64_t arg = exchange;
2955- LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
2956- }
2957- }
2958- {
2959- uint64_t arg = heap.data[0].elem0;
2960- LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2961- }
2962- {
2963- uint64_t arg = 0;
2964- LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg);
2965- }
2966- // ACCUMULATE ARGUMENTS - BEGIN
2967- {
2968- uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 7LLU, 6LLU);
2969- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
2970- }
2971- {
2972- uint64_t arg = /*reference_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 7LLU, 4LLU));
2973- LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
2974- }
2975- // ACCUMULATE ARGUMENTS - END
2976- uint64_t return_to = 18446744073709551513LLU;
2977- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
2978- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
2979- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
2980- heap.data[0].elem1 = heap.data[0].elem0;
2981- heap.data[0].elem0 = restore;
2982- state.addr = 552446646280519680LLU; // copyu64___
2983- break;
2984- }
2985- case 18446744073709551513LLU: // 999999998Y'''''''''''''''
2986- {
2987- {
2988- uint64_t exchange = LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 7*/;
2989- heap.data[0].elem0 = LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 6*/;
2990-
2991- {
2992- uint64_t arg = exchange;
2993- LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
2994- }
2995- }
2996- // ACCUMULATE ARGUMENTS - END
2997- uint64_t return_to = 18446744073709551516LLU;
2998- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0));
2999- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
3000- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
3001- heap.data[0].elem1 = heap.data[0].elem0;
3002- heap.data[0].elem0 = restore;
3003- state.addr = 819859607768530944LLU; // resdest___
3004- break;
3005- }
3006- case 18446744073709551516LLU: // 999999998a'''''''''''''''
3007- {
3008- // parameter-reference u64 reference_ goes out of scope
3009- (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference reference_ at 5
3010- // parameter-reference u64 idx_______ goes out of scope
3011- (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference idx_______ at 4
3012- // parameter-reference type______ type______ goes out of scope
3013- (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type______ at 3
3014- // parameter-reference resdest___ __________ goes out of scope
3015- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
3016- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
3017- {
3018- uint64_t baseinfo = heap.data[0].elem1;
3019- struct pair pair = unpair(&heap, &baseinfo);
3020- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
3021- state.addr = pair.elem1;
3022- }
3023- break;
3024- }
3025- case 325737967258195136LLU: // REPORTRES_
3026- {
3027- {
3028- uint64_t arg = tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU), 0LLU);
3029- LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3030- }
3031- {
3032- uint64_t arg = tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 2LLU, 0LLU), 1LLU);
3033- LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3034- }
3035- {
3036- uint64_t arg = tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU), 2LLU);
3037- LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3038- }
3039- // ACCUMULATE ARGUMENTS - BEGIN
3040- {
3041- uint64_t arg = /*type______*/*LOCAL_ACCESS(heap.data, 4LLU, 1LLU);
3042- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
3043- }
3044- // ACCUMULATE ARGUMENTS - END
3045- uint64_t return_to = 18446744073709551511LLU;
3046- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
3047- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
3048- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
3049- heap.data[0].elem1 = heap.data[0].elem0;
3050- heap.data[0].elem0 = restore;
3051- state.addr = 819847183518878432LLU; // reporttype
3052- break;
3053- }
3054- case 18446744073709551511LLU: // 999999998W'''''''''''''''
3055- {
3056- fprintf(stderr, "%s", " ");
3057- fprintf(stderr, "%s", "(");
3058- fprintf(stderr, "%llu", (unsigned long long)/*index_____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU)));
3059- fprintf(stderr, "%s", ")");
3060- // parameter-reference u64 reference_ goes out of scope
3061- (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference reference_ at 4
3062- // parameter-reference u64 index_____ goes out of scope
3063- (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference index_____ at 3
3064- // parameter-reference type______ type______ goes out of scope
3065- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type______ at 2
3066- // parameter-reference resdest___ __________ goes out of scope
3067- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
3068- {
3069- uint64_t baseinfo = heap.data[0].elem1;
3070- struct pair pair = unpair(&heap, &baseinfo);
3071- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
3072- state.addr = pair.elem1;
3073- }
3074- break;
3075- }
3076- case 325737967258195155LLU: // REPORTRESS
3077- {
3078- fprintf(stderr, "%s", "(");
3079- {
3080- uint64_t arg = 0;
3081- LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3082- }
3083- *LOCAL_ACCESS(heap.data, 2LLU, 1LLU) = 1;
3084- {
3085- uint64_t arg = /*rs________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 0LLU));
3086- LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3087- }
3088- {
3089- uint64_t arg = 0;
3090- LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3091- }
3092- state.addr = 18446744073709551510LLU; // 999999998V'''''''''''''''
3093- break;
3094- }
3095- case 18446744073709551510LLU: // 999999998V'''''''''''''''
3096- {
3097- if(!*LOCAL_ACCESS(heap.data, 4LLU, 2LLU))
3098- {
3099- (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
3100- (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 3
3101- {
3102- state.addr = 18446744073709551509LLU; // 999999998U'''''''''''''''
3103- break;
3104- }
3105- }
3106- /*direct*/*LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = (*LOCAL_ACCESS(heap.data, 4LLU, 2LLU) << 1) + 1LLU;
3107- *LOCAL_ACCESS(heap.data, 4LLU, 2LLU) = heap.data[*LOCAL_ACCESS(heap.data, 4LLU, 2LLU)].elem0;
3108- {
3109- uint64_t arg = 0;
3110- LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3111- }
3112- *LOCAL_ACCESS(heap.data, 5LLU, 4LLU) = /*first_____*/*LOCAL_ACCESS(heap.data, 5LLU, 1LLU);
3113- state.addr = *LOCAL_ACCESS(heap.data, 5LLU, 4LLU) ? 18446744073709551508LLU : 18446744073709551507LLU;
3114- (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 5
3115- break;
3116- }
3117- case 18446744073709551508LLU: // 999999998T'''''''''''''''
3118- {
3119-
3120- *LOCAL_ACCESS(heap.data, 4LLU, 1LLU) = 0;
3121- state.addr = 18446744073709551506LLU; // 999999998R'''''''''''''''
3122- break;
3123- }
3124- case 18446744073709551507LLU: // 999999998S'''''''''''''''
3125- {
3126- fprintf(stderr, "%s", ", ");
3127- state.addr = 18446744073709551506LLU; // 999999998R'''''''''''''''
3128- break;
3129- }
3130- case 18446744073709551506LLU: // 999999998R'''''''''''''''
3131- {
3132- // ACCUMULATE ARGUMENTS - BEGIN
3133- {
3134- uint64_t arg = /*r_________*/*LOCAL_ACCESS(heap.data, 4LLU, 3LLU);
3135- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
3136- }
3137- // ACCUMULATE ARGUMENTS - END
3138- uint64_t return_to = 18446744073709551505LLU;
3139- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
3140- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
3141- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
3142- heap.data[0].elem1 = heap.data[0].elem0;
3143- heap.data[0].elem0 = restore;
3144- state.addr = 325737967258195136LLU; // REPORTRES_
3145- break;
3146- }
3147- case 18446744073709551505LLU: // 999999998Q'''''''''''''''
3148- {
3149- // parameter-reference resdest___ r_________ goes out of scope
3150- // parameter-reference list<resdest___> rs________ goes out of scope
3151- state.addr = 18446744073709551510LLU; // 999999998V'''''''''''''''
3152- break;
3153- }
3154- case 18446744073709551509LLU: // 999999998U'''''''''''''''
3155- {
3156- fprintf(stderr, "%s", ")");
3157- // variable u64 first_____ goes out of scope
3158- // emitted destructur for type u64
3159- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference first_____ at 2
3160- // parameter-reference list<resdest___> rs________ goes out of scope
3161- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference rs________ at 1
3162- {
3163- uint64_t baseinfo = heap.data[0].elem1;
3164- struct pair pair = unpair(&heap, &baseinfo);
3165- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
3166- state.addr = pair.elem1;
3167- }
3168- break;
3169- }
3170- case 18446744073709551503LLU: // 999999998O'''''''''''''''
3171- {
3172- // destructor for variant maintain__
3173- // RELEASE destructor-argument
3174- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 1
3175- {
3176- uint64_t baseinfo = heap.data[0].elem1;
3177- struct pair pair = unpair(&heap, &baseinfo);
3178- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
3179- state.addr = pair.elem1;
3180- }
3181- break;
3182- }
3183- case 18446744073709551502LLU: // 999999998N'''''''''''''''
3184- {
3185- // destructor for variant consume___
3186- // RELEASE destructor-argument
3187- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 1
3188- {
3189- uint64_t baseinfo = heap.data[0].elem1;
3190- struct pair pair = unpair(&heap, &baseinfo);
3191- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
3192- state.addr = pair.elem1;
3193- }
3194- break;
3195- }
3196- case 18446744073709551501LLU: // 999999998M'''''''''''''''
3197- {
3198- // destructor for variant produce___
3199- // RELEASE destructor-argument
3200- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 1
3201- {
3202- uint64_t baseinfo = heap.data[0].elem1;
3203- struct pair pair = unpair(&heap, &baseinfo);
3204- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
3205- state.addr = pair.elem1;
3206- }
3207- break;
3208- }
3209- case 18446744073709551504LLU: // 999999998P'''''''''''''''
3210- {
3211- struct pair type_data = unpair(&heap, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
3212- *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)) = type_data.elem1;
3213- state.addr = 18446744073709551501LLU + type_data.elem0;
3214- break;
3215- }
3216- case 728618437845356544LLU: // maintain__
3217- {
3218- // union-constructor maintain__
3219- {
3220- uint64_t result_tuple = 0;
3221- // copy references
3222- // release parameters
3223- {
3224- uint64_t constridx = 2LLU;
3225- uint64_t root = pair_move(&heap, &constridx, &result_tuple);
3226- *access_heap(heap.data, LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*memory root*/)) = root;
3227- }
3228- }
3229- {
3230- uint64_t baseinfo = heap.data[0].elem1;
3231- struct pair pair = unpair(&heap, &baseinfo);
3232- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
3233- state.addr = pair.elem1;
3234- }
3235- break;
3236- }
3237- case 552437437528276992LLU: // consume___
3238- {
3239- // union-constructor consume___
3240- {
3241- uint64_t result_tuple = 0;
3242- // copy references
3243- // release parameters
3244- {
3245- uint64_t constridx = 1LLU;
3246- uint64_t root = pair_move(&heap, &constridx, &result_tuple);
3247- *access_heap(heap.data, LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*memory root*/)) = root;
3248- }
3249- }
3250- {
3251- uint64_t baseinfo = heap.data[0].elem1;
3252- struct pair pair = unpair(&heap, &baseinfo);
3253- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
3254- state.addr = pair.elem1;
3255- }
3256- break;
3257- }
3258- case 787472410168262656LLU: // produce___
3259- {
3260- // union-constructor produce___
3261- {
3262- uint64_t result_tuple = 0;
3263- // copy references
3264- // release parameters
3265- {
3266- uint64_t constridx = 0LLU;
3267- uint64_t root = pair_move(&heap, &constridx, &result_tuple);
3268- *access_heap(heap.data, LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*memory root*/)) = root;
3269- }
3270- }
3271- {
3272- uint64_t baseinfo = heap.data[0].elem1;
3273- struct pair pair = unpair(&heap, &baseinfo);
3274- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
3275- state.addr = pair.elem1;
3276- }
3277- break;
3278- }
3279- case 589058781102643104LLU: // equbalance
3280- {
3281- if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU))].elem0 != 0/*produce___*/)
3282- {
3283- state.addr = 18446744073709551500LLU; // 999999998L'''''''''''''''
3284- break;
3285- }
3286- {
3287- uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 1LLU);
3288- LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3289- }
3290- if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU))].elem0 != 0/*produce___*/)
3291- {
3292- (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
3293- state.addr = 18446744073709551500LLU; // 999999998L'''''''''''''''
3294- break;
3295- }
3296- {
3297- uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU), 1LLU);
3298- LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3299- }
3300- *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 0LLU)) = 1LLU;
3301- // parameter-reference continuity __________ goes out of scope
3302- (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 5
3303- // parameter continuity __________ goes out of scope
3304- (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 4
3305- // parameter-reference continuity __________ goes out of scope
3306- (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3
3307- // parameter continuity __________ goes out of scope
3308- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
3309- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
3310- {
3311- uint64_t baseinfo = heap.data[0].elem1;
3312- struct pair pair = unpair(&heap, &baseinfo);
3313- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
3314- state.addr = pair.elem1;
3315- }
3316- break;
3317- }
3318- case 18446744073709551500LLU: // 999999998L'''''''''''''''
3319- {
3320- if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU))].elem0 != 1/*consume___*/)
3321- {
3322- state.addr = 18446744073709551499LLU; // 999999998K'''''''''''''''
3323- break;
3324- }
3325- {
3326- uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 1LLU);
3327- LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3328- }
3329- if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU))].elem0 != 0/*produce___*/)
3330- {
3331- (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
3332- state.addr = 18446744073709551499LLU; // 999999998K'''''''''''''''
3333- break;
3334- }
3335- {
3336- uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU), 1LLU);
3337- LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3338- }
3339- *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 0LLU)) = 0LLU;
3340- // parameter-reference continuity __________ goes out of scope
3341- (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 5
3342- // parameter continuity __________ goes out of scope
3343- (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 4
3344- // parameter-reference continuity __________ goes out of scope
3345- (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3
3346- // parameter continuity __________ goes out of scope
3347- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
3348- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
3349- {
3350- uint64_t baseinfo = heap.data[0].elem1;
3351- struct pair pair = unpair(&heap, &baseinfo);
3352- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
3353- state.addr = pair.elem1;
3354- }
3355- break;
3356- }
3357- case 18446744073709551499LLU: // 999999998K'''''''''''''''
3358- {
3359- if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU))].elem0 != 2/*maintain__*/)
3360- {
3361- state.addr = 18446744073709551498LLU; // 999999998J'''''''''''''''
3362- break;
3363- }
3364- {
3365- uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 1LLU);
3366- LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3367- }
3368- if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU))].elem0 != 0/*produce___*/)
3369- {
3370- (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
3371- state.addr = 18446744073709551498LLU; // 999999998J'''''''''''''''
3372- break;
3373- }
3374- {
3375- uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU), 1LLU);
3376- LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3377- }
3378- *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 0LLU)) = 0LLU;
3379- // parameter-reference continuity __________ goes out of scope
3380- (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 5
3381- // parameter continuity __________ goes out of scope
3382- (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 4
3383- // parameter-reference continuity __________ goes out of scope
3384- (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3
3385- // parameter continuity __________ goes out of scope
3386- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
3387- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
3388- {
3389- uint64_t baseinfo = heap.data[0].elem1;
3390- struct pair pair = unpair(&heap, &baseinfo);
3391- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
3392- state.addr = pair.elem1;
3393- }
3394- break;
3395- }
3396- case 18446744073709551498LLU: // 999999998J'''''''''''''''
3397- {
3398- if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU))].elem0 != 0/*produce___*/)
3399- {
3400- state.addr = 18446744073709551497LLU; // 999999998I'''''''''''''''
3401- break;
3402- }
3403- {
3404- uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 1LLU);
3405- LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3406- }
3407- if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU))].elem0 != 1/*consume___*/)
3408- {
3409- (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
3410- state.addr = 18446744073709551497LLU; // 999999998I'''''''''''''''
3411- break;
3412- }
3413- {
3414- uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU), 1LLU);
3415- LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3416- }
3417- *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 0LLU)) = 0LLU;
3418- // parameter-reference continuity __________ goes out of scope
3419- (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 5
3420- // parameter continuity __________ goes out of scope
3421- (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 4
3422- // parameter-reference continuity __________ goes out of scope
3423- (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3
3424- // parameter continuity __________ goes out of scope
3425- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
3426- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
3427- {
3428- uint64_t baseinfo = heap.data[0].elem1;
3429- struct pair pair = unpair(&heap, &baseinfo);
3430- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
3431- state.addr = pair.elem1;
3432- }
3433- break;
3434- }
3435- case 18446744073709551497LLU: // 999999998I'''''''''''''''
3436- {
3437- if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU))].elem0 != 1/*consume___*/)
3438- {
3439- state.addr = 18446744073709551496LLU; // 999999998H'''''''''''''''
3440- break;
3441- }
3442- {
3443- uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 1LLU);
3444- LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3445- }
3446- if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU))].elem0 != 1/*consume___*/)
3447- {
3448- (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
3449- state.addr = 18446744073709551496LLU; // 999999998H'''''''''''''''
3450- break;
3451- }
3452- {
3453- uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU), 1LLU);
3454- LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3455- }
3456- *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 0LLU)) = 1LLU;
3457- // parameter-reference continuity __________ goes out of scope
3458- (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 5
3459- // parameter continuity __________ goes out of scope
3460- (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 4
3461- // parameter-reference continuity __________ goes out of scope
3462- (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3
3463- // parameter continuity __________ goes out of scope
3464- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
3465- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
3466- {
3467- uint64_t baseinfo = heap.data[0].elem1;
3468- struct pair pair = unpair(&heap, &baseinfo);
3469- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
3470- state.addr = pair.elem1;
3471- }
3472- break;
3473- }
3474- case 18446744073709551496LLU: // 999999998H'''''''''''''''
3475- {
3476- if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU))].elem0 != 2/*maintain__*/)
3477- {
3478- state.addr = 18446744073709551495LLU; // 999999998G'''''''''''''''
3479- break;
3480- }
3481- {
3482- uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 1LLU);
3483- LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3484- }
3485- if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU))].elem0 != 1/*consume___*/)
3486- {
3487- (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
3488- state.addr = 18446744073709551495LLU; // 999999998G'''''''''''''''
3489- break;
3490- }
3491- {
3492- uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU), 1LLU);
3493- LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3494- }
3495- *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 0LLU)) = 0LLU;
3496- // parameter-reference continuity __________ goes out of scope
3497- (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 5
3498- // parameter continuity __________ goes out of scope
3499- (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 4
3500- // parameter-reference continuity __________ goes out of scope
3501- (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3
3502- // parameter continuity __________ goes out of scope
3503- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
3504- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
3505- {
3506- uint64_t baseinfo = heap.data[0].elem1;
3507- struct pair pair = unpair(&heap, &baseinfo);
3508- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
3509- state.addr = pair.elem1;
3510- }
3511- break;
3512- }
3513- case 18446744073709551495LLU: // 999999998G'''''''''''''''
3514- {
3515- if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU))].elem0 != 0/*produce___*/)
3516- {
3517- state.addr = 18446744073709551494LLU; // 999999998F'''''''''''''''
3518- break;
3519- }
3520- {
3521- uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 1LLU);
3522- LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3523- }
3524- if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU))].elem0 != 2/*maintain__*/)
3525- {
3526- (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
3527- state.addr = 18446744073709551494LLU; // 999999998F'''''''''''''''
3528- break;
3529- }
3530- {
3531- uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU), 1LLU);
3532- LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3533- }
3534- *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 0LLU)) = 0LLU;
3535- // parameter-reference continuity __________ goes out of scope
3536- (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 5
3537- // parameter continuity __________ goes out of scope
3538- (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 4
3539- // parameter-reference continuity __________ goes out of scope
3540- (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3
3541- // parameter continuity __________ goes out of scope
3542- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
3543- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
3544- {
3545- uint64_t baseinfo = heap.data[0].elem1;
3546- struct pair pair = unpair(&heap, &baseinfo);
3547- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
3548- state.addr = pair.elem1;
3549- }
3550- break;
3551- }
3552- case 18446744073709551494LLU: // 999999998F'''''''''''''''
3553- {
3554- if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU))].elem0 != 1/*consume___*/)
3555- {
3556- state.addr = 18446744073709551493LLU; // 999999998E'''''''''''''''
3557- break;
3558- }
3559- {
3560- uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 1LLU);
3561- LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3562- }
3563- if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU))].elem0 != 2/*maintain__*/)
3564- {
3565- (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
3566- state.addr = 18446744073709551493LLU; // 999999998E'''''''''''''''
3567- break;
3568- }
3569- {
3570- uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU), 1LLU);
3571- LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3572- }
3573- *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 0LLU)) = 0LLU;
3574- // parameter-reference continuity __________ goes out of scope
3575- (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 5
3576- // parameter continuity __________ goes out of scope
3577- (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 4
3578- // parameter-reference continuity __________ goes out of scope
3579- (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3
3580- // parameter continuity __________ goes out of scope
3581- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
3582- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
3583- {
3584- uint64_t baseinfo = heap.data[0].elem1;
3585- struct pair pair = unpair(&heap, &baseinfo);
3586- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
3587- state.addr = pair.elem1;
3588- }
3589- break;
3590- }
3591- case 18446744073709551493LLU: // 999999998E'''''''''''''''
3592- {
3593- if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU))].elem0 != 2/*maintain__*/)
3594- {
3595- state.addr = 18446744073709551492LLU; // 999999998D'''''''''''''''
3596- break;
3597- }
3598- {
3599- uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 1LLU);
3600- LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3601- }
3602- if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU))].elem0 != 2/*maintain__*/)
3603- {
3604- (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
3605- state.addr = 18446744073709551492LLU; // 999999998D'''''''''''''''
3606- break;
3607- }
3608- {
3609- uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU), 1LLU);
3610- LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3611- }
3612- *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 0LLU)) = 1LLU;
3613- // parameter-reference continuity __________ goes out of scope
3614- (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 5
3615- // parameter continuity __________ goes out of scope
3616- (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 4
3617- // parameter-reference continuity __________ goes out of scope
3618- (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3
3619- // parameter continuity __________ goes out of scope
3620- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
3621- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
3622- {
3623- uint64_t baseinfo = heap.data[0].elem1;
3624- struct pair pair = unpair(&heap, &baseinfo);
3625- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
3626- state.addr = pair.elem1;
3627- }
3628- break;
3629- }
3630- case 18446744073709551492LLU: // 999999998D'''''''''''''''
3631- {
3632- fprintf(stderr, "INTERNAL COMPILER ERROR: missing pattern-match-case in definition of equbalance\n");
3633- exit(-1);
3634- break;
3635- }
3636- case 552664889133754368LLU: // cpbalance_
3637- {
3638- if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 != 0/*produce___*/)
3639- {
3640- state.addr = 18446744073709551491LLU; // 999999998C'''''''''''''''
3641- break;
3642- }
3643- {
3644- uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU), 1LLU);
3645- LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3646- }
3647-
3648- // emitted destructur for type continuity
3649- // ACCUMULATE ARGUMENTS - BEGIN
3650- {
3651- uint64_t arg = *LOCAL_ACCESS(heap.data, 3LLU, 0LLU);
3652- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
3653- }
3654- // ACCUMULATE ARGUMENTS - END
3655- uint64_t return_to = 18446744073709551490LLU;
3656- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
3657- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
3658- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
3659- heap.data[0].elem1 = heap.data[0].elem0;
3660- heap.data[0].elem0 = restore;
3661- state.addr = 18446744073709551504LLU; // 999999998P'''''''''''''''
3662- break;
3663- }
3664- case 18446744073709551490LLU: // 999999998B'''''''''''''''
3665- {
3666- // ACCUMULATE ARGUMENTS - BEGIN
3667- {
3668- uint64_t arg = *LOCAL_ACCESS(heap.data, 3LLU, 0LLU);
3669- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
3670- }
3671- // ACCUMULATE ARGUMENTS - END
3672- uint64_t return_to = 18446744073709551489LLU;
3673- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
3674- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
3675- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
3676- heap.data[0].elem1 = heap.data[0].elem0;
3677- heap.data[0].elem0 = restore;
3678- state.addr = 787472410168262656LLU; // produce___
3679- break;
3680- }
3681- case 18446744073709551489LLU: // 999999998A'''''''''''''''
3682- {
3683- // parameter-reference continuity __________ goes out of scope
3684- (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3
3685- // parameter continuity __________ goes out of scope
3686- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
3687- // parameter-reference continuity dst_______ goes out of scope
3688- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference dst_______ at 1
3689- {
3690- uint64_t baseinfo = heap.data[0].elem1;
3691- struct pair pair = unpair(&heap, &baseinfo);
3692- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
3693- state.addr = pair.elem1;
3694- }
3695- break;
3696- }
3697- case 18446744073709551491LLU: // 999999998C'''''''''''''''
3698- {
3699- if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 != 1/*consume___*/)
3700- {
3701- state.addr = 18446744073709551488LLU; // 999999998_'''''''''''''''
3702- break;
3703- }
3704- {
3705- uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU), 1LLU);
3706- LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3707- }
3708-
3709- // emitted destructur for type continuity
3710- // ACCUMULATE ARGUMENTS - BEGIN
3711- {
3712- uint64_t arg = *LOCAL_ACCESS(heap.data, 3LLU, 0LLU);
3713- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
3714- }
3715- // ACCUMULATE ARGUMENTS - END
3716- uint64_t return_to = 18446744073709551487LLU;
3717- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
3718- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
3719- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
3720- heap.data[0].elem1 = heap.data[0].elem0;
3721- heap.data[0].elem0 = restore;
3722- state.addr = 18446744073709551504LLU; // 999999998P'''''''''''''''
3723- break;
3724- }
3725- case 18446744073709551487LLU: // 9999999979'''''''''''''''
3726- {
3727- // ACCUMULATE ARGUMENTS - BEGIN
3728- {
3729- uint64_t arg = *LOCAL_ACCESS(heap.data, 3LLU, 0LLU);
3730- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
3731- }
3732- // ACCUMULATE ARGUMENTS - END
3733- uint64_t return_to = 18446744073709551486LLU;
3734- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
3735- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
3736- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
3737- heap.data[0].elem1 = heap.data[0].elem0;
3738- heap.data[0].elem0 = restore;
3739- state.addr = 552437437528276992LLU; // consume___
3740- break;
3741- }
3742- case 18446744073709551486LLU: // 9999999978'''''''''''''''
3743- {
3744- // parameter-reference continuity __________ goes out of scope
3745- (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3
3746- // parameter continuity __________ goes out of scope
3747- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
3748- // parameter-reference continuity dst_______ goes out of scope
3749- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference dst_______ at 1
3750- {
3751- uint64_t baseinfo = heap.data[0].elem1;
3752- struct pair pair = unpair(&heap, &baseinfo);
3753- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
3754- state.addr = pair.elem1;
3755- }
3756- break;
3757- }
3758- case 18446744073709551488LLU: // 999999998_'''''''''''''''
3759- {
3760- if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 != 2/*maintain__*/)
3761- {
3762- state.addr = 18446744073709551485LLU; // 9999999977'''''''''''''''
3763- break;
3764- }
3765- {
3766- uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU), 1LLU);
3767- LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3768- }
3769-
3770- // emitted destructur for type continuity
3771- // ACCUMULATE ARGUMENTS - BEGIN
3772- {
3773- uint64_t arg = *LOCAL_ACCESS(heap.data, 3LLU, 0LLU);
3774- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
3775- }
3776- // ACCUMULATE ARGUMENTS - END
3777- uint64_t return_to = 18446744073709551484LLU;
3778- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
3779- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
3780- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
3781- heap.data[0].elem1 = heap.data[0].elem0;
3782- heap.data[0].elem0 = restore;
3783- state.addr = 18446744073709551504LLU; // 999999998P'''''''''''''''
3784- break;
3785- }
3786- case 18446744073709551484LLU: // 9999999976'''''''''''''''
3787- {
3788- // ACCUMULATE ARGUMENTS - BEGIN
3789- {
3790- uint64_t arg = *LOCAL_ACCESS(heap.data, 3LLU, 0LLU);
3791- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
3792- }
3793- // ACCUMULATE ARGUMENTS - END
3794- uint64_t return_to = 18446744073709551483LLU;
3795- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
3796- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
3797- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
3798- heap.data[0].elem1 = heap.data[0].elem0;
3799- heap.data[0].elem0 = restore;
3800- state.addr = 728618437845356544LLU; // maintain__
3801- break;
3802- }
3803- case 18446744073709551483LLU: // 9999999975'''''''''''''''
3804- {
3805- // parameter-reference continuity __________ goes out of scope
3806- (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3
3807- // parameter continuity __________ goes out of scope
3808- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
3809- // parameter-reference continuity dst_______ goes out of scope
3810- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference dst_______ at 1
3811- {
3812- uint64_t baseinfo = heap.data[0].elem1;
3813- struct pair pair = unpair(&heap, &baseinfo);
3814- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
3815- state.addr = pair.elem1;
3816- }
3817- break;
3818- }
3819- case 18446744073709551485LLU: // 9999999977'''''''''''''''
3820- {
3821- fprintf(stderr, "INTERNAL COMPILER ERROR: missing pattern-match-case in definition of cpbalance_\n");
3822- exit(-1);
3823- break;
3824- }
3825- case 58555672873677120LLU: // CPBALANCE_
3826- {
3827- if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 != 0/*produce___*/)
3828- {
3829- state.addr = 18446744073709551482LLU; // 9999999974'''''''''''''''
3830- break;
3831- }
3832- {
3833- uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU), 1LLU);
3834- LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3835- }
3836- // ACCUMULATE ARGUMENTS - BEGIN
3837- {
3838- uint64_t arg = *LOCAL_ACCESS(heap.data, 3LLU, 0LLU);
3839- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
3840- }
3841- // ACCUMULATE ARGUMENTS - END
3842- uint64_t return_to = 18446744073709551481LLU;
3843- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
3844- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
3845- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
3846- heap.data[0].elem1 = heap.data[0].elem0;
3847- heap.data[0].elem0 = restore;
3848- state.addr = 787472410168262656LLU; // produce___
3849- break;
3850- }
3851- case 18446744073709551481LLU: // 9999999973'''''''''''''''
3852- {
3853- // parameter-reference continuity __________ goes out of scope
3854- (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3
3855- // parameter continuity __________ goes out of scope
3856- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
3857- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
3858- {
3859- uint64_t baseinfo = heap.data[0].elem1;
3860- struct pair pair = unpair(&heap, &baseinfo);
3861- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
3862- state.addr = pair.elem1;
3863- }
3864- break;
3865- }
3866- case 18446744073709551482LLU: // 9999999974'''''''''''''''
3867- {
3868- if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 != 1/*consume___*/)
3869- {
3870- state.addr = 18446744073709551480LLU; // 9999999972'''''''''''''''
3871- break;
3872- }
3873- {
3874- uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU), 1LLU);
3875- LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3876- }
3877- // ACCUMULATE ARGUMENTS - BEGIN
3878- {
3879- uint64_t arg = *LOCAL_ACCESS(heap.data, 3LLU, 0LLU);
3880- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
3881- }
3882- // ACCUMULATE ARGUMENTS - END
3883- uint64_t return_to = 18446744073709551479LLU;
3884- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
3885- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
3886- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
3887- heap.data[0].elem1 = heap.data[0].elem0;
3888- heap.data[0].elem0 = restore;
3889- state.addr = 552437437528276992LLU; // consume___
3890- break;
3891- }
3892- case 18446744073709551479LLU: // 9999999971'''''''''''''''
3893- {
3894- // parameter-reference continuity __________ goes out of scope
3895- (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3
3896- // parameter continuity __________ goes out of scope
3897- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
3898- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
3899- {
3900- uint64_t baseinfo = heap.data[0].elem1;
3901- struct pair pair = unpair(&heap, &baseinfo);
3902- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
3903- state.addr = pair.elem1;
3904- }
3905- break;
3906- }
3907- case 18446744073709551480LLU: // 9999999972'''''''''''''''
3908- {
3909- if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 != 2/*maintain__*/)
3910- {
3911- state.addr = 18446744073709551478LLU; // 9999999970'''''''''''''''
3912- break;
3913- }
3914- {
3915- uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU), 1LLU);
3916- LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
3917- }
3918- // ACCUMULATE ARGUMENTS - BEGIN
3919- {
3920- uint64_t arg = *LOCAL_ACCESS(heap.data, 3LLU, 0LLU);
3921- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
3922- }
3923- // ACCUMULATE ARGUMENTS - END
3924- uint64_t return_to = 18446744073709551477LLU;
3925- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
3926- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
3927- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
3928- heap.data[0].elem1 = heap.data[0].elem0;
3929- heap.data[0].elem0 = restore;
3930- state.addr = 728618437845356544LLU; // maintain__
3931- break;
3932- }
3933- case 18446744073709551477LLU: // 999999997z'''''''''''''''
3934- {
3935- // parameter-reference continuity __________ goes out of scope
3936- (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 3
3937- // parameter continuity __________ goes out of scope
3938- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
3939- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
3940- {
3941- uint64_t baseinfo = heap.data[0].elem1;
3942- struct pair pair = unpair(&heap, &baseinfo);
3943- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
3944- state.addr = pair.elem1;
3945- }
3946- break;
3947- }
3948- case 18446744073709551478LLU: // 9999999970'''''''''''''''
3949- {
3950- fprintf(stderr, "INTERNAL COMPILER ERROR: missing pattern-match-case in definition of CPBALANCE_\n");
3951- exit(-1);
3952- break;
3953- }
3954- case 18446744073709551475LLU: // 999999997x'''''''''''''''
3955- {
3956- // destructor for variant blkloop___
3957- // RELEASE destructor-argument
3958- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 1
3959- {
3960- uint64_t baseinfo = heap.data[0].elem1;
3961- struct pair pair = unpair(&heap, &baseinfo);
3962- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
3963- state.addr = pair.elem1;
3964- }
3965- break;
3966- }
3967- case 18446744073709551474LLU: // 999999997w'''''''''''''''
3968- {
3969- // destructor for variant blkelse___
3970- // RELEASE destructor-argument
3971- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 1
3972- {
3973- uint64_t baseinfo = heap.data[0].elem1;
3974- struct pair pair = unpair(&heap, &baseinfo);
3975- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
3976- state.addr = pair.elem1;
3977- }
3978- break;
3979- }
3980- case 18446744073709551473LLU: // 999999997v'''''''''''''''
3981- {
3982- // destructor for variant blkif_____
3983- // RELEASE destructor-argument
3984- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 1
3985- {
3986- uint64_t baseinfo = heap.data[0].elem1;
3987- struct pair pair = unpair(&heap, &baseinfo);
3988- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
3989- state.addr = pair.elem1;
3990- }
3991- break;
3992- }
3993- case 18446744073709551472LLU: // 999999997u'''''''''''''''
3994- {
3995- // destructor for variant blkwhen___
3996- // RELEASE destructor-argument
3997- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 1
3998- {
3999- uint64_t baseinfo = heap.data[0].elem1;
4000- struct pair pair = unpair(&heap, &baseinfo);
4001- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
4002- state.addr = pair.elem1;
4003- }
4004- break;
4005- }
4006- case 18446744073709551471LLU: // 999999997t'''''''''''''''
4007- {
4008- // destructor for variant blknone___
4009- // RELEASE destructor-argument
4010- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 1
4011- {
4012- uint64_t baseinfo = heap.data[0].elem1;
4013- struct pair pair = unpair(&heap, &baseinfo);
4014- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
4015- state.addr = pair.elem1;
4016- }
4017- break;
4018- }
4019- case 18446744073709551476LLU: // 999999997y'''''''''''''''
4020- {
4021- struct pair type_data = unpair(&heap, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
4022- *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)) = type_data.elem1;
4023- state.addr = 18446744073709551471LLU + type_data.elem0;
4024- break;
4025- }
4026- case 533564932506779648LLU: // blkloop___
4027- {
4028- // union-constructor blkloop___
4029- {
4030- uint64_t result_tuple = 0;
4031- // copy references
4032- // release parameters
4033- {
4034- uint64_t constridx = 4LLU;
4035- uint64_t root = pair_move(&heap, &constridx, &result_tuple);
4036- *access_heap(heap.data, LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*memory root*/)) = root;
4037- }
4038- }
4039- {
4040- uint64_t baseinfo = heap.data[0].elem1;
4041- struct pair pair = unpair(&heap, &baseinfo);
4042- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
4043- state.addr = pair.elem1;
4044- }
4045- break;
4046- }
4047- case 533564448313442304LLU: // blkelse___
4048- {
4049- // union-constructor blkelse___
4050- {
4051- uint64_t result_tuple = 0;
4052- // copy references
4053- // release parameters
4054- {
4055- uint64_t constridx = 3LLU;
4056- uint64_t root = pair_move(&heap, &constridx, &result_tuple);
4057- *access_heap(heap.data, LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*memory root*/)) = root;
4058- }
4059- }
4060- {
4061- uint64_t baseinfo = heap.data[0].elem1;
4062- struct pair pair = unpair(&heap, &baseinfo);
4063- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
4064- state.addr = pair.elem1;
4065- }
4066- break;
4067- }
4068- case 533564715968757760LLU: // blkif_____
4069- {
4070- // union-constructor blkif_____
4071- {
4072- uint64_t result_tuple = 0;
4073- // copy references
4074- // release parameters
4075- {
4076- uint64_t constridx = 2LLU;
4077- uint64_t root = pair_move(&heap, &constridx, &result_tuple);
4078- *access_heap(heap.data, LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*memory root*/)) = root;
4079- }
4080- }
4081- {
4082- uint64_t baseinfo = heap.data[0].elem1;
4083- struct pair pair = unpair(&heap, &baseinfo);
4084- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
4085- state.addr = pair.elem1;
4086- }
4087- break;
4088- }
4089- case 533565680736534528LLU: // blkwhen___
4090- {
4091- // union-constructor blkwhen___
4092- {
4093- uint64_t result_tuple = 0;
4094- // copy references
4095- // release parameters
4096- {
4097- uint64_t constridx = 1LLU;
4098- uint64_t root = pair_move(&heap, &constridx, &result_tuple);
4099- *access_heap(heap.data, LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*memory root*/)) = root;
4100- }
4101- }
4102- {
4103- uint64_t baseinfo = heap.data[0].elem1;
4104- struct pair pair = unpair(&heap, &baseinfo);
4105- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
4106- state.addr = pair.elem1;
4107- }
4108- break;
4109- }
4110- case 533565069926072320LLU: // blknone___
4111- {
4112- // union-constructor blknone___
4113- {
4114- uint64_t result_tuple = 0;
4115- // copy references
4116- // release parameters
4117- {
4118- uint64_t constridx = 0LLU;
4119- uint64_t root = pair_move(&heap, &constridx, &result_tuple);
4120- *access_heap(heap.data, LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*memory root*/)) = root;
4121- }
4122- }
4123- {
4124- uint64_t baseinfo = heap.data[0].elem1;
4125- struct pair pair = unpair(&heap, &baseinfo);
4126- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
4127- state.addr = pair.elem1;
4128- }
4129- break;
4130- }
4131- case 819847183514106240LLU: // reportblk_
4132- {
4133- if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 0/*blknone___*/)
4134- {
4135- state.addr = 18446744073709551470LLU; // 999999997s'''''''''''''''
4136- break;
4137- }
4138- {
4139- uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU), 1LLU);
4140- LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4141- }
4142- fprintf(stderr, "%s", "blknone");
4143- // parameter-reference blockvar__ __________ goes out of scope
4144- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
4145- // parameter blockvar__ __________ goes out of scope
4146- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
4147- {
4148- uint64_t baseinfo = heap.data[0].elem1;
4149- struct pair pair = unpair(&heap, &baseinfo);
4150- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
4151- state.addr = pair.elem1;
4152- }
4153- break;
4154- }
4155- case 18446744073709551470LLU: // 999999997s'''''''''''''''
4156- {
4157- if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 1/*blkwhen___*/)
4158- {
4159- state.addr = 18446744073709551469LLU; // 999999997r'''''''''''''''
4160- break;
4161- }
4162- {
4163- uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU), 1LLU);
4164- LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4165- }
4166- fprintf(stderr, "%s", "blkwhen");
4167- // parameter-reference blockvar__ __________ goes out of scope
4168- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
4169- // parameter blockvar__ __________ goes out of scope
4170- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
4171- {
4172- uint64_t baseinfo = heap.data[0].elem1;
4173- struct pair pair = unpair(&heap, &baseinfo);
4174- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
4175- state.addr = pair.elem1;
4176- }
4177- break;
4178- }
4179- case 18446744073709551469LLU: // 999999997r'''''''''''''''
4180- {
4181- if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 2/*blkif_____*/)
4182- {
4183- state.addr = 18446744073709551468LLU; // 999999997q'''''''''''''''
4184- break;
4185- }
4186- {
4187- uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU), 1LLU);
4188- LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4189- }
4190- fprintf(stderr, "%s", "blkif");
4191- // parameter-reference blockvar__ __________ goes out of scope
4192- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
4193- // parameter blockvar__ __________ goes out of scope
4194- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
4195- {
4196- uint64_t baseinfo = heap.data[0].elem1;
4197- struct pair pair = unpair(&heap, &baseinfo);
4198- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
4199- state.addr = pair.elem1;
4200- }
4201- break;
4202- }
4203- case 18446744073709551468LLU: // 999999997q'''''''''''''''
4204- {
4205- if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 3/*blkelse___*/)
4206- {
4207- state.addr = 18446744073709551467LLU; // 999999997p'''''''''''''''
4208- break;
4209- }
4210- {
4211- uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU), 1LLU);
4212- LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4213- }
4214- fprintf(stderr, "%s", "blkelse");
4215- // parameter-reference blockvar__ __________ goes out of scope
4216- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
4217- // parameter blockvar__ __________ goes out of scope
4218- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
4219- {
4220- uint64_t baseinfo = heap.data[0].elem1;
4221- struct pair pair = unpair(&heap, &baseinfo);
4222- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
4223- state.addr = pair.elem1;
4224- }
4225- break;
4226- }
4227- case 18446744073709551467LLU: // 999999997p'''''''''''''''
4228- {
4229- if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 4/*blkloop___*/)
4230- {
4231- state.addr = 18446744073709551466LLU; // 999999997o'''''''''''''''
4232- break;
4233- }
4234- {
4235- uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU), 1LLU);
4236- LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4237- }
4238- fprintf(stderr, "%s", "blkloop");
4239- // parameter-reference blockvar__ __________ goes out of scope
4240- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
4241- // parameter blockvar__ __________ goes out of scope
4242- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
4243- {
4244- uint64_t baseinfo = heap.data[0].elem1;
4245- struct pair pair = unpair(&heap, &baseinfo);
4246- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
4247- state.addr = pair.elem1;
4248- }
4249- break;
4250- }
4251- case 18446744073709551466LLU: // 999999997o'''''''''''''''
4252- {
4253- fprintf(stderr, "INTERNAL COMPILER ERROR: missing pattern-match-case in definition of reportblk_\n");
4254- exit(-1);
4255- break;
4256- }
4257- case 18446744073709551464LLU: // 999999997m'''''''''''''''
4258- {
4259- // destructor for variant varhide___
4260- // RELEASE destructor-argument
4261- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 1
4262- {
4263- uint64_t baseinfo = heap.data[0].elem1;
4264- struct pair pair = unpair(&heap, &baseinfo);
4265- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
4266- state.addr = pair.elem1;
4267- }
4268- break;
4269- }
4270- case 18446744073709551463LLU: // 999999997l'''''''''''''''
4271- {
4272- // destructor for variant elblock___
4273- {
4274- uint64_t arg = tree_pop_move(&heap, 1LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
4275- LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4276- }
4277- // emitted destructur for type u64
4278- // RELEASE temporary destructor-variable
4279- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
4280- // RELEASE destructor-argument
4281- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 1
4282- {
4283- uint64_t baseinfo = heap.data[0].elem1;
4284- struct pair pair = unpair(&heap, &baseinfo);
4285- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
4286- state.addr = pair.elem1;
4287- }
4288- break;
4289- }
4290- case 18446744073709551462LLU: // 999999997k'''''''''''''''
4291- {
4292- // destructor for variant varblock__
4293- // RELEASE destructor-argument
4294- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 1
4295- {
4296- uint64_t baseinfo = heap.data[0].elem1;
4297- struct pair pair = unpair(&heap, &baseinfo);
4298- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
4299- state.addr = pair.elem1;
4300- }
4301- break;
4302- }
4303- case 18446744073709551461LLU: // 999999997j'''''''''''''''
4304- {
4305- // destructor for variant varvirt___
4306- {
4307- uint64_t arg = tree_pop_move(&heap, 5LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
4308- LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4309- }
4310- // emitted destructur for type u64
4311- // RELEASE temporary destructor-variable
4312- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
4313- {
4314- uint64_t arg = tree_pop_move(&heap, 4LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
4315- LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4316- }
4317- // emitted destructur for type u64
4318- // RELEASE temporary destructor-variable
4319- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
4320- {
4321- uint64_t arg = tree_pop_move(&heap, 3LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
4322- LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4323- }
4324- // emitted destructur for type type______
4325- // ACCUMULATE ARGUMENTS - BEGIN
4326- {
4327- uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 2LLU, 1LLU);
4328- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4329- }
4330- // ACCUMULATE ARGUMENTS - END
4331- uint64_t return_to = 18446744073709551458LLU;
4332- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4333- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4334- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
4335- heap.data[0].elem1 = heap.data[0].elem0;
4336- heap.data[0].elem0 = restore;
4337- state.addr = 18446744073709551569LLU; // 999999999Q'''''''''''''''
4338- break;
4339- }
4340- case 18446744073709551458LLU: // 999999997g'''''''''''''''
4341- {
4342- // RELEASE temporary destructor-variable
4343- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
4344- {
4345- uint64_t arg = tree_pop_move(&heap, 2LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
4346- LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4347- }
4348- // emitted destructur for type u64
4349- // RELEASE temporary destructor-variable
4350- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
4351- {
4352- uint64_t arg = tree_pop_move(&heap, 1LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
4353- LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4354- }
4355- // emitted destructur for type u64
4356- // RELEASE temporary destructor-variable
4357- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
4358- // RELEASE destructor-argument
4359- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 1
4360- {
4361- uint64_t baseinfo = heap.data[0].elem1;
4362- struct pair pair = unpair(&heap, &baseinfo);
4363- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
4364- state.addr = pair.elem1;
4365- }
4366- break;
4367- }
4368- case 18446744073709551460LLU: // 999999997i'''''''''''''''
4369- {
4370- // destructor for variant varref____
4371- {
4372- uint64_t arg = tree_pop_move(&heap, 6LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
4373- LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4374- }
4375- // emitted destructur for type u64
4376- // RELEASE temporary destructor-variable
4377- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
4378- {
4379- uint64_t arg = tree_pop_move(&heap, 5LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
4380- LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4381- }
4382- // emitted destructur for type u64
4383- // RELEASE temporary destructor-variable
4384- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
4385- {
4386- uint64_t arg = tree_pop_move(&heap, 4LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
4387- LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4388- }
4389- // emitted destructur for type u64
4390- // RELEASE temporary destructor-variable
4391- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
4392- {
4393- uint64_t arg = tree_pop_move(&heap, 3LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
4394- LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4395- }
4396- // emitted destructur for type type______
4397- // ACCUMULATE ARGUMENTS - BEGIN
4398- {
4399- uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 2LLU, 1LLU);
4400- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4401- }
4402- // ACCUMULATE ARGUMENTS - END
4403- uint64_t return_to = 18446744073709551457LLU;
4404- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4405- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4406- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
4407- heap.data[0].elem1 = heap.data[0].elem0;
4408- heap.data[0].elem0 = restore;
4409- state.addr = 18446744073709551569LLU; // 999999999Q'''''''''''''''
4410- break;
4411- }
4412- case 18446744073709551457LLU: // 999999997f'''''''''''''''
4413- {
4414- // RELEASE temporary destructor-variable
4415- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
4416- {
4417- uint64_t arg = tree_pop_move(&heap, 2LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
4418- LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4419- }
4420- // emitted destructur for type u64
4421- // RELEASE temporary destructor-variable
4422- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
4423- {
4424- uint64_t arg = tree_pop_move(&heap, 1LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
4425- LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4426- }
4427- // emitted destructur for type u64
4428- // RELEASE temporary destructor-variable
4429- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
4430- // RELEASE destructor-argument
4431- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 1
4432- {
4433- uint64_t baseinfo = heap.data[0].elem1;
4434- struct pair pair = unpair(&heap, &baseinfo);
4435- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
4436- state.addr = pair.elem1;
4437- }
4438- break;
4439- }
4440- case 18446744073709551459LLU: // 999999997h'''''''''''''''
4441- {
4442- // destructor for variant varvar____
4443- {
4444- uint64_t arg = tree_pop_move(&heap, 5LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
4445- LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4446- }
4447- // emitted destructur for type u64
4448- // RELEASE temporary destructor-variable
4449- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
4450- {
4451- uint64_t arg = tree_pop_move(&heap, 4LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
4452- LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4453- }
4454- // emitted destructur for type u64
4455- // RELEASE temporary destructor-variable
4456- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
4457- {
4458- uint64_t arg = tree_pop_move(&heap, 3LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
4459- LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4460- }
4461- // emitted destructur for type type______
4462- // ACCUMULATE ARGUMENTS - BEGIN
4463- {
4464- uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 2LLU, 1LLU);
4465- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4466- }
4467- // ACCUMULATE ARGUMENTS - END
4468- uint64_t return_to = 18446744073709551456LLU;
4469- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4470- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4471- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
4472- heap.data[0].elem1 = heap.data[0].elem0;
4473- heap.data[0].elem0 = restore;
4474- state.addr = 18446744073709551569LLU; // 999999999Q'''''''''''''''
4475- break;
4476- }
4477- case 18446744073709551456LLU: // 999999997e'''''''''''''''
4478- {
4479- // RELEASE temporary destructor-variable
4480- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
4481- {
4482- uint64_t arg = tree_pop_move(&heap, 2LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
4483- LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4484- }
4485- // emitted destructur for type u64
4486- // RELEASE temporary destructor-variable
4487- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
4488- {
4489- uint64_t arg = tree_pop_move(&heap, 1LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
4490- LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4491- }
4492- // emitted destructur for type u64
4493- // RELEASE temporary destructor-variable
4494- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
4495- // RELEASE destructor-argument
4496- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 1
4497- {
4498- uint64_t baseinfo = heap.data[0].elem1;
4499- struct pair pair = unpair(&heap, &baseinfo);
4500- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
4501- state.addr = pair.elem1;
4502- }
4503- break;
4504- }
4505- case 18446744073709551465LLU: // 999999997n'''''''''''''''
4506- {
4507- struct pair type_data = unpair(&heap, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
4508- *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)) = type_data.elem1;
4509- state.addr = 18446744073709551459LLU + type_data.elem0;
4510- break;
4511- }
4512- case 890787182770388992LLU: // varhide___
4513- {
4514- // union-constructor varhide___
4515- {
4516- uint64_t result_tuple = 0;
4517- // copy references
4518- // release parameters
4519- {
4520- uint64_t constridx = 5LLU;
4521- uint64_t root = pair_move(&heap, &constridx, &result_tuple);
4522- *access_heap(heap.data, LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*memory root*/)) = root;
4523- }
4524- }
4525- {
4526- uint64_t baseinfo = heap.data[0].elem1;
4527- struct pair pair = unpair(&heap, &baseinfo);
4528- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
4529- state.addr = pair.elem1;
4530- }
4531- break;
4532- }
4533- case 587568545413988352LLU: // elblock___
4534- {
4535- // union-constructor elblock___
4536- {
4537- uint64_t result_tuple = 0;
4538- // copy references
4539- {
4540- uint64_t elem = *LOCAL_ACCESS(heap.data, 1LLU + 1, 0LLU + 1);
4541- tree_push_move(&heap, 0LLU, &result_tuple, &elem);
4542- }
4543- // release parameters
4544- {
4545- (void)LOCAL_POP_MOVE(&heap, 1LLU + 1, &(heap.data[0].elem1)/*memory root*/);
4546- }
4547- {
4548- uint64_t constridx = 4LLU;
4549- uint64_t root = pair_move(&heap, &constridx, &result_tuple);
4550- *access_heap(heap.data, LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*memory root*/)) = root;
4551- }
4552- }
4553- {
4554- uint64_t baseinfo = heap.data[0].elem1;
4555- struct pair pair = unpair(&heap, &baseinfo);
4556- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
4557- state.addr = pair.elem1;
4558- }
4559- break;
4560- }
4561- case 890786773858934784LLU: // varblock__
4562- {
4563- // union-constructor varblock__
4564- {
4565- uint64_t result_tuple = 0;
4566- // copy references
4567- // release parameters
4568- {
4569- uint64_t constridx = 3LLU;
4570- uint64_t root = pair_move(&heap, &constridx, &result_tuple);
4571- *access_heap(heap.data, LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*memory root*/)) = root;
4572- }
4573- }
4574- {
4575- uint64_t baseinfo = heap.data[0].elem1;
4576- struct pair pair = unpair(&heap, &baseinfo);
4577- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
4578- state.addr = pair.elem1;
4579- }
4580- break;
4581- }
4582- case 890788145081876480LLU: // varvirt___
4583- {
4584- // union-constructor varvirt___
4585- {
4586- uint64_t result_tuple = 0;
4587- // copy references
4588- {
4589- uint64_t elem = *LOCAL_ACCESS(heap.data, 5LLU + 1, 0LLU + 1);
4590- tree_push_move(&heap, 0LLU, &result_tuple, &elem);
4591- }
4592- {
4593- uint64_t elem = *LOCAL_ACCESS(heap.data, 5LLU + 1, 1LLU + 1);
4594- tree_push_move(&heap, 1LLU, &result_tuple, &elem);
4595- }
4596- {
4597- uint64_t elem = *LOCAL_ACCESS(heap.data, 5LLU + 1, 2LLU + 1);
4598- tree_push_move(&heap, 2LLU, &result_tuple, &elem);
4599- }
4600- {
4601- uint64_t elem = *LOCAL_ACCESS(heap.data, 5LLU + 1, 3LLU + 1);
4602- tree_push_move(&heap, 3LLU, &result_tuple, &elem);
4603- }
4604- {
4605- uint64_t elem = *LOCAL_ACCESS(heap.data, 5LLU + 1, 4LLU + 1);
4606- tree_push_move(&heap, 4LLU, &result_tuple, &elem);
4607- }
4608- // release parameters
4609- {
4610- (void)LOCAL_POP_MOVE(&heap, 5LLU + 1, &(heap.data[0].elem1)/*memory root*/);
4611- }
4612- {
4613- (void)LOCAL_POP_MOVE(&heap, 4LLU + 1, &(heap.data[0].elem1)/*memory root*/);
4614- }
4615- {
4616- (void)LOCAL_POP_MOVE(&heap, 3LLU + 1, &(heap.data[0].elem1)/*memory root*/);
4617- }
4618- {
4619- (void)LOCAL_POP_MOVE(&heap, 2LLU + 1, &(heap.data[0].elem1)/*memory root*/);
4620- }
4621- {
4622- (void)LOCAL_POP_MOVE(&heap, 1LLU + 1, &(heap.data[0].elem1)/*memory root*/);
4623- }
4624- {
4625- uint64_t constridx = 2LLU;
4626- uint64_t root = pair_move(&heap, &constridx, &result_tuple);
4627- *access_heap(heap.data, LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*memory root*/)) = root;
4628- }
4629- }
4630- {
4631- uint64_t baseinfo = heap.data[0].elem1;
4632- struct pair pair = unpair(&heap, &baseinfo);
4633- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
4634- state.addr = pair.elem1;
4635- }
4636- break;
4637- }
4638- case 890787865695354880LLU: // varref____
4639- {
4640- // union-constructor varref____
4641- {
4642- uint64_t result_tuple = 0;
4643- // copy references
4644- {
4645- uint64_t elem = *LOCAL_ACCESS(heap.data, 6LLU + 1, 0LLU + 1);
4646- tree_push_move(&heap, 0LLU, &result_tuple, &elem);
4647- }
4648- {
4649- uint64_t elem = *LOCAL_ACCESS(heap.data, 6LLU + 1, 1LLU + 1);
4650- tree_push_move(&heap, 1LLU, &result_tuple, &elem);
4651- }
4652- {
4653- uint64_t elem = *LOCAL_ACCESS(heap.data, 6LLU + 1, 2LLU + 1);
4654- tree_push_move(&heap, 2LLU, &result_tuple, &elem);
4655- }
4656- {
4657- uint64_t elem = *LOCAL_ACCESS(heap.data, 6LLU + 1, 3LLU + 1);
4658- tree_push_move(&heap, 3LLU, &result_tuple, &elem);
4659- }
4660- {
4661- uint64_t elem = *LOCAL_ACCESS(heap.data, 6LLU + 1, 4LLU + 1);
4662- tree_push_move(&heap, 4LLU, &result_tuple, &elem);
4663- }
4664- {
4665- uint64_t elem = *LOCAL_ACCESS(heap.data, 6LLU + 1, 5LLU + 1);
4666- tree_push_move(&heap, 5LLU, &result_tuple, &elem);
4667- }
4668- // release parameters
4669- {
4670- (void)LOCAL_POP_MOVE(&heap, 6LLU + 1, &(heap.data[0].elem1)/*memory root*/);
4671- }
4672- {
4673- (void)LOCAL_POP_MOVE(&heap, 5LLU + 1, &(heap.data[0].elem1)/*memory root*/);
4674- }
4675- {
4676- (void)LOCAL_POP_MOVE(&heap, 4LLU + 1, &(heap.data[0].elem1)/*memory root*/);
4677- }
4678- {
4679- (void)LOCAL_POP_MOVE(&heap, 3LLU + 1, &(heap.data[0].elem1)/*memory root*/);
4680- }
4681- {
4682- (void)LOCAL_POP_MOVE(&heap, 2LLU + 1, &(heap.data[0].elem1)/*memory root*/);
4683- }
4684- {
4685- (void)LOCAL_POP_MOVE(&heap, 1LLU + 1, &(heap.data[0].elem1)/*memory root*/);
4686- }
4687- {
4688- uint64_t constridx = 1LLU;
4689- uint64_t root = pair_move(&heap, &constridx, &result_tuple);
4690- *access_heap(heap.data, LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*memory root*/)) = root;
4691- }
4692- }
4693- {
4694- uint64_t baseinfo = heap.data[0].elem1;
4695- struct pair pair = unpair(&heap, &baseinfo);
4696- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
4697- state.addr = pair.elem1;
4698- }
4699- break;
4700- }
4701- case 890788136479621120LLU: // varvar____
4702- {
4703- // union-constructor varvar____
4704- {
4705- uint64_t result_tuple = 0;
4706- // copy references
4707- {
4708- uint64_t elem = *LOCAL_ACCESS(heap.data, 5LLU + 1, 0LLU + 1);
4709- tree_push_move(&heap, 0LLU, &result_tuple, &elem);
4710- }
4711- {
4712- uint64_t elem = *LOCAL_ACCESS(heap.data, 5LLU + 1, 1LLU + 1);
4713- tree_push_move(&heap, 1LLU, &result_tuple, &elem);
4714- }
4715- {
4716- uint64_t elem = *LOCAL_ACCESS(heap.data, 5LLU + 1, 2LLU + 1);
4717- tree_push_move(&heap, 2LLU, &result_tuple, &elem);
4718- }
4719- {
4720- uint64_t elem = *LOCAL_ACCESS(heap.data, 5LLU + 1, 3LLU + 1);
4721- tree_push_move(&heap, 3LLU, &result_tuple, &elem);
4722- }
4723- {
4724- uint64_t elem = *LOCAL_ACCESS(heap.data, 5LLU + 1, 4LLU + 1);
4725- tree_push_move(&heap, 4LLU, &result_tuple, &elem);
4726- }
4727- // release parameters
4728- {
4729- (void)LOCAL_POP_MOVE(&heap, 5LLU + 1, &(heap.data[0].elem1)/*memory root*/);
4730- }
4731- {
4732- (void)LOCAL_POP_MOVE(&heap, 4LLU + 1, &(heap.data[0].elem1)/*memory root*/);
4733- }
4734- {
4735- (void)LOCAL_POP_MOVE(&heap, 3LLU + 1, &(heap.data[0].elem1)/*memory root*/);
4736- }
4737- {
4738- (void)LOCAL_POP_MOVE(&heap, 2LLU + 1, &(heap.data[0].elem1)/*memory root*/);
4739- }
4740- {
4741- (void)LOCAL_POP_MOVE(&heap, 1LLU + 1, &(heap.data[0].elem1)/*memory root*/);
4742- }
4743- {
4744- uint64_t constridx = 0LLU;
4745- uint64_t root = pair_move(&heap, &constridx, &result_tuple);
4746- *access_heap(heap.data, LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*memory root*/)) = root;
4747- }
4748- }
4749- {
4750- uint64_t baseinfo = heap.data[0].elem1;
4751- struct pair pair = unpair(&heap, &baseinfo);
4752- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
4753- state.addr = pair.elem1;
4754- }
4755- break;
4756- }
4757- case 819847183519304512LLU: // reportvar_
4758- {
4759- if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 0/*varvar____*/)
4760- {
4761- state.addr = 18446744073709551455LLU; // 999999997d'''''''''''''''
4762- break;
4763- }
4764- {
4765- uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU), 1LLU);
4766- LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4767- }
4768- fprintf(stderr, "%s", "varvar");
4769- // parameter-reference varkind___ __________ goes out of scope
4770- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
4771- // parameter varkind___ __________ goes out of scope
4772- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
4773- {
4774- uint64_t baseinfo = heap.data[0].elem1;
4775- struct pair pair = unpair(&heap, &baseinfo);
4776- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
4777- state.addr = pair.elem1;
4778- }
4779- break;
4780- }
4781- case 18446744073709551455LLU: // 999999997d'''''''''''''''
4782- {
4783- if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 1/*varref____*/)
4784- {
4785- state.addr = 18446744073709551454LLU; // 999999997c'''''''''''''''
4786- break;
4787- }
4788- {
4789- uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU), 1LLU);
4790- LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4791- }
4792- fprintf(stderr, "%s", "varref");
4793- // parameter-reference varkind___ __________ goes out of scope
4794- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
4795- // parameter varkind___ __________ goes out of scope
4796- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
4797- {
4798- uint64_t baseinfo = heap.data[0].elem1;
4799- struct pair pair = unpair(&heap, &baseinfo);
4800- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
4801- state.addr = pair.elem1;
4802- }
4803- break;
4804- }
4805- case 18446744073709551454LLU: // 999999997c'''''''''''''''
4806- {
4807- if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 2/*varvirt___*/)
4808- {
4809- state.addr = 18446744073709551453LLU; // 999999997b'''''''''''''''
4810- break;
4811- }
4812- {
4813- uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU), 1LLU);
4814- LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4815- }
4816- fprintf(stderr, "%s", "varvirt");
4817- // parameter-reference varkind___ __________ goes out of scope
4818- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
4819- // parameter varkind___ __________ goes out of scope
4820- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
4821- {
4822- uint64_t baseinfo = heap.data[0].elem1;
4823- struct pair pair = unpair(&heap, &baseinfo);
4824- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
4825- state.addr = pair.elem1;
4826- }
4827- break;
4828- }
4829- case 18446744073709551453LLU: // 999999997b'''''''''''''''
4830- {
4831- if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 3/*varblock__*/)
4832- {
4833- state.addr = 18446744073709551452LLU; // 999999997a'''''''''''''''
4834- break;
4835- }
4836- {
4837- uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU), 1LLU);
4838- LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4839- }
4840- fprintf(stderr, "%s", "varblock");
4841- // parameter-reference varkind___ __________ goes out of scope
4842- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
4843- // parameter varkind___ __________ goes out of scope
4844- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
4845- {
4846- uint64_t baseinfo = heap.data[0].elem1;
4847- struct pair pair = unpair(&heap, &baseinfo);
4848- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
4849- state.addr = pair.elem1;
4850- }
4851- break;
4852- }
4853- case 18446744073709551452LLU: // 999999997a'''''''''''''''
4854- {
4855- if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 4/*elblock___*/)
4856- {
4857- state.addr = 18446744073709551451LLU; // 999999997$'''''''''''''''
4858- break;
4859- }
4860- {
4861- uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU), 1LLU);
4862- LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4863- }
4864- fprintf(stderr, "%s", "elblock");
4865- // parameter-reference varkind___ __________ goes out of scope
4866- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
4867- // parameter varkind___ __________ goes out of scope
4868- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
4869- {
4870- uint64_t baseinfo = heap.data[0].elem1;
4871- struct pair pair = unpair(&heap, &baseinfo);
4872- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
4873- state.addr = pair.elem1;
4874- }
4875- break;
4876- }
4877- case 18446744073709551451LLU: // 999999997$'''''''''''''''
4878- {
4879- if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 5/*varhide___*/)
4880- {
4881- state.addr = 18446744073709551450LLU; // 999999997Z'''''''''''''''
4882- break;
4883- }
4884- {
4885- uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU), 1LLU);
4886- LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4887- }
4888- fprintf(stderr, "%s", "varhide");
4889- // parameter-reference varkind___ __________ goes out of scope
4890- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
4891- // parameter varkind___ __________ goes out of scope
4892- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
4893- {
4894- uint64_t baseinfo = heap.data[0].elem1;
4895- struct pair pair = unpair(&heap, &baseinfo);
4896- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
4897- state.addr = pair.elem1;
4898- }
4899- break;
4900- }
4901- case 18446744073709551450LLU: // 999999997Z'''''''''''''''
4902- {
4903- fprintf(stderr, "INTERNAL COMPILER ERROR: missing pattern-match-case in definition of reportvar_\n");
4904- exit(-1);
4905- break;
4906- }
4907- case 18446744073709551449LLU: // 999999997Y'''''''''''''''
4908- {
4909- {
4910- uint64_t arg = tree_pop_move(&heap, 4LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
4911- LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4912- }
4913- // emitted destructur for type u64
4914- // RELEASE temporary destructor-variable
4915- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
4916- {
4917- uint64_t arg = tree_pop_move(&heap, 3LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
4918- LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4919- }
4920- // emitted destructur for type continuity
4921- // ACCUMULATE ARGUMENTS - BEGIN
4922- {
4923- uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 2LLU, 1LLU);
4924- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4925- }
4926- // ACCUMULATE ARGUMENTS - END
4927- uint64_t return_to = 18446744073709551448LLU;
4928- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4929- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4930- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
4931- heap.data[0].elem1 = heap.data[0].elem0;
4932- heap.data[0].elem0 = restore;
4933- state.addr = 18446744073709551504LLU; // 999999998P'''''''''''''''
4934- break;
4935- }
4936- case 18446744073709551448LLU: // 999999997X'''''''''''''''
4937- {
4938- // RELEASE temporary destructor-variable
4939- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
4940- {
4941- uint64_t arg = tree_pop_move(&heap, 2LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
4942- LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4943- }
4944- // emitted destructur for type u64
4945- // RELEASE temporary destructor-variable
4946- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
4947- {
4948- uint64_t arg = tree_pop_move(&heap, 1LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
4949- LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
4950- }
4951- // emitted destructur for type type______
4952- // ACCUMULATE ARGUMENTS - BEGIN
4953- {
4954- uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 2LLU, 1LLU);
4955- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
4956- }
4957- // ACCUMULATE ARGUMENTS - END
4958- uint64_t return_to = 18446744073709551447LLU;
4959- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
4960- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
4961- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
4962- heap.data[0].elem1 = heap.data[0].elem0;
4963- heap.data[0].elem0 = restore;
4964- state.addr = 18446744073709551569LLU; // 999999999Q'''''''''''''''
4965- break;
4966- }
4967- case 18446744073709551447LLU: // 999999997W'''''''''''''''
4968- {
4969- // RELEASE temporary destructor-variable
4970- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
4971- // RELEASE destructor-argument
4972- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 1
4973- {
4974- uint64_t baseinfo = heap.data[0].elem1;
4975- struct pair pair = unpair(&heap, &baseinfo);
4976- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
4977- state.addr = pair.elem1;
4978- }
4979- break;
4980- }
4981- case 782700512565788672LLU: // pardef____
4982- {
4983- // struct-constructor pardef____
4984- {
4985- uint64_t result_tuple = 0;
4986- // copy references
4987- {
4988- uint64_t elem = *LOCAL_ACCESS(heap.data, 4LLU + 1, 0LLU + 1);
4989- tree_push_move(&heap, 0LLU, &result_tuple, &elem);
4990- }
4991- {
4992- uint64_t elem = *LOCAL_ACCESS(heap.data, 4LLU + 1, 1LLU + 1);
4993- tree_push_move(&heap, 1LLU, &result_tuple, &elem);
4994- }
4995- {
4996- uint64_t elem = *LOCAL_ACCESS(heap.data, 4LLU + 1, 2LLU + 1);
4997- tree_push_move(&heap, 2LLU, &result_tuple, &elem);
4998- }
4999- {
5000- uint64_t elem = *LOCAL_ACCESS(heap.data, 4LLU + 1, 3LLU + 1);
5001- tree_push_move(&heap, 3LLU, &result_tuple, &elem);
5002- }
5003- // release parameters
5004- {
5005- (void)LOCAL_POP_MOVE(&heap, 4LLU + 1, &(heap.data[0].elem1)/*memory root*/);
5006- }
5007- {
5008- (void)LOCAL_POP_MOVE(&heap, 3LLU + 1, &(heap.data[0].elem1)/*memory root*/);
5009- }
5010- {
5011- (void)LOCAL_POP_MOVE(&heap, 2LLU + 1, &(heap.data[0].elem1)/*memory root*/);
5012- }
5013- {
5014- (void)LOCAL_POP_MOVE(&heap, 1LLU + 1, &(heap.data[0].elem1)/*memory root*/);
5015- }
5016- *access_heap(heap.data, LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*memory root*/)) = result_tuple;
5017- }
5018- {
5019- uint64_t baseinfo = heap.data[0].elem1;
5020- struct pair pair = unpair(&heap, &baseinfo);
5021- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
5022- state.addr = pair.elem1;
5023- }
5024- break;
5025- }
5026- case 18446744073709551446LLU: // 999999997V'''''''''''''''
5027- {
5028- {
5029- uint64_t arg = tree_pop_move(&heap, 2LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
5030- LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5031- }
5032- // emitted destructur for type type______
5033- // ACCUMULATE ARGUMENTS - BEGIN
5034- {
5035- uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 2LLU, 1LLU);
5036- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5037- }
5038- // ACCUMULATE ARGUMENTS - END
5039- uint64_t return_to = 18446744073709551445LLU;
5040- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5041- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5042- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
5043- heap.data[0].elem1 = heap.data[0].elem0;
5044- heap.data[0].elem0 = restore;
5045- state.addr = 18446744073709551569LLU; // 999999999Q'''''''''''''''
5046- break;
5047- }
5048- case 18446744073709551445LLU: // 999999997U'''''''''''''''
5049- {
5050- // RELEASE temporary destructor-variable
5051- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
5052- {
5053- uint64_t arg = tree_pop_move(&heap, 1LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
5054- LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5055- }
5056- // emitted destructur for type u64
5057- // RELEASE temporary destructor-variable
5058- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
5059- // RELEASE destructor-argument
5060- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 1
5061- {
5062- uint64_t baseinfo = heap.data[0].elem1;
5063- struct pair pair = unpair(&heap, &baseinfo);
5064- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
5065- state.addr = pair.elem1;
5066- }
5067- break;
5068- }
5069- case 587581796494082048LLU: // elemdef___
5070- {
5071- // struct-constructor elemdef___
5072- {
5073- uint64_t result_tuple = 0;
5074- // copy references
5075- {
5076- uint64_t elem = *LOCAL_ACCESS(heap.data, 2LLU + 1, 0LLU + 1);
5077- tree_push_move(&heap, 0LLU, &result_tuple, &elem);
5078- }
5079- {
5080- uint64_t elem = *LOCAL_ACCESS(heap.data, 2LLU + 1, 1LLU + 1);
5081- tree_push_move(&heap, 1LLU, &result_tuple, &elem);
5082- }
5083- // release parameters
5084- {
5085- (void)LOCAL_POP_MOVE(&heap, 2LLU + 1, &(heap.data[0].elem1)/*memory root*/);
5086- }
5087- {
5088- (void)LOCAL_POP_MOVE(&heap, 1LLU + 1, &(heap.data[0].elem1)/*memory root*/);
5089- }
5090- *access_heap(heap.data, LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*memory root*/)) = result_tuple;
5091- }
5092- {
5093- uint64_t baseinfo = heap.data[0].elem1;
5094- struct pair pair = unpair(&heap, &baseinfo);
5095- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
5096- state.addr = pair.elem1;
5097- }
5098- break;
5099- }
5100- case 18446744073709551444LLU: // 999999997T'''''''''''''''
5101- {
5102- {
5103- uint64_t arg = tree_pop_move(&heap, 5LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
5104- LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5105- }
5106- // emitted destructur for type u64
5107- // RELEASE temporary destructor-variable
5108- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
5109- {
5110- uint64_t arg = tree_pop_move(&heap, 4LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
5111- LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5112- }
5113- // emitted destructur for type type______
5114- // ACCUMULATE ARGUMENTS - BEGIN
5115- {
5116- uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 2LLU, 1LLU);
5117- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5118- }
5119- // ACCUMULATE ARGUMENTS - END
5120- uint64_t return_to = 18446744073709551443LLU;
5121- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5122- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5123- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
5124- heap.data[0].elem1 = heap.data[0].elem0;
5125- heap.data[0].elem0 = restore;
5126- state.addr = 18446744073709551569LLU; // 999999999Q'''''''''''''''
5127- break;
5128- }
5129- case 18446744073709551443LLU: // 999999997S'''''''''''''''
5130- {
5131- // RELEASE temporary destructor-variable
5132- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
5133- {
5134- uint64_t arg = tree_pop_move(&heap, 3LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
5135- LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5136- }
5137- // emitted destructur for type u64
5138- // RELEASE temporary destructor-variable
5139- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
5140- {
5141- uint64_t arg = tree_pop_move(&heap, 2LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
5142- LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5143- }
5144- // emitted destructur for type continuity
5145- // ACCUMULATE ARGUMENTS - BEGIN
5146- {
5147- uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 2LLU, 1LLU);
5148- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5149- }
5150- // ACCUMULATE ARGUMENTS - END
5151- uint64_t return_to = 18446744073709551442LLU;
5152- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5153- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5154- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
5155- heap.data[0].elem1 = heap.data[0].elem0;
5156- heap.data[0].elem0 = restore;
5157- state.addr = 18446744073709551504LLU; // 999999998P'''''''''''''''
5158- break;
5159- }
5160- case 18446744073709551442LLU: // 999999997R'''''''''''''''
5161- {
5162- // RELEASE temporary destructor-variable
5163- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
5164- {
5165- uint64_t arg = tree_pop_move(&heap, 1LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)));
5166- LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5167- }
5168- // emitted destructur for type u64
5169- // RELEASE temporary destructor-variable
5170- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2
5171- // RELEASE destructor-argument
5172- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 1
5173- {
5174- uint64_t baseinfo = heap.data[0].elem1;
5175- struct pair pair = unpair(&heap, &baseinfo);
5176- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
5177- state.addr = pair.elem1;
5178- }
5179- break;
5180- }
5181- case 838947815509196800LLU: // signdef___
5182- {
5183- // struct-constructor signdef___
5184- {
5185- uint64_t result_tuple = 0;
5186- // copy references
5187- {
5188- uint64_t elem = *LOCAL_ACCESS(heap.data, 5LLU + 1, 0LLU + 1);
5189- tree_push_move(&heap, 0LLU, &result_tuple, &elem);
5190- }
5191- {
5192- uint64_t elem = *LOCAL_ACCESS(heap.data, 5LLU + 1, 1LLU + 1);
5193- tree_push_move(&heap, 1LLU, &result_tuple, &elem);
5194- }
5195- {
5196- uint64_t elem = *LOCAL_ACCESS(heap.data, 5LLU + 1, 2LLU + 1);
5197- tree_push_move(&heap, 2LLU, &result_tuple, &elem);
5198- }
5199- {
5200- uint64_t elem = *LOCAL_ACCESS(heap.data, 5LLU + 1, 3LLU + 1);
5201- tree_push_move(&heap, 3LLU, &result_tuple, &elem);
5202- }
5203- {
5204- uint64_t elem = *LOCAL_ACCESS(heap.data, 5LLU + 1, 4LLU + 1);
5205- tree_push_move(&heap, 4LLU, &result_tuple, &elem);
5206- }
5207- // release parameters
5208- {
5209- (void)LOCAL_POP_MOVE(&heap, 5LLU + 1, &(heap.data[0].elem1)/*memory root*/);
5210- }
5211- {
5212- (void)LOCAL_POP_MOVE(&heap, 4LLU + 1, &(heap.data[0].elem1)/*memory root*/);
5213- }
5214- {
5215- (void)LOCAL_POP_MOVE(&heap, 3LLU + 1, &(heap.data[0].elem1)/*memory root*/);
5216- }
5217- {
5218- (void)LOCAL_POP_MOVE(&heap, 2LLU + 1, &(heap.data[0].elem1)/*memory root*/);
5219- }
5220- {
5221- (void)LOCAL_POP_MOVE(&heap, 1LLU + 1, &(heap.data[0].elem1)/*memory root*/);
5222- }
5223- *access_heap(heap.data, LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*memory root*/)) = result_tuple;
5224- }
5225- {
5226- uint64_t baseinfo = heap.data[0].elem1;
5227- struct pair pair = unpair(&heap, &baseinfo);
5228- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
5229- state.addr = pair.elem1;
5230- }
5231- break;
5232- }
5233- case 552740200527038528LLU: // cpsigndef_
5234- {
5235- {
5236- uint64_t arg = tree_elem_addr(heap.data, 5LLU, *LOCAL_ACCESS(heap.data, 2LLU, 0LLU), 0LLU);
5237- LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5238- }
5239- {
5240- uint64_t arg = tree_elem_addr(heap.data, 5LLU, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU), 1LLU);
5241- LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5242- }
5243- {
5244- uint64_t arg = tree_elem_addr(heap.data, 5LLU, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU), 2LLU);
5245- LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5246- }
5247- {
5248- uint64_t arg = tree_elem_addr(heap.data, 5LLU, *LOCAL_ACCESS(heap.data, 5LLU, 0LLU), 3LLU);
5249- LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5250- }
5251- {
5252- uint64_t arg = tree_elem_addr(heap.data, 5LLU, *LOCAL_ACCESS(heap.data, 6LLU, 0LLU), 4LLU);
5253- LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5254- }
5255- {
5256- uint64_t arg = tree_elem_addr(heap.data, 5LLU, *LOCAL_ACCESS(heap.data, 7LLU, 1LLU), 0LLU);
5257- LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5258- }
5259- {
5260- uint64_t arg = tree_elem_addr(heap.data, 5LLU, *LOCAL_ACCESS(heap.data, 8LLU, 1LLU), 1LLU);
5261- LOCAL_PUSH_MOVE(&heap, 8, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5262- }
5263- {
5264- uint64_t arg = tree_elem_addr(heap.data, 5LLU, *LOCAL_ACCESS(heap.data, 9LLU, 1LLU), 2LLU);
5265- LOCAL_PUSH_MOVE(&heap, 9, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5266- }
5267- {
5268- uint64_t arg = tree_elem_addr(heap.data, 5LLU, *LOCAL_ACCESS(heap.data, 10LLU, 1LLU), 3LLU);
5269- LOCAL_PUSH_MOVE(&heap, 10, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5270- }
5271- {
5272- uint64_t arg = tree_elem_addr(heap.data, 5LLU, *LOCAL_ACCESS(heap.data, 11LLU, 1LLU), 4LLU);
5273- LOCAL_PUSH_MOVE(&heap, 11, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5274- }
5275-
5276- *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 12LLU, 2LLU)) = /*indirect1_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 12LLU, 7LLU));
5277- // ACCUMULATE ARGUMENTS - BEGIN
5278- {
5279- uint64_t arg = /*cont0_____*/*LOCAL_ACCESS(heap.data, 12LLU, 3LLU);
5280- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5281- }
5282- {
5283- uint64_t arg = /*cont1_____*/*LOCAL_ACCESS(heap.data, 12LLU, 8LLU);
5284- LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5285- }
5286- // ACCUMULATE ARGUMENTS - END
5287- uint64_t return_to = 18446744073709551440LLU;
5288- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
5289- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5290- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
5291- heap.data[0].elem1 = heap.data[0].elem0;
5292- heap.data[0].elem0 = restore;
5293- state.addr = 552664889133754368LLU; // cpbalance_
5294- break;
5295- }
5296- case 18446744073709551440LLU: // 999999997P'''''''''''''''
5297- {
5298-
5299- *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 12LLU, 4LLU)) = /*mutable1__*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 12LLU, 9LLU));
5300-
5301- // emitted destructur for type type______
5302- // ACCUMULATE ARGUMENTS - BEGIN
5303- {
5304- uint64_t arg = *LOCAL_ACCESS(heap.data, 12LLU, 5LLU);
5305- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5306- }
5307- // ACCUMULATE ARGUMENTS - END
5308- uint64_t return_to = 18446744073709551439LLU;
5309- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5310- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5311- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
5312- heap.data[0].elem1 = heap.data[0].elem0;
5313- heap.data[0].elem0 = restore;
5314- state.addr = 18446744073709551569LLU; // 999999999Q'''''''''''''''
5315- break;
5316- }
5317- case 18446744073709551439LLU: // 999999997O'''''''''''''''
5318- {
5319- // ACCUMULATE ARGUMENTS - BEGIN
5320- {
5321- uint64_t arg = *LOCAL_ACCESS(heap.data, 12LLU, 5LLU);
5322- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5323- }
5324- {
5325- uint64_t arg = /*type1_____*/*LOCAL_ACCESS(heap.data, 12LLU, 10LLU);
5326- LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5327- }
5328- // ACCUMULATE ARGUMENTS - END
5329- uint64_t return_to = 18446744073709551438LLU;
5330- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
5331- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5332- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
5333- heap.data[0].elem1 = heap.data[0].elem0;
5334- heap.data[0].elem0 = restore;
5335- state.addr = 367395560426147840LLU; // TYPECOPY__
5336- break;
5337- }
5338- case 18446744073709551438LLU: // 999999997N'''''''''''''''
5339- {
5340-
5341- *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 12LLU, 6LLU)) = /*curidx1___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 12LLU, 11LLU));
5342- // parameter-reference u64 curidx1___ goes out of scope
5343- (void)LOCAL_POP_MOVE(&heap, 12LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference curidx1___ at 12
5344- // parameter-reference type______ type1_____ goes out of scope
5345- (void)LOCAL_POP_MOVE(&heap, 11LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type1_____ at 11
5346- // parameter-reference u64 mutable1__ goes out of scope
5347- (void)LOCAL_POP_MOVE(&heap, 10LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference mutable1__ at 10
5348- // parameter-reference continuity cont1_____ goes out of scope
5349- (void)LOCAL_POP_MOVE(&heap, 9LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference cont1_____ at 9
5350- // parameter-reference u64 indirect1_ goes out of scope
5351- (void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference indirect1_ at 8
5352- // parameter-reference signdef___ __________ goes out of scope
5353- (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 7
5354- // parameter-reference u64 curidx0___ goes out of scope
5355- (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference curidx0___ at 6
5356- // parameter-reference type______ type0_____ goes out of scope
5357- (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type0_____ at 5
5358- // parameter-reference u64 mutable0__ goes out of scope
5359- (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference mutable0__ at 4
5360- // parameter-reference continuity cont0_____ goes out of scope
5361- (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference cont0_____ at 3
5362- // parameter-reference u64 indirect0_ goes out of scope
5363- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference indirect0_ at 2
5364- // parameter-reference signdef___ __________ goes out of scope
5365- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
5366- {
5367- uint64_t baseinfo = heap.data[0].elem1;
5368- struct pair pair = unpair(&heap, &baseinfo);
5369- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
5370- state.addr = pair.elem1;
5371- }
5372- break;
5373- }
5374- case 589059743276730432LLU: // equpardef_
5375- {
5376-
5377- // ACCUMULATE ARGUMENTS - BEGIN
5378- {
5379- uint64_t arg = *LOCAL_ACCESS(heap.data, 3LLU, 0LLU);
5380- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5381- }
5382- {
5383- uint64_t arg = /*x_________*/tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 0LLU);
5384- LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5385- }
5386- {
5387- uint64_t arg = /*y_________*/tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 3LLU, 2LLU), 0LLU);
5388- LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5389- }
5390- // ACCUMULATE ARGUMENTS - END
5391- uint64_t return_to = 18446744073709551437LLU;
5392- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0));
5393- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5394- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
5395- heap.data[0].elem1 = heap.data[0].elem0;
5396- heap.data[0].elem0 = restore;
5397- state.addr = 589060043891015680LLU; // equtype___
5398- break;
5399- }
5400- case 18446744073709551437LLU: // 999999997M'''''''''''''''
5401- {
5402- {
5403- uint64_t arg = 0;
5404- LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5405- }
5406- *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /*equal_____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU));
5407- state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551436LLU : 18446744073709551435LLU;
5408- (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
5409- break;
5410- }
5411- case 18446744073709551436LLU: // 999999997L'''''''''''''''
5412- {
5413- state.addr = 18446744073709551434LLU; // 999999997J'''''''''''''''
5414- break;
5415- }
5416- case 18446744073709551435LLU: // 999999997K'''''''''''''''
5417- {
5418- fprintf(stderr, "%s", "type");
5419- state.addr = 18446744073709551434LLU; // 999999997J'''''''''''''''
5420- break;
5421- }
5422- case 18446744073709551434LLU: // 999999997J'''''''''''''''
5423- {
5424- {
5425- uint64_t arg = 0;
5426- LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5427- }
5428- *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /*equal_____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU));
5429- state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551433LLU : 18446744073709551432LLU;
5430- (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
5431- break;
5432- }
5433- case 18446744073709551433LLU: // 999999997I'''''''''''''''
5434- {
5435-
5436- *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));
5437- {
5438- uint64_t arg = 0;
5439- LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5440- }
5441- *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /*equal_____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU));
5442- state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551431LLU : 18446744073709551430LLU;
5443- (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
5444- break;
5445- }
5446- case 18446744073709551431LLU: // 999999997G'''''''''''''''
5447- {
5448- state.addr = 18446744073709551429LLU; // 999999997E'''''''''''''''
5449- break;
5450- }
5451- case 18446744073709551430LLU: // 999999997F'''''''''''''''
5452- {
5453- fprintf(stderr, "%s", "mutable");
5454- state.addr = 18446744073709551429LLU; // 999999997E'''''''''''''''
5455- break;
5456- }
5457- case 18446744073709551429LLU: // 999999997E'''''''''''''''
5458- {
5459- {
5460- uint64_t arg = 0;
5461- LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5462- }
5463- *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /*equal_____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU));
5464- state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551428LLU : 18446744073709551427LLU;
5465- (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
5466- break;
5467- }
5468- case 18446744073709551428LLU: // 999999997D'''''''''''''''
5469- {
5470-
5471- // ACCUMULATE ARGUMENTS - BEGIN
5472- {
5473- uint64_t arg = *LOCAL_ACCESS(heap.data, 3LLU, 0LLU);
5474- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5475- }
5476- {
5477- uint64_t arg = /*x_________*/tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 2LLU);
5478- LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5479- }
5480- {
5481- uint64_t arg = /*y_________*/tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 3LLU, 2LLU), 2LLU);
5482- LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5483- }
5484- // ACCUMULATE ARGUMENTS - END
5485- uint64_t return_to = 18446744073709551426LLU;
5486- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0));
5487- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5488- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
5489- heap.data[0].elem1 = heap.data[0].elem0;
5490- heap.data[0].elem0 = restore;
5491- state.addr = 589058781102643104LLU; // equbalance
5492- break;
5493- }
5494- case 18446744073709551426LLU: // 999999997B'''''''''''''''
5495- {
5496- {
5497- uint64_t arg = 0;
5498- LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5499- }
5500- *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /*equal_____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU));
5501- state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551425LLU : 18446744073709551424LLU;
5502- (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
5503- break;
5504- }
5505- case 18446744073709551425LLU: // 999999997A'''''''''''''''
5506- {
5507- state.addr = 18446744073709551423LLU; // 9999999969'''''''''''''''
5508- break;
5509- }
5510- case 18446744073709551424LLU: // 999999997_'''''''''''''''
5511- {
5512- fprintf(stderr, "%s", "continuity");
5513- state.addr = 18446744073709551423LLU; // 9999999969'''''''''''''''
5514- break;
5515- }
5516- case 18446744073709551423LLU: // 9999999969'''''''''''''''
5517- {
5518- {
5519- uint64_t arg = 0;
5520- LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5521- }
5522- *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /*equal_____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU));
5523- state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551422LLU : 18446744073709551421LLU;
5524- (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
5525- break;
5526- }
5527- case 18446744073709551422LLU: // 9999999968'''''''''''''''
5528- {
5529-
5530- *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));
5531- {
5532- uint64_t arg = 0;
5533- LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5534- }
5535- *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /*equal_____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU));
5536- state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551420LLU : 18446744073709551419LLU;
5537- (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
5538- break;
5539- }
5540- case 18446744073709551420LLU: // 9999999966'''''''''''''''
5541- {
5542- state.addr = 18446744073709551418LLU; // 9999999964'''''''''''''''
5543- break;
5544- }
5545- case 18446744073709551419LLU: // 9999999965'''''''''''''''
5546- {
5547- fprintf(stderr, "%s", "REFERENCE");
5548- state.addr = 18446744073709551418LLU; // 9999999964'''''''''''''''
5549- break;
5550- }
5551- case 18446744073709551418LLU: // 9999999964'''''''''''''''
5552- {
5553- state.addr = 18446744073709551421LLU; // 9999999967'''''''''''''''
5554- break;
5555- }
5556- case 18446744073709551421LLU: // 9999999967'''''''''''''''
5557- {
5558- state.addr = 18446744073709551427LLU; // 999999997C'''''''''''''''
5559- break;
5560- }
5561- case 18446744073709551427LLU: // 999999997C'''''''''''''''
5562- {
5563- state.addr = 18446744073709551432LLU; // 999999997H'''''''''''''''
5564- break;
5565- }
5566- case 18446744073709551432LLU: // 999999997H'''''''''''''''
5567- {
5568- // parameter-reference pardef____ y_________ goes out of scope
5569- (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference y_________ at 3
5570- // parameter-reference pardef____ x_________ goes out of scope
5571- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference x_________ at 2
5572- // parameter-reference u64 equal_____ goes out of scope
5573- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference equal_____ at 1
5574- {
5575- uint64_t baseinfo = heap.data[0].elem1;
5576- struct pair pair = unpair(&heap, &baseinfo);
5577- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
5578- state.addr = pair.elem1;
5579- }
5580- break;
5581- }
5582- case 589058998957897761LLU: // equelemdef
5583- {
5584-
5585- *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));
5586- {
5587- uint64_t arg = 0;
5588- LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5589- }
5590- *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /*equal_____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU));
5591- state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551417LLU : 18446744073709551416LLU;
5592- (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
5593- break;
5594- }
5595- case 18446744073709551417LLU: // 9999999963'''''''''''''''
5596- {
5597-
5598- // ACCUMULATE ARGUMENTS - BEGIN
5599- {
5600- uint64_t arg = *LOCAL_ACCESS(heap.data, 3LLU, 0LLU);
5601- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5602- }
5603- {
5604- uint64_t arg = /*x_________*/tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 1LLU);
5605- LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5606- }
5607- {
5608- uint64_t arg = /*y_________*/tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 3LLU, 2LLU), 1LLU);
5609- LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5610- }
5611- // ACCUMULATE ARGUMENTS - END
5612- uint64_t return_to = 18446744073709551415LLU;
5613- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0));
5614- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5615- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
5616- heap.data[0].elem1 = heap.data[0].elem0;
5617- heap.data[0].elem0 = restore;
5618- state.addr = 589060043891015680LLU; // equtype___
5619- break;
5620- }
5621- case 18446744073709551415LLU: // 9999999961'''''''''''''''
5622- {
5623- state.addr = 18446744073709551416LLU; // 9999999962'''''''''''''''
5624- break;
5625- }
5626- case 18446744073709551416LLU: // 9999999962'''''''''''''''
5627- {
5628- // parameter-reference elemdef___ y_________ goes out of scope
5629- (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference y_________ at 3
5630- // parameter-reference elemdef___ x_________ goes out of scope
5631- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference x_________ at 2
5632- // parameter-reference u64 equal_____ goes out of scope
5633- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference equal_____ at 1
5634- {
5635- uint64_t baseinfo = heap.data[0].elem1;
5636- struct pair pair = unpair(&heap, &baseinfo);
5637- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
5638- state.addr = pair.elem1;
5639- }
5640- break;
5641- }
5642- case 782700512573827828LLU: // pardefcopy
5643- {
5644- {
5645- uint64_t arg = tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 2LLU, 0LLU), 0LLU);
5646- LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5647- }
5648- {
5649- uint64_t arg = tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU), 1LLU);
5650- LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5651- }
5652- {
5653- uint64_t arg = tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU), 2LLU);
5654- LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5655- }
5656- {
5657- uint64_t arg = tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 5LLU, 0LLU), 3LLU);
5658- LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5659- }
5660- {
5661- uint64_t arg = tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 6LLU, 1LLU), 0LLU);
5662- LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5663- }
5664- {
5665- uint64_t arg = tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 7LLU, 1LLU), 1LLU);
5666- LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5667- }
5668- {
5669- uint64_t arg = tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 8LLU, 1LLU), 2LLU);
5670- LOCAL_PUSH_MOVE(&heap, 8, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5671- }
5672- {
5673- uint64_t arg = tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 9LLU, 1LLU), 3LLU);
5674- LOCAL_PUSH_MOVE(&heap, 9, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5675- }
5676-
5677- // emitted destructur for type type______
5678- // ACCUMULATE ARGUMENTS - BEGIN
5679- {
5680- uint64_t arg = *LOCAL_ACCESS(heap.data, 10LLU, 2LLU);
5681- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5682- }
5683- // ACCUMULATE ARGUMENTS - END
5684- uint64_t return_to = 18446744073709551413LLU;
5685- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
5686- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5687- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
5688- heap.data[0].elem1 = heap.data[0].elem0;
5689- heap.data[0].elem0 = restore;
5690- state.addr = 18446744073709551569LLU; // 999999999Q'''''''''''''''
5691- break;
5692- }
5693- case 18446744073709551413LLU: // 999999996z'''''''''''''''
5694- {
5695- // ACCUMULATE ARGUMENTS - BEGIN
5696- {
5697- uint64_t arg = *LOCAL_ACCESS(heap.data, 10LLU, 2LLU);
5698- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5699- }
5700- {
5701- uint64_t arg = /*type1_____*/*LOCAL_ACCESS(heap.data, 10LLU, 6LLU);
5702- LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5703- }
5704- // ACCUMULATE ARGUMENTS - END
5705- uint64_t return_to = 18446744073709551412LLU;
5706- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
5707- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5708- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
5709- heap.data[0].elem1 = heap.data[0].elem0;
5710- heap.data[0].elem0 = restore;
5711- state.addr = 367395560426147840LLU; // TYPECOPY__
5712- break;
5713- }
5714- case 18446744073709551412LLU: // 999999996y'''''''''''''''
5715- {
5716- // ACCUMULATE ARGUMENTS - BEGIN
5717- {
5718- uint64_t arg = /*balance0__*/*LOCAL_ACCESS(heap.data, 10LLU, 4LLU);
5719- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5720- }
5721- {
5722- uint64_t arg = /*balance1__*/*LOCAL_ACCESS(heap.data, 10LLU, 8LLU);
5723- LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5724- }
5725- // ACCUMULATE ARGUMENTS - END
5726- uint64_t return_to = 18446744073709551411LLU;
5727- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
5728- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5729- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
5730- heap.data[0].elem1 = heap.data[0].elem0;
5731- heap.data[0].elem0 = restore;
5732- state.addr = 552664889133754368LLU; // cpbalance_
5733- break;
5734- }
5735- case 18446744073709551411LLU: // 999999996x'''''''''''''''
5736- {
5737-
5738- *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 10LLU, 3LLU)) = /*mutable1__*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 10LLU, 7LLU));
5739-
5740- *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 10LLU, 5LLU)) = /*reference1*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 10LLU, 9LLU));
5741- // parameter-reference u64 reference1 goes out of scope
5742- (void)LOCAL_POP_MOVE(&heap, 10LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference reference1 at 10
5743- // parameter-reference continuity balance1__ goes out of scope
5744- (void)LOCAL_POP_MOVE(&heap, 9LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference balance1__ at 9
5745- // parameter-reference u64 mutable1__ goes out of scope
5746- (void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference mutable1__ at 8
5747- // parameter-reference type______ type1_____ goes out of scope
5748- (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type1_____ at 7
5749- // parameter-reference pardef____ __________ goes out of scope
5750- (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 6
5751- // parameter-reference u64 reference0 goes out of scope
5752- (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference reference0 at 5
5753- // parameter-reference continuity balance0__ goes out of scope
5754- (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference balance0__ at 4
5755- // parameter-reference u64 mutable0__ goes out of scope
5756- (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference mutable0__ at 3
5757- // parameter-reference type______ type0_____ goes out of scope
5758- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type0_____ at 2
5759- // parameter-reference pardef____ __________ goes out of scope
5760- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
5761- {
5762- uint64_t baseinfo = heap.data[0].elem1;
5763- struct pair pair = unpair(&heap, &baseinfo);
5764- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
5765- state.addr = pair.elem1;
5766- }
5767- break;
5768- }
5769- case 288591296313750553LLU: // PARDEFCOPY
5770- {
5771- *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 0LLU)) = tree_init(&heap, 4LLU);
5772- {
5773- uint64_t arg = tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 2LLU, 0LLU), 0LLU);
5774- LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5775- }
5776- {
5777- uint64_t arg = tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU), 1LLU);
5778- LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5779- }
5780- {
5781- uint64_t arg = tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU), 2LLU);
5782- LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5783- }
5784- {
5785- uint64_t arg = tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 5LLU, 0LLU), 3LLU);
5786- LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5787- }
5788- {
5789- uint64_t arg = tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 6LLU, 1LLU), 0LLU);
5790- LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5791- }
5792- {
5793- uint64_t arg = tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 7LLU, 1LLU), 1LLU);
5794- LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5795- }
5796- {
5797- uint64_t arg = tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 8LLU, 1LLU), 2LLU);
5798- LOCAL_PUSH_MOVE(&heap, 8, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5799- }
5800- {
5801- uint64_t arg = tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 9LLU, 1LLU), 3LLU);
5802- LOCAL_PUSH_MOVE(&heap, 9, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5803- }
5804-
5805- // ACCUMULATE ARGUMENTS - BEGIN
5806- {
5807- uint64_t arg = *LOCAL_ACCESS(heap.data, 10LLU, 2LLU);
5808- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5809- }
5810- {
5811- uint64_t arg = /*type1_____*/*LOCAL_ACCESS(heap.data, 10LLU, 6LLU);
5812- LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5813- }
5814- // ACCUMULATE ARGUMENTS - END
5815- uint64_t return_to = 18446744073709551409LLU;
5816- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
5817- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5818- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
5819- heap.data[0].elem1 = heap.data[0].elem0;
5820- heap.data[0].elem0 = restore;
5821- state.addr = 367395560426147840LLU; // TYPECOPY__
5822- break;
5823- }
5824- case 18446744073709551409LLU: // 999999996v'''''''''''''''
5825- {
5826-
5827- // ACCUMULATE ARGUMENTS - BEGIN
5828- {
5829- uint64_t arg = *LOCAL_ACCESS(heap.data, 10LLU, 4LLU);
5830- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5831- }
5832- {
5833- uint64_t arg = /*balance1__*/*LOCAL_ACCESS(heap.data, 10LLU, 8LLU);
5834- LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5835- }
5836- // ACCUMULATE ARGUMENTS - END
5837- uint64_t return_to = 18446744073709551408LLU;
5838- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
5839- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5840- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
5841- heap.data[0].elem1 = heap.data[0].elem0;
5842- heap.data[0].elem0 = restore;
5843- state.addr = 58555672873677120LLU; // CPBALANCE_
5844- break;
5845- }
5846- case 18446744073709551408LLU: // 999999996u'''''''''''''''
5847- {
5848-
5849- *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 10LLU, 3LLU)) = /*mutable1__*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 10LLU, 7LLU));
5850-
5851- *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 10LLU, 5LLU)) = /*reference1*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 10LLU, 9LLU));
5852- // parameter-reference u64 reference1 goes out of scope
5853- (void)LOCAL_POP_MOVE(&heap, 10LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference reference1 at 10
5854- // parameter-reference continuity balance1__ goes out of scope
5855- (void)LOCAL_POP_MOVE(&heap, 9LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference balance1__ at 9
5856- // parameter-reference u64 mutable1__ goes out of scope
5857- (void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference mutable1__ at 8
5858- // parameter-reference type______ type1_____ goes out of scope
5859- (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type1_____ at 7
5860- // parameter-reference pardef____ __________ goes out of scope
5861- (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 6
5862- // parameter-reference u64 reference0 goes out of scope
5863- (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference reference0 at 5
5864- // parameter-reference continuity balance0__ goes out of scope
5865- (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference balance0__ at 4
5866- // parameter-reference u64 mutable0__ goes out of scope
5867- (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference mutable0__ at 3
5868- // parameter-reference type______ type0_____ goes out of scope
5869- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type0_____ at 2
5870- // parameter-reference pardef____ __________ goes out of scope
5871- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
5872- {
5873- uint64_t baseinfo = heap.data[0].elem1;
5874- struct pair pair = unpair(&heap, &baseinfo);
5875- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
5876- state.addr = pair.elem1;
5877- }
5878- break;
5879- }
5880- case 296309897384864500LLU: // ParDefCopy
5881- {
5882- {
5883- uint64_t arg = tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU), 0LLU);
5884- LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5885- }
5886- {
5887- uint64_t arg = tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 1LLU);
5888- LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5889- }
5890- {
5891- uint64_t arg = tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 4LLU, 1LLU), 2LLU);
5892- LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5893- }
5894- {
5895- uint64_t arg = tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 5LLU, 1LLU), 3LLU);
5896- LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5897- }
5898- // ACCUMULATE ARGUMENTS - BEGIN
5899- {
5900- uint64_t arg = *LOCAL_ACCESS(heap.data, 6LLU, 0LLU);
5901- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5902- }
5903- {
5904- uint64_t arg = heap.data[0].elem0;
5905- LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5906- }
5907- {
5908- uint64_t arg = 0;
5909- LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5910- }
5911- // ACCUMULATE ARGUMENTS - BEGIN
5912- {
5913- uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 8LLU, 7LLU);
5914- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5915- }
5916- {
5917- uint64_t arg = /*type1_____*/*LOCAL_ACCESS(heap.data, 8LLU, 2LLU);
5918- LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5919- }
5920- // ACCUMULATE ARGUMENTS - END
5921- uint64_t return_to = 18446744073709551405LLU;
5922- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
5923- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5924- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
5925- heap.data[0].elem1 = heap.data[0].elem0;
5926- heap.data[0].elem0 = restore;
5927- state.addr = 367395560426147840LLU; // TYPECOPY__
5928- break;
5929- }
5930- case 18446744073709551405LLU: // 999999996r'''''''''''''''
5931- {
5932- {
5933- uint64_t exchange = LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 8*/;
5934- heap.data[0].elem0 = LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 7*/;
5935-
5936- {
5937- uint64_t arg = exchange;
5938- LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5939- }
5940- }
5941- {
5942- uint64_t arg = heap.data[0].elem0;
5943- LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5944- }
5945- {
5946- uint64_t arg = 0;
5947- LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5948- }
5949- // ACCUMULATE ARGUMENTS - BEGIN
5950- {
5951- uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 8LLU, 7LLU);
5952- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5953- }
5954- {
5955- uint64_t arg = /*mutable1__*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 8LLU, 3LLU));
5956- LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5957- }
5958- // ACCUMULATE ARGUMENTS - END
5959- uint64_t return_to = 18446744073709551404LLU;
5960- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
5961- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
5962- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
5963- heap.data[0].elem1 = heap.data[0].elem0;
5964- heap.data[0].elem0 = restore;
5965- state.addr = 552446646280519680LLU; // copyu64___
5966- break;
5967- }
5968- case 18446744073709551404LLU: // 999999996q'''''''''''''''
5969- {
5970- {
5971- uint64_t exchange = LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 8*/;
5972- heap.data[0].elem0 = LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 7*/;
5973-
5974- {
5975- uint64_t arg = exchange;
5976- LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5977- }
5978- }
5979- {
5980- uint64_t arg = heap.data[0].elem0;
5981- LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5982- }
5983- {
5984- uint64_t arg = 0;
5985- LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/*address of current closure*/, &arg);
5986- }
5987- // ACCUMULATE ARGUMENTS - BEGIN
5988- {
5989- uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 8LLU, 7LLU);
5990- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5991- }
5992- {
5993- uint64_t arg = /*balance1__*/*LOCAL_ACCESS(heap.data, 8LLU, 4LLU);
5994- LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
5995- }
5996- // ACCUMULATE ARGUMENTS - END
5997- uint64_t return_to = 18446744073709551403LLU;
5998- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
5999- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6000- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
6001- heap.data[0].elem1 = heap.data[0].elem0;
6002- heap.data[0].elem0 = restore;
6003- state.addr = 58555672873677120LLU; // CPBALANCE_
6004- break;
6005- }
6006- case 18446744073709551403LLU: // 999999996p'''''''''''''''
6007- {
6008- {
6009- uint64_t exchange = LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 8*/;
6010- heap.data[0].elem0 = LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 7*/;
6011-
6012- {
6013- uint64_t arg = exchange;
6014- LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6015- }
6016- }
6017- {
6018- uint64_t arg = heap.data[0].elem0;
6019- LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6020- }
6021- {
6022- uint64_t arg = 0;
6023- LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6024- }
6025- // ACCUMULATE ARGUMENTS - BEGIN
6026- {
6027- uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 8LLU, 7LLU);
6028- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6029- }
6030- {
6031- uint64_t arg = /*reference1*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 8LLU, 5LLU));
6032- LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6033- }
6034- // ACCUMULATE ARGUMENTS - END
6035- uint64_t return_to = 18446744073709551402LLU;
6036- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
6037- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6038- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
6039- heap.data[0].elem1 = heap.data[0].elem0;
6040- heap.data[0].elem0 = restore;
6041- state.addr = 552446646280519680LLU; // copyu64___
6042- break;
6043- }
6044- case 18446744073709551402LLU: // 999999996o'''''''''''''''
6045- {
6046- {
6047- uint64_t exchange = LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 8*/;
6048- heap.data[0].elem0 = LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 7*/;
6049-
6050- {
6051- uint64_t arg = exchange;
6052- LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6053- }
6054- }
6055- // ACCUMULATE ARGUMENTS - END
6056- uint64_t return_to = 18446744073709551406LLU;
6057- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0));
6058- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6059- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
6060- heap.data[0].elem1 = heap.data[0].elem0;
6061- heap.data[0].elem0 = restore;
6062- state.addr = 782700512565788672LLU; // pardef____
6063- break;
6064- }
6065- case 18446744073709551406LLU: // 999999996s'''''''''''''''
6066- {
6067- // parameter-reference u64 reference1 goes out of scope
6068- (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference reference1 at 6
6069- // parameter-reference continuity balance1__ goes out of scope
6070- (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference balance1__ at 5
6071- // parameter-reference u64 mutable1__ goes out of scope
6072- (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference mutable1__ at 4
6073- // parameter-reference type______ type1_____ goes out of scope
6074- (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type1_____ at 3
6075- // parameter-reference pardef____ __________ goes out of scope
6076- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
6077- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
6078- {
6079- uint64_t baseinfo = heap.data[0].elem1;
6080- struct pair pair = unpair(&heap, &baseinfo);
6081- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
6082- state.addr = pair.elem1;
6083- }
6084- break;
6085- }
6086- case 782700512577972928LLU: // pardefscp_
6087- {
6088- {
6089- uint64_t arg = /*srcs______*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU));
6090- LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6091- }
6092- {
6093- uint64_t arg = 0;
6094- LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6095- }
6096- state.addr = 18446744073709551401LLU; // 999999996n'''''''''''''''
6097- break;
6098- }
6099- case 18446744073709551401LLU: // 999999996n'''''''''''''''
6100- {
6101- if(!*LOCAL_ACCESS(heap.data, 4LLU, 2LLU))
6102- {
6103- (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
6104- (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 3
6105- {
6106- state.addr = 18446744073709551400LLU; // 999999996m'''''''''''''''
6107- break;
6108- }
6109- }
6110- /*direct*/*LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = (*LOCAL_ACCESS(heap.data, 4LLU, 2LLU) << 1) + 1LLU;
6111- *LOCAL_ACCESS(heap.data, 4LLU, 2LLU) = heap.data[*LOCAL_ACCESS(heap.data, 4LLU, 2LLU)].elem0;
6112- {
6113- uint64_t arg = 0;
6114- LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6115- }
6116- // ACCUMULATE ARGUMENTS - BEGIN
6117- {
6118- uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 5LLU, 4LLU);
6119- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6120- }
6121- {
6122- uint64_t arg = /*src_______*/*LOCAL_ACCESS(heap.data, 5LLU, 3LLU);
6123- LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6124- }
6125- // ACCUMULATE ARGUMENTS - END
6126- uint64_t return_to = 18446744073709551396LLU;
6127- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
6128- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6129- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
6130- heap.data[0].elem1 = heap.data[0].elem0;
6131- heap.data[0].elem0 = restore;
6132- state.addr = 296309897384864500LLU; // ParDefCopy
6133- break;
6134- }
6135- case 18446744073709551396LLU: // 999999996i'''''''''''''''
6136- {
6137- state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 5LLU, 4LLU), &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 0LLU)), 11) ? 18446744073709551399LLU : 18446744073709551398LLU;
6138- break;
6139- }
6140- case 18446744073709551399LLU: // 999999996l'''''''''''''''
6141- {
6142- {
6143- fprintf(stderr, "%s\n", "INTERNAL ERROR: out of heap in pardefscp - recompile with increased heap-size");
6144- exit(-1);
6145- }
6146- // emitted destructur for type pardef____
6147- // ACCUMULATE ARGUMENTS - BEGIN
6148- {
6149- uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 5LLU, 4LLU);
6150- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6151- }
6152- // ACCUMULATE ARGUMENTS - END
6153- uint64_t return_to = 18446744073709551395LLU;
6154- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6155- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6156- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
6157- heap.data[0].elem1 = heap.data[0].elem0;
6158- heap.data[0].elem0 = restore;
6159- state.addr = 18446744073709551449LLU; // 999999997Y'''''''''''''''
6160- break;
6161- }
6162- case 18446744073709551395LLU: // 999999996h'''''''''''''''
6163- {
6164- // parameter pardef____ dst_______ goes out of scope
6165- state.addr = 18446744073709551397LLU; // 999999996j'''''''''''''''
6166- break;
6167- }
6168- case 18446744073709551398LLU: // 999999996k'''''''''''''''
6169- {
6170- state.addr = 18446744073709551397LLU; // 999999996j'''''''''''''''
6171- break;
6172- }
6173- case 18446744073709551397LLU: // 999999996j'''''''''''''''
6174- {
6175- (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 5
6176- // parameter-reference pardef____ src_______ goes out of scope
6177- // parameter-reference list<pardef____> srcs______ goes out of scope
6178- state.addr = 18446744073709551401LLU; // 999999996n'''''''''''''''
6179- break;
6180- }
6181- case 18446744073709551400LLU: // 999999996m'''''''''''''''
6182- {
6183- // parameter-reference list<pardef____> srcs______ goes out of scope
6184- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference srcs______ at 2
6185- // parameter-reference list<pardef____> dsts______ goes out of scope
6186- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference dsts______ at 1
6187- {
6188- uint64_t baseinfo = heap.data[0].elem1;
6189- struct pair pair = unpair(&heap, &baseinfo);
6190- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
6191- state.addr = pair.elem1;
6192- }
6193- break;
6194- }
6195- case 587581813005601646LLU: // elems2pars
6196- {
6197- {
6198- uint64_t arg = /*srcs______*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU));
6199- LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6200- }
6201- {
6202- uint64_t arg = 0;
6203- LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6204- }
6205- state.addr = 18446744073709551394LLU; // 999999996g'''''''''''''''
6206- break;
6207- }
6208- case 18446744073709551394LLU: // 999999996g'''''''''''''''
6209- {
6210- if(!*LOCAL_ACCESS(heap.data, 5LLU, 3LLU))
6211- {
6212- (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 5
6213- (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
6214- {
6215- state.addr = 18446744073709551393LLU; // 999999996f'''''''''''''''
6216- break;
6217- }
6218- }
6219- /*direct*/*LOCAL_ACCESS(heap.data, 5LLU, 4LLU) = (*LOCAL_ACCESS(heap.data, 5LLU, 3LLU) << 1) + 1LLU;
6220- *LOCAL_ACCESS(heap.data, 5LLU, 3LLU) = heap.data[*LOCAL_ACCESS(heap.data, 5LLU, 3LLU)].elem0;
6221- {
6222- uint64_t arg = 0;
6223- LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6224- }
6225- *LOCAL_ACCESS(heap.data, 6LLU, 5LLU) = 1;
6226- {
6227- uint64_t arg = 0;
6228- LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6229- }
6230- *LOCAL_ACCESS(heap.data, 7LLU, 6LLU) = /*reference_*/*LOCAL_ACCESS(heap.data, 7LLU, 2LLU);
6231- {
6232- uint64_t arg = 0;
6233- LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6234- }
6235- // ACCUMULATE ARGUMENTS - BEGIN
6236- {
6237- uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 8LLU, 7LLU);
6238- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6239- }
6240- {
6241- uint64_t arg = /*src_______*/tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 8LLU, 4LLU), 1LLU);
6242- LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6243- }
6244- // ACCUMULATE ARGUMENTS - END
6245- uint64_t return_to = 18446744073709551392LLU;
6246- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
6247- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6248- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
6249- heap.data[0].elem1 = heap.data[0].elem0;
6250- heap.data[0].elem0 = restore;
6251- state.addr = 367395560426147840LLU; // TYPECOPY__
6252- break;
6253- }
6254- case 18446744073709551392LLU: // 999999996e'''''''''''''''
6255- {
6256- {
6257- uint64_t arg = 0;
6258- LOCAL_PUSH_MOVE(&heap, 8, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6259- }
6260- // ACCUMULATE ARGUMENTS - BEGIN
6261- {
6262- uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 9LLU, 8LLU);
6263- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6264- }
6265- // ACCUMULATE ARGUMENTS - END
6266- uint64_t return_to = 18446744073709551391LLU;
6267- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6268- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6269- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
6270- heap.data[0].elem1 = heap.data[0].elem0;
6271- heap.data[0].elem0 = restore;
6272- state.addr = 552437437528276992LLU; // consume___
6273- break;
6274- }
6275- case 18446744073709551391LLU: // 999999996d'''''''''''''''
6276- {
6277- {
6278- uint64_t arg = 0;
6279- LOCAL_PUSH_MOVE(&heap, 9, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6280- }
6281- // ACCUMULATE ARGUMENTS - BEGIN
6282- {
6283- uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 10LLU, 9LLU);
6284- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6285- }
6286- {
6287- uint64_t arg = /*t_________*/*LOCAL_ACCESS(heap.data, 10LLU, 7LLU);
6288- LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6289- }
6290- {
6291- uint64_t arg = /*mutable___*/*LOCAL_ACCESS(heap.data, 10LLU, 5LLU);
6292- LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6293- }
6294- {
6295- uint64_t arg = /*continuity*/*LOCAL_ACCESS(heap.data, 10LLU, 8LLU);
6296- LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6297- }
6298- {
6299- uint64_t arg = /*reference_*/*LOCAL_ACCESS(heap.data, 10LLU, 6LLU);
6300- LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6301- }
6302- // ACCUMULATE ARGUMENTS - END
6303- uint64_t return_to = 18446744073709551387LLU;
6304- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0));
6305- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6306- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
6307- heap.data[0].elem1 = heap.data[0].elem0;
6308- heap.data[0].elem0 = restore;
6309- state.addr = 782700512565788672LLU; // pardef____
6310- break;
6311- }
6312- case 18446744073709551387LLU: // 999999996$'''''''''''''''
6313- {
6314- state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 10LLU, 9LLU), &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 10LLU, 0LLU)), 11) ? 18446744073709551390LLU : 18446744073709551389LLU;
6315- break;
6316- }
6317- case 18446744073709551390LLU: // 999999996c'''''''''''''''
6318- {
6319- fprintf(stderr, "%s", "pushing par ");
6320- // ACCUMULATE ARGUMENTS - BEGIN
6321- {
6322- uint64_t arg = /*newpar____*/tree_elem_addr(heap.data, 4LLU, LOCAL_ACCESS_ADDR(heap.data, 10LLU, 9LLU), 0LLU);
6323- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6324- }
6325- // ACCUMULATE ARGUMENTS - END
6326- uint64_t return_to = 18446744073709551386LLU;
6327- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6328- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6329- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
6330- heap.data[0].elem1 = heap.data[0].elem0;
6331- heap.data[0].elem0 = restore;
6332- state.addr = 819847183518878432LLU; // reporttype
6333- break;
6334- }
6335- case 18446744073709551386LLU: // 999999996Z'''''''''''''''
6336- {
6337- fprintf(stderr, "%s", "\n");
6338- {
6339- fprintf(stderr, "%s\n", "INTERNAL ERROR: out of heap/dynamic in compiler, elems2pars - recompile compiler with increased heap-size");
6340- exit(-1);
6341- }
6342- // emitted destructur for type pardef____
6343- // ACCUMULATE ARGUMENTS - BEGIN
6344- {
6345- uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 10LLU, 9LLU);
6346- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6347- }
6348- // ACCUMULATE ARGUMENTS - END
6349- uint64_t return_to = 18446744073709551385LLU;
6350- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6351- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6352- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
6353- heap.data[0].elem1 = heap.data[0].elem0;
6354- heap.data[0].elem0 = restore;
6355- state.addr = 18446744073709551449LLU; // 999999997Y'''''''''''''''
6356- break;
6357- }
6358- case 18446744073709551385LLU: // 999999996Y'''''''''''''''
6359- {
6360- // parameter pardef____ newpar____ goes out of scope
6361- state.addr = 18446744073709551388LLU; // 999999996a'''''''''''''''
6362- break;
6363- }
6364- case 18446744073709551389LLU: // 999999996b'''''''''''''''
6365- {
6366- state.addr = 18446744073709551388LLU; // 999999996a'''''''''''''''
6367- break;
6368- }
6369- case 18446744073709551388LLU: // 999999996a'''''''''''''''
6370- {
6371- (void)LOCAL_POP_MOVE(&heap, 10LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 10
6372- // variable continuity continuity goes out of scope
6373- // (uninitialized -> no destructor-call)
6374- (void)LOCAL_POP_MOVE(&heap, 9LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference continuity at 9
6375- // variable type______ t_________ goes out of scope
6376- // (uninitialized -> no destructor-call)
6377- (void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference t_________ at 8
6378- // variable u64 reference_ goes out of scope
6379- // (uninitialized -> no destructor-call)
6380- (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference reference_ at 7
6381- // variable u64 mutable___ goes out of scope
6382- // (uninitialized -> no destructor-call)
6383- (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference mutable___ at 6
6384- // parameter-reference elemdef___ src_______ goes out of scope
6385- // parameter-reference list<elemdef___> srcs______ goes out of scope
6386- state.addr = 18446744073709551394LLU; // 999999996g'''''''''''''''
6387- break;
6388- }
6389- case 18446744073709551393LLU: // 999999996f'''''''''''''''
6390- {
6391- // parameter u64 reference_ goes out of scope
6392- (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference reference_ at 3
6393- // parameter-reference list<elemdef___> srcs______ goes out of scope
6394- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference srcs______ at 2
6395- // parameter-reference list<pardef____> dsts______ goes out of scope
6396- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference dsts______ at 1
6397- {
6398- uint64_t baseinfo = heap.data[0].elem1;
6399- struct pair pair = unpair(&heap, &baseinfo);
6400- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
6401- state.addr = pair.elem1;
6402- }
6403- break;
6404- }
6405- case 587581796494207680LLU: // elemdefcp_
6406- {
6407- {
6408- uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 2LLU, 0LLU), 0LLU);
6409- LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6410- }
6411- {
6412- uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU), 1LLU);
6413- LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6414- }
6415- {
6416- uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 4LLU, 1LLU), 0LLU);
6417- LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6418- }
6419- {
6420- uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 5LLU, 1LLU), 1LLU);
6421- LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6422- }
6423-
6424- *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 6LLU, 2LLU)) = /*id1_______*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 6LLU, 4LLU));
6425-
6426- // emitted destructur for type type______
6427- // ACCUMULATE ARGUMENTS - BEGIN
6428- {
6429- uint64_t arg = *LOCAL_ACCESS(heap.data, 6LLU, 3LLU);
6430- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6431- }
6432- // ACCUMULATE ARGUMENTS - END
6433- uint64_t return_to = 18446744073709551383LLU;
6434- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6435- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6436- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
6437- heap.data[0].elem1 = heap.data[0].elem0;
6438- heap.data[0].elem0 = restore;
6439- state.addr = 18446744073709551569LLU; // 999999999Q'''''''''''''''
6440- break;
6441- }
6442- case 18446744073709551383LLU: // 999999996W'''''''''''''''
6443- {
6444- // ACCUMULATE ARGUMENTS - BEGIN
6445- {
6446- uint64_t arg = *LOCAL_ACCESS(heap.data, 6LLU, 3LLU);
6447- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6448- }
6449- {
6450- uint64_t arg = /*type1_____*/*LOCAL_ACCESS(heap.data, 6LLU, 5LLU);
6451- LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6452- }
6453- // ACCUMULATE ARGUMENTS - END
6454- uint64_t return_to = 18446744073709551382LLU;
6455- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
6456- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6457- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
6458- heap.data[0].elem1 = heap.data[0].elem0;
6459- heap.data[0].elem0 = restore;
6460- state.addr = 367395560426147840LLU; // TYPECOPY__
6461- break;
6462- }
6463- case 18446744073709551382LLU: // 999999996V'''''''''''''''
6464- {
6465- // parameter-reference type______ type1_____ goes out of scope
6466- (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type1_____ at 6
6467- // parameter-reference u64 id1_______ goes out of scope
6468- (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id1_______ at 5
6469- // parameter-reference elemdef___ __________ goes out of scope
6470- (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 4
6471- // parameter-reference type______ type0_____ goes out of scope
6472- (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type0_____ at 3
6473- // parameter-reference u64 id0_______ goes out of scope
6474- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id0_______ at 2
6475- // parameter-reference elemdef___ __________ goes out of scope
6476- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
6477- {
6478- uint64_t baseinfo = heap.data[0].elem1;
6479- struct pair pair = unpair(&heap, &baseinfo);
6480- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
6481- state.addr = pair.elem1;
6482- }
6483- break;
6484- }
6485- case 101193007747052544LLU: // ElemDefCP_
6486- {
6487- {
6488- uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU), 0LLU);
6489- LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6490- }
6491- {
6492- uint64_t arg = tree_elem_addr(heap.data, 2LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 1LLU);
6493- LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6494- }
6495- // ACCUMULATE ARGUMENTS - BEGIN
6496- {
6497- uint64_t arg = *LOCAL_ACCESS(heap.data, 4LLU, 0LLU);
6498- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6499- }
6500- {
6501- uint64_t arg = heap.data[0].elem0;
6502- LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6503- }
6504- {
6505- uint64_t arg = 0;
6506- LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6507- }
6508- // ACCUMULATE ARGUMENTS - BEGIN
6509- {
6510- uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 6LLU, 5LLU);
6511- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6512- }
6513- {
6514- uint64_t arg = /*id1_______*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 6LLU, 2LLU));
6515- LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6516- }
6517- // ACCUMULATE ARGUMENTS - END
6518- uint64_t return_to = 18446744073709551379LLU;
6519- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
6520- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6521- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
6522- heap.data[0].elem1 = heap.data[0].elem0;
6523- heap.data[0].elem0 = restore;
6524- state.addr = 552446646280519680LLU; // copyu64___
6525- break;
6526- }
6527- case 18446744073709551379LLU: // 999999996S'''''''''''''''
6528- {
6529- {
6530- uint64_t exchange = LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 6*/;
6531- heap.data[0].elem0 = LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 5*/;
6532-
6533- {
6534- uint64_t arg = exchange;
6535- LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6536- }
6537- }
6538- {
6539- uint64_t arg = heap.data[0].elem0;
6540- LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6541- }
6542- {
6543- uint64_t arg = 0;
6544- LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6545- }
6546- // ACCUMULATE ARGUMENTS - BEGIN
6547- {
6548- uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 6LLU, 5LLU);
6549- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6550- }
6551- {
6552- uint64_t arg = /*type1_____*/*LOCAL_ACCESS(heap.data, 6LLU, 3LLU);
6553- LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6554- }
6555- // ACCUMULATE ARGUMENTS - END
6556- uint64_t return_to = 18446744073709551378LLU;
6557- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
6558- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6559- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
6560- heap.data[0].elem1 = heap.data[0].elem0;
6561- heap.data[0].elem0 = restore;
6562- state.addr = 367395560426147840LLU; // TYPECOPY__
6563- break;
6564- }
6565- case 18446744073709551378LLU: // 999999996R'''''''''''''''
6566- {
6567- {
6568- uint64_t exchange = LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 6*/;
6569- heap.data[0].elem0 = LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 5*/;
6570-
6571- {
6572- uint64_t arg = exchange;
6573- LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6574- }
6575- }
6576- // ACCUMULATE ARGUMENTS - END
6577- uint64_t return_to = 18446744073709551380LLU;
6578- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0));
6579- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6580- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
6581- heap.data[0].elem1 = heap.data[0].elem0;
6582- heap.data[0].elem0 = restore;
6583- state.addr = 587581796494082048LLU; // elemdef___
6584- break;
6585- }
6586- case 18446744073709551380LLU: // 999999996T'''''''''''''''
6587- {
6588- // parameter-reference type______ type1_____ goes out of scope
6589- (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type1_____ at 4
6590- // parameter-reference u64 id1_______ goes out of scope
6591- (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id1_______ at 3
6592- // parameter-reference elemdef___ __________ goes out of scope
6593- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 2
6594- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
6595- {
6596- uint64_t baseinfo = heap.data[0].elem1;
6597- struct pair pair = unpair(&heap, &baseinfo);
6598- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
6599- state.addr = pair.elem1;
6600- }
6601- break;
6602- }
6603- case 587581796494272427LLU: // elemdefscp
6604- {
6605- {
6606- uint64_t arg = /*srcs______*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU));
6607- LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6608- }
6609- {
6610- uint64_t arg = 0;
6611- LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6612- }
6613- state.addr = 18446744073709551377LLU; // 999999996Q'''''''''''''''
6614- break;
6615- }
6616- case 18446744073709551377LLU: // 999999996Q'''''''''''''''
6617- {
6618- if(!*LOCAL_ACCESS(heap.data, 4LLU, 2LLU))
6619- {
6620- (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4
6621- (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 3
6622- {
6623- state.addr = 18446744073709551376LLU; // 999999996P'''''''''''''''
6624- break;
6625- }
6626- }
6627- /*direct*/*LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = (*LOCAL_ACCESS(heap.data, 4LLU, 2LLU) << 1) + 1LLU;
6628- *LOCAL_ACCESS(heap.data, 4LLU, 2LLU) = heap.data[*LOCAL_ACCESS(heap.data, 4LLU, 2LLU)].elem0;
6629- {
6630- uint64_t arg = 0;
6631- LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6632- }
6633- // ACCUMULATE ARGUMENTS - BEGIN
6634- {
6635- uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 5LLU, 4LLU);
6636- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6637- }
6638- {
6639- uint64_t arg = /*src_______*/*LOCAL_ACCESS(heap.data, 5LLU, 3LLU);
6640- LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6641- }
6642- // ACCUMULATE ARGUMENTS - END
6643- uint64_t return_to = 18446744073709551372LLU;
6644- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
6645- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6646- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
6647- heap.data[0].elem1 = heap.data[0].elem0;
6648- heap.data[0].elem0 = restore;
6649- state.addr = 101193007747052544LLU; // ElemDefCP_
6650- break;
6651- }
6652- case 18446744073709551372LLU: // 999999996L'''''''''''''''
6653- {
6654- state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 5LLU, 4LLU), &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 0LLU)), 7) ? 18446744073709551375LLU : 18446744073709551374LLU;
6655- break;
6656- }
6657- case 18446744073709551375LLU: // 999999996O'''''''''''''''
6658- {
6659- fprintf(stderr, "%s", "pushing par ");
6660- // ACCUMULATE ARGUMENTS - BEGIN
6661- {
6662- uint64_t arg = /*dst_______*/tree_elem_addr(heap.data, 2LLU, LOCAL_ACCESS_ADDR(heap.data, 5LLU, 4LLU), 1LLU);
6663- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6664- }
6665- // ACCUMULATE ARGUMENTS - END
6666- uint64_t return_to = 18446744073709551371LLU;
6667- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6668- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6669- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
6670- heap.data[0].elem1 = heap.data[0].elem0;
6671- heap.data[0].elem0 = restore;
6672- state.addr = 819847183518878432LLU; // reporttype
6673- break;
6674- }
6675- case 18446744073709551371LLU: // 999999996K'''''''''''''''
6676- {
6677- fprintf(stderr, "%s", "\n");
6678- {
6679- fprintf(stderr, "%s\n", "INTERNAL ERROR: out of heap/dynamic in compiler, elemdesfcp - recompile compiler with increased heap-size");
6680- exit(-1);
6681- }
6682- // emitted destructur for type elemdef___
6683- // ACCUMULATE ARGUMENTS - BEGIN
6684- {
6685- uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 5LLU, 4LLU);
6686- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6687- }
6688- // ACCUMULATE ARGUMENTS - END
6689- uint64_t return_to = 18446744073709551370LLU;
6690- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6691- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6692- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
6693- heap.data[0].elem1 = heap.data[0].elem0;
6694- heap.data[0].elem0 = restore;
6695- state.addr = 18446744073709551446LLU; // 999999997V'''''''''''''''
6696- break;
6697- }
6698- case 18446744073709551370LLU: // 999999996J'''''''''''''''
6699- {
6700- // parameter elemdef___ dst_______ goes out of scope
6701- state.addr = 18446744073709551373LLU; // 999999996M'''''''''''''''
6702- break;
6703- }
6704- case 18446744073709551374LLU: // 999999996N'''''''''''''''
6705- {
6706- state.addr = 18446744073709551373LLU; // 999999996M'''''''''''''''
6707- break;
6708- }
6709- case 18446744073709551373LLU: // 999999996M'''''''''''''''
6710- {
6711- (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 5
6712- // parameter-reference elemdef___ src_______ goes out of scope
6713- // parameter-reference list<elemdef___> srcs______ goes out of scope
6714- state.addr = 18446744073709551377LLU; // 999999996Q'''''''''''''''
6715- break;
6716- }
6717- case 18446744073709551376LLU: // 999999996P'''''''''''''''
6718- {
6719- // parameter-reference list<elemdef___> srcs______ goes out of scope
6720- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference srcs______ at 2
6721- // parameter-reference list<elemdef___> dsts______ goes out of scope
6722- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference dsts______ at 1
6723- {
6724- uint64_t baseinfo = heap.data[0].elem1;
6725- struct pair pair = unpair(&heap, &baseinfo);
6726- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
6727- state.addr = pair.elem1;
6728- }
6729- break;
6730- }
6731- case 819859607546145524LLU: // resdefcopy
6732- {
6733- {
6734- uint64_t arg = tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 2LLU, 0LLU), 0LLU);
6735- LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6736- }
6737- {
6738- uint64_t arg = tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU), 1LLU);
6739- LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6740- }
6741- {
6742- uint64_t arg = tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU), 2LLU);
6743- LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6744- }
6745- {
6746- uint64_t arg = tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 5LLU, 1LLU), 0LLU);
6747- LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6748- }
6749- {
6750- uint64_t arg = tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 6LLU, 1LLU), 1LLU);
6751- LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6752- }
6753- {
6754- uint64_t arg = tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 7LLU, 1LLU), 2LLU);
6755- LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6756- }
6757-
6758- // emitted destructur for type type______
6759- // ACCUMULATE ARGUMENTS - BEGIN
6760- {
6761- uint64_t arg = *LOCAL_ACCESS(heap.data, 8LLU, 2LLU);
6762- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6763- }
6764- // ACCUMULATE ARGUMENTS - END
6765- uint64_t return_to = 18446744073709551368LLU;
6766- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0));
6767- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6768- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
6769- heap.data[0].elem1 = heap.data[0].elem0;
6770- heap.data[0].elem0 = restore;
6771- state.addr = 18446744073709551569LLU; // 999999999Q'''''''''''''''
6772- break;
6773- }
6774- case 18446744073709551368LLU: // 999999996H'''''''''''''''
6775- {
6776- // ACCUMULATE ARGUMENTS - BEGIN
6777- {
6778- uint64_t arg = *LOCAL_ACCESS(heap.data, 8LLU, 2LLU);
6779- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6780- }
6781- {
6782- uint64_t arg = /*type1_____*/*LOCAL_ACCESS(heap.data, 8LLU, 5LLU);
6783- LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6784- }
6785- // ACCUMULATE ARGUMENTS - END
6786- uint64_t return_to = 18446744073709551367LLU;
6787- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
6788- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6789- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
6790- heap.data[0].elem1 = heap.data[0].elem0;
6791- heap.data[0].elem0 = restore;
6792- state.addr = 367395560426147840LLU; // TYPECOPY__
6793- break;
6794- }
6795- case 18446744073709551367LLU: // 999999996G'''''''''''''''
6796- {
6797-
6798- *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 8LLU, 3LLU)) = /*idx1______*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 8LLU, 6LLU));
6799-
6800- *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 8LLU, 4LLU)) = /*reference1*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 8LLU, 7LLU));
6801- // parameter-reference u64 reference1 goes out of scope
6802- (void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference reference1 at 8
6803- // parameter-reference u64 idx1______ goes out of scope
6804- (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference idx1______ at 7
6805- // parameter-reference type______ type1_____ goes out of scope
6806- (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type1_____ at 6
6807- // parameter-reference resdest___ __________ goes out of scope
6808- (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 5
6809- // parameter-reference u64 reference0 goes out of scope
6810- (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference reference0 at 4
6811- // parameter-reference u64 idx0______ goes out of scope
6812- (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference idx0______ at 3
6813- // parameter-reference type______ type0_____ goes out of scope
6814- (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type0_____ at 2
6815- // parameter-reference resdest___ __________ goes out of scope
6816- (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1
6817- {
6818- uint64_t baseinfo = heap.data[0].elem1;
6819- struct pair pair = unpair(&heap, &baseinfo);
6820- *access_heap(heap.data, 1/*memory root*/) = pair.elem0;
6821- state.addr = pair.elem1;
6822- }
6823- break;
6824- }
6825- case 325750391286068249LLU: // RESDEFCOPY
6826- {
6827- {
6828- uint64_t arg = tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU), 0LLU);
6829- LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6830- }
6831- {
6832- uint64_t arg = tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 1LLU);
6833- LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6834- }
6835- {
6836- uint64_t arg = tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 4LLU, 1LLU), 2LLU);
6837- LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6838- }
6839- // ACCUMULATE ARGUMENTS - BEGIN
6840- {
6841- uint64_t arg = *LOCAL_ACCESS(heap.data, 5LLU, 0LLU);
6842- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6843- }
6844- {
6845- uint64_t arg = heap.data[0].elem0;
6846- LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6847- }
6848- {
6849- uint64_t arg = 0;
6850- LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6851- }
6852- // ACCUMULATE ARGUMENTS - BEGIN
6853- {
6854- uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 7LLU, 6LLU);
6855- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6856- }
6857- {
6858- uint64_t arg = /*type1_____*/*LOCAL_ACCESS(heap.data, 7LLU, 2LLU);
6859- LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6860- }
6861- // ACCUMULATE ARGUMENTS - END
6862- uint64_t return_to = 18446744073709551364LLU;
6863- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
6864- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6865- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
6866- heap.data[0].elem1 = heap.data[0].elem0;
6867- heap.data[0].elem0 = restore;
6868- state.addr = 367395560426147840LLU; // TYPECOPY__
6869- break;
6870- }
6871- case 18446744073709551364LLU: // 999999996D'''''''''''''''
6872- {
6873- {
6874- uint64_t exchange = LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 7*/;
6875- heap.data[0].elem0 = LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 6*/;
6876-
6877- {
6878- uint64_t arg = exchange;
6879- LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6880- }
6881- }
6882- {
6883- uint64_t arg = heap.data[0].elem0;
6884- LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6885- }
6886- {
6887- uint64_t arg = 0;
6888- LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6889- }
6890- // ACCUMULATE ARGUMENTS - BEGIN
6891- {
6892- uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 7LLU, 6LLU);
6893- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6894- }
6895- {
6896- uint64_t arg = /*idx1______*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 7LLU, 3LLU));
6897- LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6898- }
6899- // ACCUMULATE ARGUMENTS - END
6900- uint64_t return_to = 18446744073709551363LLU;
6901- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
6902- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6903- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
6904- heap.data[0].elem1 = heap.data[0].elem0;
6905- heap.data[0].elem0 = restore;
6906- state.addr = 552446646280519680LLU; // copyu64___
6907- break;
6908- }
6909- case 18446744073709551363LLU: // 999999996C'''''''''''''''
6910- {
6911- {
6912- uint64_t exchange = LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 7*/;
6913- heap.data[0].elem0 = LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 6*/;
6914-
6915- {
6916- uint64_t arg = exchange;
6917- LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6918- }
6919- }
6920- {
6921- uint64_t arg = heap.data[0].elem0;
6922- LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6923- }
6924- {
6925- uint64_t arg = 0;
6926- LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg);
6927- }
6928- // ACCUMULATE ARGUMENTS - BEGIN
6929- {
6930- uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 7LLU, 6LLU);
6931- LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6932- }
6933- {
6934- uint64_t arg = /*reference1*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 7LLU, 4LLU));
6935- LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6936- }
6937- // ACCUMULATE ARGUMENTS - END
6938- uint64_t return_to = 18446744073709551362LLU;
6939- const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0));
6940- uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);
6941- *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo;
6942- heap.data[0].elem1 = heap.data[0].elem0;
6943- heap.data[0].elem0 = restore;
6944- state.addr = 552446646280519680LLU; // copyu64___
6945- break;
6946- }
6947- case 18446744073709551362LLU: // 999999996B'''''''''''''''
6948- {
6949- {
6950- uint64_t exchange = LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 7*/;
6951- heap.data[0].elem0 = LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 6*/;
6952-
6953- {
6954- uint64_t arg = exchange;
6955- LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);
6956-