Revision | 979 (tree) |
---|---|
Time | 2020-04-26 08:50:48 |
Author | jakobthomsen |
assignment copies primitives, moves compounds
@@ -560,9 +560,9 @@ | ||
560 | 560 | LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
561 | 561 | } |
562 | 562 | *LOCAL_ACCESS(heap.data, 3LLU, 2LLU) = /*value_____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU)); |
563 | - swap(&*LOCAL_ACCESS(heap.data, 3LLU, 2LLU), &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU))); // result | |
563 | + *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU)) = /*result____*/*LOCAL_ACCESS(heap.data, 3LLU, 2LLU); | |
564 | 564 | // variable u64 result____ goes out of scope |
565 | - // (uninitialized -> no destructor-call) | |
565 | + // emitted destructur for type u64 | |
566 | 566 | (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference result____ at 3 |
567 | 567 | // parameter-reference u64 value_____ goes out of scope |
568 | 568 | (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference value_____ at 2 |
@@ -583,9 +583,9 @@ | ||
583 | 583 | LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
584 | 584 | } |
585 | 585 | *LOCAL_ACCESS(heap.data, 3LLU, 2LLU) = /*value_____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU)); |
586 | - swap(&*LOCAL_ACCESS(heap.data, 3LLU, 2LLU), &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU))); // result | |
586 | + *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU)) = /*result____*/*LOCAL_ACCESS(heap.data, 3LLU, 2LLU); | |
587 | 587 | // variable u64 result____ goes out of scope |
588 | - // (uninitialized -> no destructor-call) | |
588 | + // emitted destructur for type u64 | |
589 | 589 | (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference result____ at 3 |
590 | 590 | // parameter-reference u64 value_____ goes out of scope |
591 | 591 | (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference value_____ at 2 |
@@ -644,9 +644,9 @@ | ||
644 | 644 | } |
645 | 645 | case 18446744073709551613LLU: // 9999999997''''''''''''''' |
646 | 646 | { |
647 | - swap(&*LOCAL_ACCESS(heap.data, 3LLU, 2LLU), &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU))); // result | |
647 | + *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU)) = /*result____*/*LOCAL_ACCESS(heap.data, 3LLU, 2LLU); | |
648 | 648 | // variable u64 result____ goes out of scope |
649 | - // (uninitialized -> no destructor-call) | |
649 | + // emitted destructur for type u64 | |
650 | 650 | (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference result____ at 3 |
651 | 651 | // parameter-reference u64 lookahead_ goes out of scope |
652 | 652 | (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference lookahead_ at 2 |
@@ -678,9 +678,9 @@ | ||
678 | 678 | } |
679 | 679 | case 18446744073709551611LLU: // 9999999995''''''''''''''' |
680 | 680 | { |
681 | - swap(&*LOCAL_ACCESS(heap.data, 3LLU, 2LLU), &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU))); // result | |
681 | + *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU)) = /*result____*/*LOCAL_ACCESS(heap.data, 3LLU, 2LLU); | |
682 | 682 | // variable u64 result____ goes out of scope |
683 | - // (uninitialized -> no destructor-call) | |
683 | + // emitted destructur for type u64 | |
684 | 684 | (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference result____ at 3 |
685 | 685 | // parameter-reference u64 lookahead_ goes out of scope |
686 | 686 | (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference lookahead_ at 2 |
@@ -912,9 +912,9 @@ | ||
912 | 912 | } |
913 | 913 | case 18446744073709551598LLU: // 999999999s''''''''''''''' |
914 | 914 | { |
915 | - swap(&*LOCAL_ACCESS(heap.data, 3LLU, 2LLU), &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU))); // result | |
915 | + *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU)) = /*result____*/*LOCAL_ACCESS(heap.data, 3LLU, 2LLU); | |
916 | 916 | // variable u64 result____ goes out of scope |
917 | - // (uninitialized -> no destructor-call) | |
917 | + // emitted destructur for type u64 | |
918 | 918 | (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference result____ at 3 |
919 | 919 | // parameter-reference u64 lookahead_ goes out of scope |
920 | 920 | (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference lookahead_ at 2 |
@@ -985,9 +985,9 @@ | ||
985 | 985 | } |
986 | 986 | case 18446744073709551589LLU: // 999999999j''''''''''''''' |
987 | 987 | { |
988 | - swap(&*LOCAL_ACCESS(heap.data, 3LLU, 2LLU), &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU))); // result | |
988 | + *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU)) = /*result____*/*LOCAL_ACCESS(heap.data, 3LLU, 2LLU); | |
989 | 989 | // variable u64 result____ goes out of scope |
990 | - // (uninitialized -> no destructor-call) | |
990 | + // emitted destructur for type u64 | |
991 | 991 | (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference result____ at 3 |
992 | 992 | // parameter-reference u64 lookahead_ goes out of scope |
993 | 993 | (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference lookahead_ at 2 |
@@ -1110,9 +1110,9 @@ | ||
1110 | 1110 | } |
1111 | 1111 | case 18446744073709551578LLU: // 999999999Z''''''''''''''' |
1112 | 1112 | { |
1113 | - swap(&*LOCAL_ACCESS(heap.data, 3LLU, 2LLU), &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU))); // result | |
1113 | + *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU)) = /*result____*/*LOCAL_ACCESS(heap.data, 3LLU, 2LLU); | |
1114 | 1114 | // variable u64 result____ goes out of scope |
1115 | - // (uninitialized -> no destructor-call) | |
1115 | + // emitted destructur for type u64 | |
1116 | 1116 | (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference result____ at 3 |
1117 | 1117 | // parameter-reference u64 lookahead_ goes out of scope |
1118 | 1118 | (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference lookahead_ at 2 |
@@ -1182,9 +1182,9 @@ | ||
1182 | 1182 | } |
1183 | 1183 | case 18446744073709551571LLU: // 999999999S''''''''''''''' |
1184 | 1184 | { |
1185 | - swap(&*LOCAL_ACCESS(heap.data, 3LLU, 2LLU), &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU))); // result | |
1185 | + *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU)) = /*result____*/*LOCAL_ACCESS(heap.data, 3LLU, 2LLU); | |
1186 | 1186 | // variable u64 result____ goes out of scope |
1187 | - // (uninitialized -> no destructor-call) | |
1187 | + // emitted destructur for type u64 | |
1188 | 1188 | (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference result____ at 3 |
1189 | 1189 | // parameter-reference u64 lookahead_ goes out of scope |
1190 | 1190 | (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference lookahead_ at 2 |
@@ -7275,9 +7275,9 @@ | ||
7275 | 7275 | LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
7276 | 7276 | } |
7277 | 7277 | *LOCAL_ACCESS(heap.data, 3LLU, 2LLU) = /*fn________*/*access_heap(heap.data, tree_elem_addr(heap.data, 7LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 4LLU)); |
7278 | - swap(&*LOCAL_ACCESS(heap.data, 3LLU, 2LLU), &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU))); // result | |
7278 | + *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU)) = /*result____*/*LOCAL_ACCESS(heap.data, 3LLU, 2LLU); | |
7279 | 7279 | // variable u64 result____ goes out of scope |
7280 | - // (uninitialized -> no destructor-call) | |
7280 | + // emitted destructur for type u64 | |
7281 | 7281 | (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference result____ at 3 |
7282 | 7282 | // parameter-reference function__ fn________ goes out of scope |
7283 | 7283 | (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference fn________ at 2 |
@@ -7297,9 +7297,9 @@ | ||
7297 | 7297 | LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
7298 | 7298 | } |
7299 | 7299 | *LOCAL_ACCESS(heap.data, 3LLU, 2LLU) = /*fn________*/*access_heap(heap.data, tree_elem_addr(heap.data, 7LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 5LLU)); |
7300 | - swap(&*LOCAL_ACCESS(heap.data, 3LLU, 2LLU), &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU))); // result | |
7300 | + *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU)) = /*result____*/*LOCAL_ACCESS(heap.data, 3LLU, 2LLU); | |
7301 | 7301 | // variable u64 result____ goes out of scope |
7302 | - // (uninitialized -> no destructor-call) | |
7302 | + // emitted destructur for type u64 | |
7303 | 7303 | (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference result____ at 3 |
7304 | 7304 | // parameter-reference function__ fn________ goes out of scope |
7305 | 7305 | (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference fn________ at 2 |
@@ -7319,9 +7319,9 @@ | ||
7319 | 7319 | LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
7320 | 7320 | } |
7321 | 7321 | *LOCAL_ACCESS(heap.data, 3LLU, 2LLU) = /*fn________*/*access_heap(heap.data, tree_elem_addr(heap.data, 7LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 6LLU)); |
7322 | - swap(&*LOCAL_ACCESS(heap.data, 3LLU, 2LLU), &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU))); // result | |
7322 | + *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU)) = /*result____*/*LOCAL_ACCESS(heap.data, 3LLU, 2LLU); | |
7323 | 7323 | // variable u64 result____ goes out of scope |
7324 | - // (uninitialized -> no destructor-call) | |
7324 | + // emitted destructur for type u64 | |
7325 | 7325 | (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference result____ at 3 |
7326 | 7326 | // parameter-reference function__ fn________ goes out of scope |
7327 | 7327 | (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference fn________ at 2 |
@@ -12099,9 +12099,9 @@ | ||
12099 | 12099 | LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
12100 | 12100 | } |
12101 | 12101 | *LOCAL_ACCESS(heap.data, 3LLU, 2LLU) = /*fn________*/*access_heap(heap.data, tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU), 2LLU)); |
12102 | - swap(&*LOCAL_ACCESS(heap.data, 3LLU, 2LLU), &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU))); // result | |
12102 | + *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU)) = /*result____*/*LOCAL_ACCESS(heap.data, 3LLU, 2LLU); | |
12103 | 12103 | // variable u64 result____ goes out of scope |
12104 | - // (uninitialized -> no destructor-call) | |
12104 | + // emitted destructur for type u64 | |
12105 | 12105 | (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference result____ at 3 |
12106 | 12106 | // parameter-reference defidfn___ fn________ goes out of scope |
12107 | 12107 | (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference fn________ at 2 |
@@ -16353,12 +16353,12 @@ | ||
16353 | 16353 | } |
16354 | 16354 | case 18446744073709550618LLU: // 99999999uZ''''''''''''''' |
16355 | 16355 | { |
16356 | - swap(&*LOCAL_ACCESS(heap.data, 6LLU, 4LLU), &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 6LLU, 0LLU))); // result | |
16356 | + *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 6LLU, 0LLU)) = /*sizeonheap*/*LOCAL_ACCESS(heap.data, 6LLU, 4LLU); | |
16357 | 16357 | // variable u64 notfound__ goes out of scope |
16358 | 16358 | // emitted destructur for type u64 |
16359 | 16359 | (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference notfound__ at 6 |
16360 | 16360 | // variable u64 sizeonheap goes out of scope |
16361 | - // (uninitialized -> no destructor-call) | |
16361 | + // emitted destructur for type u64 | |
16362 | 16362 | (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference sizeonheap at 5 |
16363 | 16363 | // parameter-reference u64 id________ goes out of scope |
16364 | 16364 | (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id________ at 4 |
@@ -21129,12 +21129,12 @@ | ||
21129 | 21129 | } |
21130 | 21130 | case 18446744073709550338LLU: // 99999999qB''''''''''''''' |
21131 | 21131 | { |
21132 | - swap(&*LOCAL_ACCESS(heap.data, 4LLU, 2LLU), &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU))); // result | |
21132 | + *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU)) = /*result____*/*LOCAL_ACCESS(heap.data, 4LLU, 2LLU); | |
21133 | 21133 | // variable u64 sym_______ goes out of scope |
21134 | 21134 | // emitted destructur for type u64 |
21135 | 21135 | (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference sym_______ at 4 |
21136 | 21136 | // variable u64 result____ goes out of scope |
21137 | - // (uninitialized -> no destructor-call) | |
21137 | + // emitted destructur for type u64 | |
21138 | 21138 | (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference result____ at 3 |
21139 | 21139 | // parameter-reference u64 c_________ goes out of scope |
21140 | 21140 | (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference c_________ at 2 |
@@ -21440,12 +21440,12 @@ | ||
21440 | 21440 | } |
21441 | 21441 | case 18446744073709550309LLU: // 99999999pj''''''''''''''' |
21442 | 21442 | { |
21443 | - swap(&*LOCAL_ACCESS(heap.data, 4LLU, 2LLU), &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU))); // result | |
21443 | + *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU)) = /*result____*/*LOCAL_ACCESS(heap.data, 4LLU, 2LLU); | |
21444 | 21444 | // variable u64 sym_______ goes out of scope |
21445 | 21445 | // emitted destructur for type u64 |
21446 | 21446 | (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference sym_______ at 4 |
21447 | 21447 | // variable u64 result____ goes out of scope |
21448 | - // (uninitialized -> no destructor-call) | |
21448 | + // emitted destructur for type u64 | |
21449 | 21449 | (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference result____ at 3 |
21450 | 21450 | // parameter-reference u64 c_________ goes out of scope |
21451 | 21451 | (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference c_________ at 2 |
@@ -73802,9 +73802,9 @@ | ||
73802 | 73802 | } |
73803 | 73803 | case 18446744073709546900LLU: // 999999980T''''''''''''''' |
73804 | 73804 | { |
73805 | - swap(&*LOCAL_ACCESS(heap.data, 25LLU, 24LLU), &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 25LLU, 0LLU))); // result | |
73805 | + *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 25LLU, 0LLU)) = /*called____*/*LOCAL_ACCESS(heap.data, 25LLU, 24LLU); | |
73806 | 73806 | // variable u64 called____ goes out of scope |
73807 | - // (uninitialized -> no destructor-call) | |
73807 | + // emitted destructur for type u64 | |
73808 | 73808 | (void)LOCAL_POP_MOVE(&heap, 25LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference called____ at 25 |
73809 | 73809 | // parameter-reference u64 remainheap goes out of scope |
73810 | 73810 | (void)LOCAL_POP_MOVE(&heap, 24LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference remainheap at 24 |
@@ -78986,12 +78986,6 @@ | ||
78986 | 78986 | fprintf(stdout, "%s", " = "); |
78987 | 78987 | fprintf(stdout, "%llu", (unsigned long long)/*nr________*/*LOCAL_ACCESS(heap.data, 22LLU, 20LLU)); |
78988 | 78988 | fprintf(stdout, "%s", ";"); |
78989 | - ungetc((int)/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 22LLU, 11LLU)), stdin); | |
78990 | - if(';' != (char)getchar()) | |
78991 | - { | |
78992 | - fprintf(stderr, "match failed at char %c\n", (char)59LLU); | |
78993 | - exit(-1); | |
78994 | - } | |
78995 | 78989 | state.addr = 18446744073709546587LLU; // 99999998v$''''''''''''''' |
78996 | 78990 | break; |
78997 | 78991 | } |
@@ -79852,13 +79846,49 @@ | ||
79852 | 79846 | } |
79853 | 79847 | case 18446744073709546542LLU: // 99999998us''''''''''''''' |
79854 | 79848 | { |
79849 | + { | |
79850 | + uint64_t arg = 0; | |
79851 | + LOCAL_PUSH_MOVE(&heap, 21, &(heap.data[0].elem1)/*address of current closure*/, &arg); | |
79852 | + } | |
79855 | 79853 | // ACCUMULATE ARGUMENTS - BEGIN |
79856 | 79854 | { |
79855 | + uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 22LLU, 21LLU); | |
79856 | + LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
79857 | + } | |
79858 | + { | |
79859 | + uint64_t arg = /*result____*/tree_elem_addr(heap.data, 3LLU, LOCAL_ACCESS_ADDR(heap.data, 22LLU, 20LLU), 0LLU); | |
79860 | + LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
79861 | + } | |
79862 | + // ACCUMULATE ARGUMENTS - END | |
79863 | + uint64_t return_to = 18446744073709546519LLU; | |
79864 | + const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); | |
79865 | + uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); | |
79866 | + *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; | |
79867 | + heap.data[0].elem1 = heap.data[0].elem0; | |
79868 | + heap.data[0].elem0 = restore; | |
79869 | + state.addr = 661640243165790208LLU; // islist____ | |
79870 | + break; | |
79871 | + } | |
79872 | + case 18446744073709546519LLU: // 99999998uW''''''''''''''' | |
79873 | + { | |
79874 | + state.addr = 18446744073709546520LLU; // 99999998uX''''''''''''''' | |
79875 | + break; | |
79876 | + } | |
79877 | + case 18446744073709546520LLU: // 99999998uX''''''''''''''' | |
79878 | + { | |
79879 | + state.addr = *LOCAL_ACCESS(heap.data, 22LLU, 21LLU) ? 18446744073709546522LLU : 18446744073709546521LLU; | |
79880 | + (void)LOCAL_POP_MOVE(&heap, 22LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 22 | |
79881 | + break; | |
79882 | + } | |
79883 | + case 18446744073709546522LLU: // 99999998uZ''''''''''''''' | |
79884 | + { | |
79885 | + // ACCUMULATE ARGUMENTS - BEGIN | |
79886 | + { | |
79857 | 79887 | uint64_t arg = /*def_id____*/*LOCAL_ACCESS(heap.data, 21LLU, 0LLU); |
79858 | 79888 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
79859 | 79889 | } |
79860 | 79890 | // ACCUMULATE ARGUMENTS - END |
79861 | - uint64_t return_to = 18446744073709546521LLU; | |
79891 | + uint64_t return_to = 18446744073709546517LLU; | |
79862 | 79892 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
79863 | 79893 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
79864 | 79894 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -79867,12 +79897,12 @@ | ||
79867 | 79897 | state.addr = 819847183515949359LLU; // reportinit |
79868 | 79898 | break; |
79869 | 79899 | } |
79870 | - case 18446744073709546521LLU: // 99999998uY''''''''''''''' | |
79900 | + case 18446744073709546517LLU: // 99999998uU''''''''''''''' | |
79871 | 79901 | { |
79872 | - state.addr = 18446744073709546522LLU; // 99999998uZ''''''''''''''' | |
79902 | + state.addr = 18446744073709546518LLU; // 99999998uV''''''''''''''' | |
79873 | 79903 | break; |
79874 | 79904 | } |
79875 | - case 18446744073709546522LLU: // 99999998uZ''''''''''''''' | |
79905 | + case 18446744073709546518LLU: // 99999998uV''''''''''''''' | |
79876 | 79906 | { |
79877 | 79907 | fprintf(stderr, "%s", "can only assign to u64 but found "); |
79878 | 79908 | // ACCUMULATE ARGUMENTS - BEGIN |
@@ -79881,7 +79911,7 @@ | ||
79881 | 79911 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
79882 | 79912 | } |
79883 | 79913 | // ACCUMULATE ARGUMENTS - END |
79884 | - uint64_t return_to = 18446744073709546519LLU; | |
79914 | + uint64_t return_to = 18446744073709546515LLU; | |
79885 | 79915 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
79886 | 79916 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
79887 | 79917 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -79890,28 +79920,430 @@ | ||
79890 | 79920 | state.addr = 819847183518878432LLU; // reporttype |
79891 | 79921 | break; |
79892 | 79922 | } |
79893 | - case 18446744073709546519LLU: // 99999998uW''''''''''''''' | |
79923 | + case 18446744073709546515LLU: // 99999998uS''''''''''''''' | |
79894 | 79924 | { |
79895 | - state.addr = 18446744073709546520LLU; // 99999998uX''''''''''''''' | |
79925 | + state.addr = 18446744073709546516LLU; // 99999998uT''''''''''''''' | |
79896 | 79926 | break; |
79897 | 79927 | } |
79898 | - case 18446744073709546520LLU: // 99999998uX''''''''''''''' | |
79928 | + case 18446744073709546516LLU: // 99999998uT''''''''''''''' | |
79899 | 79929 | { |
79900 | 79930 | { |
79901 | 79931 | fprintf(stderr, "%s\n", ""); |
79902 | 79932 | exit(-1); |
79903 | 79933 | } |
79934 | + heap.availilable_size_for_dynamic_objects += 0LLU; | |
79935 | + heap.availilable_size_for_dynamic_objects += 0LLU; | |
79936 | + state.addr = 18446744073709546514LLU; // 99999998uR''''''''''''''' | |
79937 | + break; | |
79938 | + } | |
79939 | + case 18446744073709546521LLU: // 99999998uY''''''''''''''' | |
79940 | + { | |
79941 | + state.addr = 18446744073709546514LLU; // 99999998uR''''''''''''''' | |
79942 | + break; | |
79943 | + } | |
79944 | + case 18446744073709546514LLU: // 99999998uR''''''''''''''' | |
79945 | + { | |
79946 | + fprintf(stdout, "%s", "\n swap(&"); | |
79947 | + { | |
79948 | + uint64_t arg = 0; | |
79949 | + LOCAL_PUSH_MOVE(&heap, 21, &(heap.data[0].elem1)/*address of current closure*/, &arg); | |
79950 | + } | |
79951 | + // ACCUMULATE ARGUMENTS - BEGIN | |
79952 | + { | |
79953 | + uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 22LLU, 21LLU); | |
79954 | + LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
79955 | + } | |
79956 | + // ACCUMULATE ARGUMENTS - END | |
79957 | + uint64_t return_to = 18446744073709546512LLU; | |
79958 | + const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); | |
79959 | + uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); | |
79960 | + *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; | |
79961 | + heap.data[0].elem1 = heap.data[0].elem0; | |
79962 | + heap.data[0].elem0 = restore; | |
79963 | + state.addr = 861504796319285248LLU; // typeu64___ | |
79964 | + break; | |
79965 | + } | |
79966 | + case 18446744073709546512LLU: // 99999998uP''''''''''''''' | |
79967 | + { | |
79968 | + state.addr = 18446744073709546513LLU; // 99999998uQ''''''''''''''' | |
79969 | + break; | |
79970 | + } | |
79971 | + case 18446744073709546513LLU: // 99999998uQ''''''''''''''' | |
79972 | + { | |
79973 | + { | |
79974 | + uint64_t arg = 0; | |
79975 | + LOCAL_PUSH_MOVE(&heap, 22, &(heap.data[0].elem1)/*address of current closure*/, &arg); | |
79976 | + } | |
79977 | + *LOCAL_ACCESS(heap.data, 23LLU, 22LLU) = 0; | |
79978 | + { | |
79979 | + uint64_t arg = 0; | |
79980 | + LOCAL_PUSH_MOVE(&heap, 23, &(heap.data[0].elem1)/*address of current closure*/, &arg); | |
79981 | + } | |
79982 | + *LOCAL_ACCESS(heap.data, 24LLU, 23LLU) = 0; | |
79983 | + { | |
79984 | + uint64_t arg = 0; | |
79985 | + LOCAL_PUSH_MOVE(&heap, 24, &(heap.data[0].elem1)/*address of current closure*/, &arg); | |
79986 | + } | |
79987 | + *LOCAL_ACCESS(heap.data, 25LLU, 24LLU) = 0; | |
79988 | + { | |
79989 | + uint64_t arg = 0; | |
79990 | + LOCAL_PUSH_MOVE(&heap, 25, &(heap.data[0].elem1)/*address of current closure*/, &arg); | |
79991 | + } | |
79992 | + *LOCAL_ACCESS(heap.data, 26LLU, 25LLU) = 0; | |
79993 | + { | |
79994 | + uint64_t arg = 0; | |
79995 | + LOCAL_PUSH_MOVE(&heap, 26, &(heap.data[0].elem1)/*address of current closure*/, &arg); | |
79996 | + } | |
79997 | + *LOCAL_ACCESS(heap.data, 27LLU, 26LLU) = 0; | |
79998 | + { | |
79999 | + uint64_t arg = 0; | |
80000 | + LOCAL_PUSH_MOVE(&heap, 27, &(heap.data[0].elem1)/*address of current closure*/, &arg); | |
80001 | + } | |
80002 | + *LOCAL_ACCESS(heap.data, 28LLU, 27LLU) = 0; | |
80003 | + { | |
80004 | + uint64_t arg = 0; | |
80005 | + LOCAL_PUSH_MOVE(&heap, 28, &(heap.data[0].elem1)/*address of current closure*/, &arg); | |
80006 | + } | |
80007 | + *LOCAL_ACCESS(heap.data, 29LLU, 28LLU) = 0; | |
80008 | + // ACCUMULATE ARGUMENTS - BEGIN | |
80009 | + { | |
80010 | + uint64_t arg = /*def_id____*/*LOCAL_ACCESS(heap.data, 29LLU, 0LLU); | |
80011 | + LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
80012 | + } | |
80013 | + { | |
80014 | + uint64_t arg = /*blocklist_*/*LOCAL_ACCESS(heap.data, 29LLU, 8LLU); | |
80015 | + LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
80016 | + } | |
80017 | + { | |
80018 | + uint64_t arg = /*varlist___*/*LOCAL_ACCESS(heap.data, 29LLU, 9LLU); | |
80019 | + LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
80020 | + } | |
80021 | + { | |
80022 | + uint64_t arg = /*callee_id_*/LOCAL_ACCESS_ADDR(heap.data, 29LLU, 19LLU); | |
80023 | + LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
80024 | + } | |
80025 | + { | |
80026 | + uint64_t arg = /*idx_______*/LOCAL_ACCESS_ADDR(heap.data, 29LLU, 26LLU); | |
80027 | + LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
80028 | + } | |
80029 | + { | |
80030 | + uint64_t arg = /*INDIRECT__*/LOCAL_ACCESS_ADDR(heap.data, 29LLU, 24LLU); | |
80031 | + LOCAL_PUSH_MOVE(&heap, 5LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
80032 | + } | |
80033 | + { | |
80034 | + uint64_t arg = /*typesrc___*/LOCAL_ACCESS_ADDR(heap.data, 29LLU, 21LLU); | |
80035 | + LOCAL_PUSH_MOVE(&heap, 6LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
80036 | + } | |
80037 | + { | |
80038 | + uint64_t arg = /*mutable___*/LOCAL_ACCESS_ADDR(heap.data, 29LLU, 23LLU); | |
80039 | + LOCAL_PUSH_MOVE(&heap, 7LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
80040 | + } | |
80041 | + { | |
80042 | + uint64_t arg = /*parameter_*/LOCAL_ACCESS_ADDR(heap.data, 29LLU, 25LLU); | |
80043 | + LOCAL_PUSH_MOVE(&heap, 8LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
80044 | + } | |
80045 | + { | |
80046 | + uint64_t arg = /*init1_____*/LOCAL_ACCESS_ADDR(heap.data, 29LLU, 22LLU); | |
80047 | + LOCAL_PUSH_MOVE(&heap, 9LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
80048 | + } | |
80049 | + { | |
80050 | + uint64_t arg = /*optelem___*/LOCAL_ACCESS_ADDR(heap.data, 29LLU, 27LLU); | |
80051 | + LOCAL_PUSH_MOVE(&heap, 10LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
80052 | + } | |
80053 | + { | |
80054 | + uint64_t arg = /*consume___*/LOCAL_ACCESS_ADDR(heap.data, 29LLU, 28LLU); | |
80055 | + LOCAL_PUSH_MOVE(&heap, 11LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
80056 | + } | |
80057 | + // ACCUMULATE ARGUMENTS - END | |
80058 | + uint64_t return_to = 18446744073709546509LLU; | |
80059 | + const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 12LLU, 0/*address of closure-in-construction*/, 0)); | |
80060 | + uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); | |
80061 | + *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 12LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; | |
80062 | + heap.data[0].elem1 = heap.data[0].elem0; | |
80063 | + heap.data[0].elem0 = restore; | |
80064 | + state.addr = 604790753280317473LLU; // findvarref | |
80065 | + break; | |
80066 | + } | |
80067 | + case 18446744073709546509LLU: // 99999998uM''''''''''''''' | |
80068 | + { | |
80069 | + state.addr = 18446744073709546510LLU; // 99999998uN''''''''''''''' | |
80070 | + break; | |
80071 | + } | |
80072 | + case 18446744073709546510LLU: // 99999998uN''''''''''''''' | |
80073 | + { | |
80074 | + // ACCUMULATE ARGUMENTS - BEGIN | |
80075 | + { | |
80076 | + uint64_t arg = /*defargcnt_*/*LOCAL_ACCESS(heap.data, 29LLU, 12LLU); | |
80077 | + LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
80078 | + } | |
80079 | + { | |
80080 | + uint64_t arg = /*defbodysz_*/*LOCAL_ACCESS(heap.data, 29LLU, 13LLU); | |
80081 | + LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
80082 | + } | |
80083 | + { | |
80084 | + uint64_t arg = /*remainsize*/*LOCAL_ACCESS(heap.data, 29LLU, 14LLU); | |
80085 | + LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
80086 | + } | |
80087 | + { | |
80088 | + uint64_t arg = /*idx_______*/LOCAL_ACCESS_ADDR(heap.data, 29LLU, 26LLU); | |
80089 | + LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
80090 | + } | |
80091 | + { | |
80092 | + uint64_t arg = /*INDIRECT__*/LOCAL_ACCESS_ADDR(heap.data, 29LLU, 24LLU); | |
80093 | + LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
80094 | + } | |
80095 | + // ACCUMULATE ARGUMENTS - END | |
80096 | + uint64_t return_to = 18446744073709546507LLU; | |
80097 | + const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)); | |
80098 | + uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); | |
80099 | + *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; | |
80100 | + heap.data[0].elem1 = heap.data[0].elem0; | |
80101 | + heap.data[0].elem0 = restore; | |
80102 | + state.addr = 587881357514113024LLU; // emitpar___ | |
80103 | + break; | |
80104 | + } | |
80105 | + case 18446744073709546507LLU: // 99999998uK''''''''''''''' | |
80106 | + { | |
80107 | + state.addr = 18446744073709546508LLU; // 99999998uL''''''''''''''' | |
80108 | + break; | |
80109 | + } | |
80110 | + case 18446744073709546508LLU: // 99999998uL''''''''''''''' | |
80111 | + { | |
80112 | + // variable u64 consume___ goes out of scope | |
80113 | + // emitted destructur for type u64 | |
80114 | + (void)LOCAL_POP_MOVE(&heap, 29LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference consume___ at 29 | |
80115 | + // variable u64 optelem___ goes out of scope | |
80116 | + // emitted destructur for type u64 | |
80117 | + (void)LOCAL_POP_MOVE(&heap, 28LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference optelem___ at 28 | |
80118 | + state.addr = 18446744073709546511LLU; // 99999998uO''''''''''''''' | |
80119 | + break; | |
80120 | + } | |
80121 | + case 18446744073709546511LLU: // 99999998uO''''''''''''''' | |
80122 | + { | |
80123 | + // ACCUMULATE ARGUMENTS - BEGIN | |
80124 | + { | |
80125 | + uint64_t arg = /*def_id____*/*LOCAL_ACCESS(heap.data, 27LLU, 0LLU); | |
80126 | + LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
80127 | + } | |
80128 | + { | |
80129 | + uint64_t arg = /*callee_id_*/LOCAL_ACCESS_ADDR(heap.data, 27LLU, 19LLU); | |
80130 | + LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
80131 | + } | |
80132 | + { | |
80133 | + uint64_t arg = /*INDIRECT__*/LOCAL_ACCESS_ADDR(heap.data, 27LLU, 24LLU); | |
80134 | + LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
80135 | + } | |
80136 | + { | |
80137 | + uint64_t arg = /*mutable___*/LOCAL_ACCESS_ADDR(heap.data, 27LLU, 23LLU); | |
80138 | + LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
80139 | + } | |
80140 | + { | |
80141 | + uint64_t arg = /*parameter_*/LOCAL_ACCESS_ADDR(heap.data, 27LLU, 25LLU); | |
80142 | + LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
80143 | + } | |
80144 | + // ACCUMULATE ARGUMENTS - END | |
80145 | + uint64_t return_to = 18446744073709546505LLU; | |
80146 | + const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)); | |
80147 | + uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); | |
80148 | + *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; | |
80149 | + heap.data[0].elem1 = heap.data[0].elem0; | |
80150 | + heap.data[0].elem0 = restore; | |
80151 | + state.addr = 842862227159939072LLU; // swappable_ | |
80152 | + break; | |
80153 | + } | |
80154 | + case 18446744073709546505LLU: // 99999998uI''''''''''''''' | |
80155 | + { | |
80156 | + state.addr = 18446744073709546506LLU; // 99999998uJ''''''''''''''' | |
80157 | + break; | |
80158 | + } | |
80159 | + case 18446744073709546506LLU: // 99999998uJ''''''''''''''' | |
80160 | + { | |
80161 | + { | |
80162 | + uint64_t arg = 0; | |
80163 | + LOCAL_PUSH_MOVE(&heap, 27, &(heap.data[0].elem1)/*address of current closure*/, &arg); | |
80164 | + } | |
80165 | + *LOCAL_ACCESS(heap.data, 28LLU, 27LLU) = 819865187908583424; | |
80166 | + // ACCUMULATE ARGUMENTS - BEGIN | |
80167 | + { | |
80168 | + uint64_t arg = /*def_id____*/*LOCAL_ACCESS(heap.data, 28LLU, 0LLU); | |
80169 | + LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
80170 | + } | |
80171 | + { | |
80172 | + uint64_t arg = /*info______*/LOCAL_ACCESS_ADDR(heap.data, 28LLU, 27LLU); | |
80173 | + LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
80174 | + } | |
80175 | + { | |
80176 | + uint64_t arg = /*init1_____*/LOCAL_ACCESS_ADDR(heap.data, 28LLU, 22LLU); | |
80177 | + LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
80178 | + } | |
80179 | + { | |
80180 | + uint64_t arg = /*callee_id_*/LOCAL_ACCESS_ADDR(heap.data, 28LLU, 19LLU); | |
80181 | + LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
80182 | + } | |
80183 | + // ACCUMULATE ARGUMENTS - END | |
80184 | + uint64_t return_to = 18446744073709546503LLU; | |
80185 | + const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); | |
80186 | + uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); | |
80187 | + *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; | |
80188 | + heap.data[0].elem1 = heap.data[0].elem0; | |
80189 | + heap.data[0].elem0 = restore; | |
80190 | + state.addr = 660220410725010287LLU; // initassert | |
80191 | + break; | |
80192 | + } | |
80193 | + case 18446744073709546503LLU: // 99999998uG''''''''''''''' | |
80194 | + { | |
80195 | + state.addr = 18446744073709546504LLU; // 99999998uH''''''''''''''' | |
80196 | + break; | |
80197 | + } | |
80198 | + case 18446744073709546504LLU: // 99999998uH''''''''''''''' | |
80199 | + { | |
80200 | + // ACCUMULATE ARGUMENTS - BEGIN | |
80201 | + { | |
80202 | + uint64_t arg = /*def_id____*/*LOCAL_ACCESS(heap.data, 28LLU, 0LLU); | |
80203 | + LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
80204 | + } | |
80205 | + { | |
80206 | + uint64_t arg = /*blocklist_*/*LOCAL_ACCESS(heap.data, 28LLU, 8LLU); | |
80207 | + LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
80208 | + } | |
80209 | + { | |
80210 | + uint64_t arg = /*varlist___*/*LOCAL_ACCESS(heap.data, 28LLU, 9LLU); | |
80211 | + LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
80212 | + } | |
80213 | + { | |
80214 | + uint64_t arg = /*callee_id_*/LOCAL_ACCESS_ADDR(heap.data, 28LLU, 19LLU); | |
80215 | + LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
80216 | + } | |
80217 | + // ACCUMULATE ARGUMENTS - END | |
80218 | + uint64_t return_to = 18446744073709546501LLU; | |
80219 | + const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); | |
80220 | + uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); | |
80221 | + *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; | |
80222 | + heap.data[0].elem1 = heap.data[0].elem0; | |
80223 | + heap.data[0].elem0 = restore; | |
80224 | + state.addr = 732615645798520865LLU; // movevarref | |
80225 | + break; | |
80226 | + } | |
80227 | + case 18446744073709546501LLU: // 99999998uE''''''''''''''' | |
80228 | + { | |
80229 | + state.addr = 18446744073709546502LLU; // 99999998uF''''''''''''''' | |
80230 | + break; | |
80231 | + } | |
80232 | + case 18446744073709546502LLU: // 99999998uF''''''''''''''' | |
80233 | + { | |
80234 | + // ACCUMULATE ARGUMENTS - BEGIN | |
80235 | + { | |
80236 | + uint64_t arg = /*def_id____*/*LOCAL_ACCESS(heap.data, 28LLU, 0LLU); | |
80237 | + LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
80238 | + } | |
80239 | + { | |
80240 | + uint64_t arg = /*result____*/tree_elem_addr(heap.data, 3LLU, LOCAL_ACCESS_ADDR(heap.data, 28LLU, 20LLU), 0LLU); | |
80241 | + LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
80242 | + } | |
80243 | + { | |
80244 | + uint64_t arg = /*typesrc___*/LOCAL_ACCESS_ADDR(heap.data, 28LLU, 21LLU); | |
80245 | + LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
80246 | + } | |
80247 | + // ACCUMULATE ARGUMENTS - END | |
80248 | + uint64_t return_to = 18446744073709546499LLU; | |
80249 | + const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)); | |
80250 | + uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); | |
80251 | + *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; | |
80252 | + heap.data[0].elem1 = heap.data[0].elem0; | |
80253 | + heap.data[0].elem0 = restore; | |
80254 | + state.addr = 861504774606556015LLU; // typeassert | |
80255 | + break; | |
80256 | + } | |
80257 | + case 18446744073709546499LLU: // 99999998uC''''''''''''''' | |
80258 | + { | |
80259 | + state.addr = 18446744073709546500LLU; // 99999998uD''''''''''''''' | |
80260 | + break; | |
80261 | + } | |
80262 | + case 18446744073709546500LLU: // 99999998uD''''''''''''''' | |
80263 | + { | |
80264 | + fprintf(stdout, "%s", ", &"); | |
80265 | + // ACCUMULATE ARGUMENTS - BEGIN | |
80266 | + { | |
80267 | + uint64_t arg = /*defargcnt_*/*LOCAL_ACCESS(heap.data, 28LLU, 12LLU); | |
80268 | + LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
80269 | + } | |
80270 | + { | |
80271 | + uint64_t arg = /*defbodysz_*/*LOCAL_ACCESS(heap.data, 28LLU, 13LLU); | |
80272 | + LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
80273 | + } | |
80274 | + { | |
80275 | + uint64_t arg = /*remainsize*/*LOCAL_ACCESS(heap.data, 28LLU, 14LLU); | |
80276 | + LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
80277 | + } | |
80278 | + { | |
80279 | + uint64_t arg = /*result____*/tree_elem_addr(heap.data, 3LLU, LOCAL_ACCESS_ADDR(heap.data, 28LLU, 20LLU), 1LLU); | |
80280 | + LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
80281 | + } | |
80282 | + { | |
80283 | + uint64_t arg = /*result____*/tree_elem_addr(heap.data, 3LLU, LOCAL_ACCESS_ADDR(heap.data, 28LLU, 20LLU), 2LLU); | |
80284 | + LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
80285 | + } | |
80286 | + // ACCUMULATE ARGUMENTS - END | |
80287 | + uint64_t return_to = 18446744073709546497LLU; | |
80288 | + const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)); | |
80289 | + uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); | |
80290 | + *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; | |
80291 | + heap.data[0].elem1 = heap.data[0].elem0; | |
80292 | + heap.data[0].elem0 = restore; | |
80293 | + state.addr = 587881357514113024LLU; // emitpar___ | |
80294 | + break; | |
80295 | + } | |
80296 | + case 18446744073709546497LLU: // 99999998uA''''''''''''''' | |
80297 | + { | |
80298 | + state.addr = 18446744073709546498LLU; // 99999998uB''''''''''''''' | |
80299 | + break; | |
80300 | + } | |
80301 | + case 18446744073709546498LLU: // 99999998uB''''''''''''''' | |
80302 | + { | |
80303 | + fprintf(stdout, "%s", "); // result"); | |
80304 | + // variable u64 info______ goes out of scope | |
80305 | + // emitted destructur for type u64 | |
80306 | + (void)LOCAL_POP_MOVE(&heap, 28LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference info______ at 28 | |
80307 | + // variable u64 idx_______ goes out of scope | |
80308 | + // emitted destructur for type u64 | |
80309 | + (void)LOCAL_POP_MOVE(&heap, 27LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference idx_______ at 27 | |
80310 | + // variable u64 parameter_ goes out of scope | |
80311 | + // emitted destructur for type u64 | |
80312 | + (void)LOCAL_POP_MOVE(&heap, 26LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference parameter_ at 26 | |
80313 | + // variable u64 INDIRECT__ goes out of scope | |
80314 | + // emitted destructur for type u64 | |
80315 | + (void)LOCAL_POP_MOVE(&heap, 25LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference INDIRECT__ at 25 | |
80316 | + // variable u64 mutable___ goes out of scope | |
80317 | + // emitted destructur for type u64 | |
80318 | + (void)LOCAL_POP_MOVE(&heap, 24LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference mutable___ at 24 | |
80319 | + // variable u64 init1_____ goes out of scope | |
80320 | + // emitted destructur for type u64 | |
80321 | + (void)LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference init1_____ at 23 | |
80322 | + // variable type______ typesrc___ goes out of scope | |
80323 | + // emitted destructur for type type______ | |
80324 | + // ACCUMULATE ARGUMENTS - BEGIN | |
80325 | + { | |
80326 | + uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 22LLU, 21LLU); | |
80327 | + LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
80328 | + } | |
80329 | + // ACCUMULATE ARGUMENTS - END | |
80330 | + uint64_t return_to = 18446744073709546496LLU; | |
80331 | + const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); | |
80332 | + uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); | |
80333 | + *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; | |
80334 | + heap.data[0].elem1 = heap.data[0].elem0; | |
80335 | + heap.data[0].elem0 = restore; | |
80336 | + state.addr = 18446744073709551534LLU; // 999999998s''''''''''''''' | |
80337 | + break; | |
80338 | + } | |
80339 | + case 18446744073709546496LLU: // 99999998u_''''''''''''''' | |
80340 | + { | |
80341 | + (void)LOCAL_POP_MOVE(&heap, 22LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference typesrc___ at 22 | |
79904 | 80342 | state.addr = 18446744073709546523LLU; // 99999998u$''''''''''''''' |
79905 | 80343 | break; |
79906 | 80344 | } |
79907 | 80345 | case 18446744073709546523LLU: // 99999998u$''''''''''''''' |
79908 | 80346 | { |
79909 | - ungetc((int)/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 11LLU)), stdin); | |
79910 | - if(';' != (char)getchar()) | |
79911 | - { | |
79912 | - fprintf(stderr, "match failed at char %c\n", (char)59LLU); | |
79913 | - exit(-1); | |
79914 | - } | |
79915 | 80347 | state.addr = 18446744073709546544LLU; // 99999998uu''''''''''''''' |
79916 | 80348 | break; |
79917 | 80349 | } |
@@ -79925,7 +80357,7 @@ | ||
79925 | 80357 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
79926 | 80358 | } |
79927 | 80359 | // ACCUMULATE ARGUMENTS - END |
79928 | - uint64_t return_to = 18446744073709546518LLU; | |
80360 | + uint64_t return_to = 18446744073709546495LLU; | |
79929 | 80361 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
79930 | 80362 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
79931 | 80363 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -79934,12 +80366,12 @@ | ||
79934 | 80366 | state.addr = 18446744073709551475LLU; // 999999997x''''''''''''''' |
79935 | 80367 | break; |
79936 | 80368 | } |
79937 | - case 18446744073709546518LLU: // 99999998uV''''''''''''''' | |
80369 | + case 18446744073709546495LLU: // 99999998t9''''''''''''''' | |
79938 | 80370 | { |
79939 | 80371 | (void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference result____ at 21 |
79940 | 80372 | heap.availilable_size_for_dynamic_objects += 0LLU; |
79941 | 80373 | heap.availilable_size_for_dynamic_objects += 0LLU; |
79942 | - state.addr = 18446744073709546517LLU; // 99999998uU''''''''''''''' | |
80374 | + state.addr = 18446744073709546494LLU; // 99999998t8''''''''''''''' | |
79943 | 80375 | break; |
79944 | 80376 | } |
79945 | 80377 | case 18446744073709546550LLU: // 99999998u0''''''''''''''' |
@@ -79950,7 +80382,7 @@ | ||
79950 | 80382 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
79951 | 80383 | } |
79952 | 80384 | // ACCUMULATE ARGUMENTS - END |
79953 | - uint64_t return_to = 18446744073709546515LLU; | |
80385 | + uint64_t return_to = 18446744073709546492LLU; | |
79954 | 80386 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
79955 | 80387 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
79956 | 80388 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -79959,12 +80391,12 @@ | ||
79959 | 80391 | state.addr = 819847183515949359LLU; // reportinit |
79960 | 80392 | break; |
79961 | 80393 | } |
79962 | - case 18446744073709546515LLU: // 99999998uS''''''''''''''' | |
80394 | + case 18446744073709546492LLU: // 99999998t6''''''''''''''' | |
79963 | 80395 | { |
79964 | - state.addr = 18446744073709546516LLU; // 99999998uT''''''''''''''' | |
80396 | + state.addr = 18446744073709546493LLU; // 99999998t7''''''''''''''' | |
79965 | 80397 | break; |
79966 | 80398 | } |
79967 | - case 18446744073709546516LLU: // 99999998uT''''''''''''''' | |
80399 | + case 18446744073709546493LLU: // 99999998t7''''''''''''''' | |
79968 | 80400 | { |
79969 | 80401 | fprintf(stderr, "%s", "missing result in assignment from "); |
79970 | 80402 | printid(stderr, /*callee_id_*/*LOCAL_ACCESS(heap.data, 20LLU, 19LLU)); |
@@ -79972,10 +80404,10 @@ | ||
79972 | 80404 | fprintf(stderr, "%s\n", ""); |
79973 | 80405 | exit(-1); |
79974 | 80406 | } |
79975 | - state.addr = 18446744073709546517LLU; // 99999998uU''''''''''''''' | |
80407 | + state.addr = 18446744073709546494LLU; // 99999998t8''''''''''''''' | |
79976 | 80408 | break; |
79977 | 80409 | } |
79978 | - case 18446744073709546517LLU: // 99999998uU''''''''''''''' | |
80410 | + case 18446744073709546494LLU: // 99999998t8''''''''''''''' | |
79979 | 80411 | { |
79980 | 80412 | state.addr = 18446744073709546552LLU; // 99999998u2''''''''''''''' |
79981 | 80413 | break; |
@@ -80061,7 +80493,7 @@ | ||
80061 | 80493 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
80062 | 80494 | } |
80063 | 80495 | // ACCUMULATE ARGUMENTS - END |
80064 | - uint64_t return_to = 18446744073709546513LLU; | |
80496 | + uint64_t return_to = 18446744073709546490LLU; | |
80065 | 80497 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
80066 | 80498 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
80067 | 80499 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -80070,12 +80502,12 @@ | ||
80070 | 80502 | state.addr = 839519719621918720LLU; // skipws____ |
80071 | 80503 | break; |
80072 | 80504 | } |
80073 | - case 18446744073709546513LLU: // 99999998uQ''''''''''''''' | |
80505 | + case 18446744073709546490LLU: // 99999998t4''''''''''''''' | |
80074 | 80506 | { |
80075 | - state.addr = 18446744073709546514LLU; // 99999998uR''''''''''''''' | |
80507 | + state.addr = 18446744073709546491LLU; // 99999998t5''''''''''''''' | |
80076 | 80508 | break; |
80077 | 80509 | } |
80078 | - case 18446744073709546514LLU: // 99999998uR''''''''''''''' | |
80510 | + case 18446744073709546491LLU: // 99999998t5''''''''''''''' | |
80079 | 80511 | { |
80080 | 80512 | { |
80081 | 80513 | uint64_t arg = 0; |
@@ -80087,21 +80519,21 @@ | ||
80087 | 80519 | LOCAL_PUSH_MOVE(&heap, 17, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
80088 | 80520 | } |
80089 | 80521 | *LOCAL_ACCESS(heap.data, 18LLU, 17LLU) = /*sym_______*/*LOCAL_ACCESS(heap.data, 18LLU, 16LLU) == /*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 18LLU, 11LLU)); |
80090 | - state.addr = 18446744073709546510LLU; // 99999998uN''''''''''''''' | |
80522 | + state.addr = 18446744073709546487LLU; // 99999998t1''''''''''''''' | |
80091 | 80523 | break; |
80092 | 80524 | } |
80093 | - case 18446744073709546510LLU: // 99999998uN''''''''''''''' | |
80525 | + case 18446744073709546487LLU: // 99999998t1''''''''''''''' | |
80094 | 80526 | { |
80095 | - state.addr = *LOCAL_ACCESS(heap.data, 18LLU, 17LLU) ? 18446744073709546512LLU : 18446744073709546511LLU; | |
80527 | + state.addr = *LOCAL_ACCESS(heap.data, 18LLU, 17LLU) ? 18446744073709546489LLU : 18446744073709546488LLU; | |
80096 | 80528 | (void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 18 |
80097 | 80529 | break; |
80098 | 80530 | } |
80099 | - case 18446744073709546512LLU: // 99999998uP''''''''''''''' | |
80531 | + case 18446744073709546489LLU: // 99999998t3''''''''''''''' | |
80100 | 80532 | { |
80101 | - state.addr = *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 4LLU)) ? 18446744073709546509LLU : 18446744073709546508LLU; | |
80533 | + state.addr = *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 4LLU)) ? 18446744073709546486LLU : 18446744073709546485LLU; | |
80102 | 80534 | break; |
80103 | 80535 | } |
80104 | - case 18446744073709546509LLU: // 99999998uM''''''''''''''' | |
80536 | + case 18446744073709546486LLU: // 99999998t0''''''''''''''' | |
80105 | 80537 | { |
80106 | 80538 | // ACCUMULATE ARGUMENTS - BEGIN |
80107 | 80539 | { |
@@ -80109,7 +80541,7 @@ | ||
80109 | 80541 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
80110 | 80542 | } |
80111 | 80543 | // ACCUMULATE ARGUMENTS - END |
80112 | - uint64_t return_to = 18446744073709546506LLU; | |
80544 | + uint64_t return_to = 18446744073709546483LLU; | |
80113 | 80545 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
80114 | 80546 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
80115 | 80547 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -80118,31 +80550,31 @@ | ||
80118 | 80550 | state.addr = 819847183515949359LLU; // reportinit |
80119 | 80551 | break; |
80120 | 80552 | } |
80121 | - case 18446744073709546506LLU: // 99999998uJ''''''''''''''' | |
80553 | + case 18446744073709546483LLU: // 99999998tx''''''''''''''' | |
80122 | 80554 | { |
80123 | - state.addr = 18446744073709546507LLU; // 99999998uK''''''''''''''' | |
80555 | + state.addr = 18446744073709546484LLU; // 99999998ty''''''''''''''' | |
80124 | 80556 | break; |
80125 | 80557 | } |
80126 | - case 18446744073709546507LLU: // 99999998uK''''''''''''''' | |
80558 | + case 18446744073709546484LLU: // 99999998ty''''''''''''''' | |
80127 | 80559 | { |
80128 | 80560 | { |
80129 | 80561 | fprintf(stderr, "%s\n", "can't return c-code in safe environment"); |
80130 | 80562 | exit(-1); |
80131 | 80563 | } |
80132 | - state.addr = 18446744073709546508LLU; // 99999998uL''''''''''''''' | |
80564 | + state.addr = 18446744073709546485LLU; // 99999998tz''''''''''''''' | |
80133 | 80565 | break; |
80134 | 80566 | } |
80135 | - case 18446744073709546508LLU: // 99999998uL''''''''''''''' | |
80567 | + case 18446744073709546485LLU: // 99999998tz''''''''''''''' | |
80136 | 80568 | { |
80137 | - state.addr = 18446744073709546505LLU; // 99999998uI''''''''''''''' | |
80569 | + state.addr = 18446744073709546482LLU; // 99999998tw''''''''''''''' | |
80138 | 80570 | break; |
80139 | 80571 | } |
80140 | - case 18446744073709546505LLU: // 99999998uI''''''''''''''' | |
80572 | + case 18446744073709546482LLU: // 99999998tw''''''''''''''' | |
80141 | 80573 | { |
80142 | 80574 | *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 11LLU)) = (uint64_t)getchar(); |
80143 | 80575 | if(!*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 11LLU)) || *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 11LLU)) > 255) |
80144 | 80576 | { |
80145 | - state.addr = 18446744073709546504LLU; // 99999998uH''''''''''''''' | |
80577 | + state.addr = 18446744073709546481LLU; // 99999998tv''''''''''''''' | |
80146 | 80578 | break; |
80147 | 80579 | } |
80148 | 80580 | { |
@@ -80150,24 +80582,24 @@ | ||
80150 | 80582 | LOCAL_PUSH_MOVE(&heap, 17, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
80151 | 80583 | } |
80152 | 80584 | *LOCAL_ACCESS(heap.data, 18LLU, 17LLU) = /*sym_______*/*LOCAL_ACCESS(heap.data, 18LLU, 16LLU) == /*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 18LLU, 11LLU)); |
80153 | - state.addr = 18446744073709546501LLU; // 99999998uE''''''''''''''' | |
80585 | + state.addr = 18446744073709546478LLU; // 99999998ts''''''''''''''' | |
80154 | 80586 | break; |
80155 | 80587 | } |
80156 | - case 18446744073709546501LLU: // 99999998uE''''''''''''''' | |
80588 | + case 18446744073709546478LLU: // 99999998ts''''''''''''''' | |
80157 | 80589 | { |
80158 | - state.addr = *LOCAL_ACCESS(heap.data, 18LLU, 17LLU) ? 18446744073709546503LLU : 18446744073709546502LLU; | |
80590 | + state.addr = *LOCAL_ACCESS(heap.data, 18LLU, 17LLU) ? 18446744073709546480LLU : 18446744073709546479LLU; | |
80159 | 80591 | (void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 18 |
80160 | 80592 | break; |
80161 | 80593 | } |
80162 | - case 18446744073709546503LLU: // 99999998uG''''''''''''''' | |
80594 | + case 18446744073709546480LLU: // 99999998tu''''''''''''''' | |
80163 | 80595 | { |
80164 | 80596 | ungetc(0, stdin); |
80165 | 80597 | heap.availilable_size_for_dynamic_objects += 0LLU; |
80166 | 80598 | heap.availilable_size_for_dynamic_objects += 0LLU; |
80167 | - state.addr = 18446744073709546500LLU; // 99999998uD''''''''''''''' | |
80599 | + state.addr = 18446744073709546477LLU; // 99999998tr''''''''''''''' | |
80168 | 80600 | break; |
80169 | 80601 | } |
80170 | - case 18446744073709546502LLU: // 99999998uF''''''''''''''' | |
80602 | + case 18446744073709546479LLU: // 99999998tt''''''''''''''' | |
80171 | 80603 | { |
80172 | 80604 | // ACCUMULATE ARGUMENTS - BEGIN |
80173 | 80605 | { |
@@ -80175,7 +80607,7 @@ | ||
80175 | 80607 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
80176 | 80608 | } |
80177 | 80609 | // ACCUMULATE ARGUMENTS - END |
80178 | - uint64_t return_to = 18446744073709546498LLU; | |
80610 | + uint64_t return_to = 18446744073709546475LLU; | |
80179 | 80611 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
80180 | 80612 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
80181 | 80613 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -80184,46 +80616,46 @@ | ||
80184 | 80616 | state.addr = 587881343588366336LLU; // emitccode_ |
80185 | 80617 | break; |
80186 | 80618 | } |
80187 | - case 18446744073709546498LLU: // 99999998uB''''''''''''''' | |
80619 | + case 18446744073709546475LLU: // 99999998tp''''''''''''''' | |
80188 | 80620 | { |
80189 | - state.addr = 18446744073709546499LLU; // 99999998uC''''''''''''''' | |
80621 | + state.addr = 18446744073709546476LLU; // 99999998tq''''''''''''''' | |
80190 | 80622 | break; |
80191 | 80623 | } |
80192 | - case 18446744073709546499LLU: // 99999998uC''''''''''''''' | |
80624 | + case 18446744073709546476LLU: // 99999998tq''''''''''''''' | |
80193 | 80625 | { |
80194 | - state.addr = 18446744073709546500LLU; // 99999998uD''''''''''''''' | |
80626 | + state.addr = 18446744073709546477LLU; // 99999998tr''''''''''''''' | |
80195 | 80627 | break; |
80196 | 80628 | } |
80197 | - case 18446744073709546500LLU: // 99999998uD''''''''''''''' | |
80629 | + case 18446744073709546477LLU: // 99999998tr''''''''''''''' | |
80198 | 80630 | { |
80199 | - state.addr = 18446744073709546505LLU; // 99999998uI''''''''''''''' | |
80631 | + state.addr = 18446744073709546482LLU; // 99999998tw''''''''''''''' | |
80200 | 80632 | break; |
80201 | 80633 | } |
80202 | - case 18446744073709546504LLU: // 99999998uH''''''''''''''' | |
80634 | + case 18446744073709546481LLU: // 99999998tv''''''''''''''' | |
80203 | 80635 | { |
80204 | 80636 | |
80205 | - state.addr = 18446744073709546497LLU; // 99999998uA''''''''''''''' | |
80637 | + state.addr = 18446744073709546474LLU; // 99999998to''''''''''''''' | |
80206 | 80638 | break; |
80207 | 80639 | } |
80208 | - case 18446744073709546497LLU: // 99999998uA''''''''''''''' | |
80640 | + case 18446744073709546474LLU: // 99999998to''''''''''''''' | |
80209 | 80641 | { |
80210 | 80642 | *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 11LLU)) = (uint64_t)getchar(); |
80211 | - state.addr = 18446744073709546496LLU; // 99999998u_''''''''''''''' | |
80643 | + state.addr = 18446744073709546473LLU; // 99999998tn''''''''''''''' | |
80212 | 80644 | break; |
80213 | 80645 | } |
80214 | - case 18446744073709546496LLU: // 99999998u_''''''''''''''' | |
80646 | + case 18446744073709546473LLU: // 99999998tn''''''''''''''' | |
80215 | 80647 | { |
80216 | 80648 | heap.availilable_size_for_dynamic_objects += 0LLU; |
80217 | 80649 | heap.availilable_size_for_dynamic_objects += 0LLU; |
80218 | - state.addr = 18446744073709546495LLU; // 99999998t9''''''''''''''' | |
80650 | + state.addr = 18446744073709546472LLU; // 99999998tm''''''''''''''' | |
80219 | 80651 | break; |
80220 | 80652 | } |
80221 | - case 18446744073709546511LLU: // 99999998uO''''''''''''''' | |
80653 | + case 18446744073709546488LLU: // 99999998t2''''''''''''''' | |
80222 | 80654 | { |
80223 | - state.addr = *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 10LLU)) ? 18446744073709546494LLU : 18446744073709546493LLU; | |
80655 | + state.addr = *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 10LLU)) ? 18446744073709546471LLU : 18446744073709546470LLU; | |
80224 | 80656 | break; |
80225 | 80657 | } |
80226 | - case 18446744073709546494LLU: // 99999998t8''''''''''''''' | |
80658 | + case 18446744073709546471LLU: // 99999998tl''''''''''''''' | |
80227 | 80659 | { |
80228 | 80660 | { |
80229 | 80661 | uint64_t arg = 0; |
@@ -80238,10 +80670,10 @@ | ||
80238 | 80670 | uint64_t arg = 0; |
80239 | 80671 | LOCAL_PUSH_MOVE(&heap, 19, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
80240 | 80672 | } |
80241 | - state.addr = 18446744073709546492LLU; // 99999998t6''''''''''''''' | |
80673 | + state.addr = 18446744073709546469LLU; // 99999998tj''''''''''''''' | |
80242 | 80674 | break; |
80243 | 80675 | } |
80244 | - case 18446744073709546492LLU: // 99999998t6''''''''''''''' | |
80676 | + case 18446744073709546469LLU: // 99999998tj''''''''''''''' | |
80245 | 80677 | { |
80246 | 80678 | if(!*LOCAL_ACCESS(heap.data, 20LLU, 18LLU)) |
80247 | 80679 | { |
@@ -80248,7 +80680,7 @@ | ||
80248 | 80680 | (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 20 |
80249 | 80681 | (void)LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 19 |
80250 | 80682 | { |
80251 | - state.addr = 18446744073709546491LLU; // 99999998t5''''''''''''''' | |
80683 | + state.addr = 18446744073709546468LLU; // 99999998ti''''''''''''''' | |
80252 | 80684 | break; |
80253 | 80685 | } |
80254 | 80686 | } |
@@ -80260,7 +80692,7 @@ | ||
80260 | 80692 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
80261 | 80693 | } |
80262 | 80694 | // ACCUMULATE ARGUMENTS - END |
80263 | - uint64_t return_to = 18446744073709546489LLU; | |
80695 | + uint64_t return_to = 18446744073709546466LLU; | |
80264 | 80696 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
80265 | 80697 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
80266 | 80698 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -80269,38 +80701,38 @@ | ||
80269 | 80701 | state.addr = 839519719621918720LLU; // skipws____ |
80270 | 80702 | break; |
80271 | 80703 | } |
80272 | - case 18446744073709546489LLU: // 99999998t3''''''''''''''' | |
80704 | + case 18446744073709546466LLU: // 99999998tg''''''''''''''' | |
80273 | 80705 | { |
80274 | - state.addr = 18446744073709546490LLU; // 99999998t4''''''''''''''' | |
80706 | + state.addr = 18446744073709546467LLU; // 99999998th''''''''''''''' | |
80275 | 80707 | break; |
80276 | 80708 | } |
80277 | - case 18446744073709546490LLU: // 99999998t4''''''''''''''' | |
80709 | + case 18446744073709546467LLU: // 99999998th''''''''''''''' | |
80278 | 80710 | { |
80279 | - state.addr = *LOCAL_ACCESS(heap.data, 20LLU, 17LLU) ? 18446744073709546488LLU : 18446744073709546487LLU; | |
80711 | + state.addr = *LOCAL_ACCESS(heap.data, 20LLU, 17LLU) ? 18446744073709546465LLU : 18446744073709546464LLU; | |
80280 | 80712 | break; |
80281 | 80713 | } |
80282 | - case 18446744073709546488LLU: // 99999998t2''''''''''''''' | |
80714 | + case 18446744073709546465LLU: // 99999998tf''''''''''''''' | |
80283 | 80715 | { |
80284 | 80716 | matchid("(", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 20LLU, 11LLU))); |
80285 | 80717 | |
80286 | - state.addr = 18446744073709546486LLU; // 99999998t0''''''''''''''' | |
80718 | + state.addr = 18446744073709546463LLU; // 99999998td''''''''''''''' | |
80287 | 80719 | break; |
80288 | 80720 | } |
80289 | - case 18446744073709546486LLU: // 99999998t0''''''''''''''' | |
80721 | + case 18446744073709546463LLU: // 99999998td''''''''''''''' | |
80290 | 80722 | { |
80291 | 80723 | *LOCAL_ACCESS(heap.data, 20LLU, 17LLU) = 0; |
80292 | 80724 | heap.availilable_size_for_dynamic_objects += 0LLU; |
80293 | 80725 | heap.availilable_size_for_dynamic_objects += 0LLU; |
80294 | - state.addr = 18446744073709546485LLU; // 99999998tz''''''''''''''' | |
80726 | + state.addr = 18446744073709546462LLU; // 99999998tc''''''''''''''' | |
80295 | 80727 | break; |
80296 | 80728 | } |
80297 | - case 18446744073709546487LLU: // 99999998t1''''''''''''''' | |
80729 | + case 18446744073709546464LLU: // 99999998te''''''''''''''' | |
80298 | 80730 | { |
80299 | 80731 | matchid(",", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 20LLU, 11LLU))); |
80300 | - state.addr = 18446744073709546485LLU; // 99999998tz''''''''''''''' | |
80732 | + state.addr = 18446744073709546462LLU; // 99999998tc''''''''''''''' | |
80301 | 80733 | break; |
80302 | 80734 | } |
80303 | - case 18446744073709546485LLU: // 99999998tz''''''''''''''' | |
80735 | + case 18446744073709546462LLU: // 99999998tc''''''''''''''' | |
80304 | 80736 | { |
80305 | 80737 | // ACCUMULATE ARGUMENTS - BEGIN |
80306 | 80738 | { |
@@ -80308,7 +80740,7 @@ | ||
80308 | 80740 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
80309 | 80741 | } |
80310 | 80742 | // ACCUMULATE ARGUMENTS - END |
80311 | - uint64_t return_to = 18446744073709546483LLU; | |
80743 | + uint64_t return_to = 18446744073709546460LLU; | |
80312 | 80744 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
80313 | 80745 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
80314 | 80746 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -80317,12 +80749,12 @@ | ||
80317 | 80749 | state.addr = 839519719621918720LLU; // skipws____ |
80318 | 80750 | break; |
80319 | 80751 | } |
80320 | - case 18446744073709546483LLU: // 99999998tx''''''''''''''' | |
80752 | + case 18446744073709546460LLU: // 99999998ta''''''''''''''' | |
80321 | 80753 | { |
80322 | - state.addr = 18446744073709546484LLU; // 99999998ty''''''''''''''' | |
80754 | + state.addr = 18446744073709546461LLU; // 99999998tb''''''''''''''' | |
80323 | 80755 | break; |
80324 | 80756 | } |
80325 | - case 18446744073709546484LLU: // 99999998ty''''''''''''''' | |
80757 | + case 18446744073709546461LLU: // 99999998tb''''''''''''''' | |
80326 | 80758 | { |
80327 | 80759 | { |
80328 | 80760 | uint64_t arg = 0; |
@@ -80338,7 +80770,7 @@ | ||
80338 | 80770 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
80339 | 80771 | } |
80340 | 80772 | // ACCUMULATE ARGUMENTS - END |
80341 | - uint64_t return_to = 18446744073709546479LLU; | |
80773 | + uint64_t return_to = 18446744073709546456LLU; | |
80342 | 80774 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
80343 | 80775 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
80344 | 80776 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -80347,18 +80779,18 @@ | ||
80347 | 80779 | state.addr = 661605045736570880LLU; // isdigit___ |
80348 | 80780 | break; |
80349 | 80781 | } |
80350 | - case 18446744073709546479LLU: // 99999998tt''''''''''''''' | |
80782 | + case 18446744073709546456LLU: // 99999998tX''''''''''''''' | |
80351 | 80783 | { |
80352 | - state.addr = 18446744073709546480LLU; // 99999998tu''''''''''''''' | |
80784 | + state.addr = 18446744073709546457LLU; // 99999998tY''''''''''''''' | |
80353 | 80785 | break; |
80354 | 80786 | } |
80355 | - case 18446744073709546480LLU: // 99999998tu''''''''''''''' | |
80787 | + case 18446744073709546457LLU: // 99999998tY''''''''''''''' | |
80356 | 80788 | { |
80357 | - state.addr = *LOCAL_ACCESS(heap.data, 21LLU, 20LLU) ? 18446744073709546482LLU : 18446744073709546481LLU; | |
80789 | + state.addr = *LOCAL_ACCESS(heap.data, 21LLU, 20LLU) ? 18446744073709546459LLU : 18446744073709546458LLU; | |
80358 | 80790 | (void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 21 |
80359 | 80791 | break; |
80360 | 80792 | } |
80361 | - case 18446744073709546482LLU: // 99999998tw''''''''''''''' | |
80793 | + case 18446744073709546459LLU: // 99999998t$''''''''''''''' | |
80362 | 80794 | { |
80363 | 80795 | // ACCUMULATE ARGUMENTS - BEGIN |
80364 | 80796 | { |
@@ -80370,7 +80802,7 @@ | ||
80370 | 80802 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
80371 | 80803 | } |
80372 | 80804 | // ACCUMULATE ARGUMENTS - END |
80373 | - uint64_t return_to = 18446744073709546477LLU; | |
80805 | + uint64_t return_to = 18446744073709546454LLU; | |
80374 | 80806 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
80375 | 80807 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
80376 | 80808 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -80379,12 +80811,12 @@ | ||
80379 | 80811 | state.addr = 517555565476695680LLU; // assertu64_ |
80380 | 80812 | break; |
80381 | 80813 | } |
80382 | - case 18446744073709546477LLU: // 99999998tr''''''''''''''' | |
80814 | + case 18446744073709546454LLU: // 99999998tV''''''''''''''' | |
80383 | 80815 | { |
80384 | - state.addr = 18446744073709546478LLU; // 99999998ts''''''''''''''' | |
80816 | + state.addr = 18446744073709546455LLU; // 99999998tW''''''''''''''' | |
80385 | 80817 | break; |
80386 | 80818 | } |
80387 | - case 18446744073709546478LLU: // 99999998ts''''''''''''''' | |
80819 | + case 18446744073709546455LLU: // 99999998tW''''''''''''''' | |
80388 | 80820 | { |
80389 | 80821 | { |
80390 | 80822 | uint64_t arg = 0; |
@@ -80391,10 +80823,10 @@ | ||
80391 | 80823 | LOCAL_PUSH_MOVE(&heap, 20, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
80392 | 80824 | } |
80393 | 80825 | *LOCAL_ACCESS(heap.data, 21LLU, 20LLU) = parsenr(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 11LLU))); |
80394 | - state.addr = 18446744073709546476LLU; // 99999998tq''''''''''''''' | |
80826 | + state.addr = 18446744073709546453LLU; // 99999998tU''''''''''''''' | |
80395 | 80827 | break; |
80396 | 80828 | } |
80397 | - case 18446744073709546476LLU: // 99999998tq''''''''''''''' | |
80829 | + case 18446744073709546453LLU: // 99999998tU''''''''''''''' | |
80398 | 80830 | { |
80399 | 80831 | fprintf(stdout, "%s", "\n "); |
80400 | 80832 | // ACCUMULATE ARGUMENTS - BEGIN |
@@ -80419,7 +80851,7 @@ | ||
80419 | 80851 | LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
80420 | 80852 | } |
80421 | 80853 | // ACCUMULATE ARGUMENTS - END |
80422 | - uint64_t return_to = 18446744073709546474LLU; | |
80854 | + uint64_t return_to = 18446744073709546451LLU; | |
80423 | 80855 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)); |
80424 | 80856 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
80425 | 80857 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -80428,12 +80860,12 @@ | ||
80428 | 80860 | state.addr = 587881357514113024LLU; // emitpar___ |
80429 | 80861 | break; |
80430 | 80862 | } |
80431 | - case 18446744073709546474LLU: // 99999998to''''''''''''''' | |
80863 | + case 18446744073709546451LLU: // 99999998tS''''''''''''''' | |
80432 | 80864 | { |
80433 | - state.addr = 18446744073709546475LLU; // 99999998tp''''''''''''''' | |
80865 | + state.addr = 18446744073709546452LLU; // 99999998tT''''''''''''''' | |
80434 | 80866 | break; |
80435 | 80867 | } |
80436 | - case 18446744073709546475LLU: // 99999998tp''''''''''''''' | |
80868 | + case 18446744073709546452LLU: // 99999998tT''''''''''''''' | |
80437 | 80869 | { |
80438 | 80870 | fprintf(stdout, "%s", " = "); |
80439 | 80871 | // ACCUMULATE ARGUMENTS - BEGIN |
@@ -80442,7 +80874,7 @@ | ||
80442 | 80874 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
80443 | 80875 | } |
80444 | 80876 | // ACCUMULATE ARGUMENTS - END |
80445 | - uint64_t return_to = 18446744073709546472LLU; | |
80877 | + uint64_t return_to = 18446744073709546449LLU; | |
80446 | 80878 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
80447 | 80879 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
80448 | 80880 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -80451,12 +80883,12 @@ | ||
80451 | 80883 | state.addr = 787446708198178816LLU; // printnr___ |
80452 | 80884 | break; |
80453 | 80885 | } |
80454 | - case 18446744073709546472LLU: // 99999998tm''''''''''''''' | |
80886 | + case 18446744073709546449LLU: // 99999998tQ''''''''''''''' | |
80455 | 80887 | { |
80456 | - state.addr = 18446744073709546473LLU; // 99999998tn''''''''''''''' | |
80888 | + state.addr = 18446744073709546450LLU; // 99999998tR''''''''''''''' | |
80457 | 80889 | break; |
80458 | 80890 | } |
80459 | - case 18446744073709546473LLU: // 99999998tn''''''''''''''' | |
80891 | + case 18446744073709546450LLU: // 99999998tR''''''''''''''' | |
80460 | 80892 | { |
80461 | 80893 | fprintf(stdout, "%s", ";"); |
80462 | 80894 | // variable u64 n_________ goes out of scope |
@@ -80464,89 +80896,34 @@ | ||
80464 | 80896 | (void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference n_________ at 21 |
80465 | 80897 | heap.availilable_size_for_dynamic_objects += 0LLU; |
80466 | 80898 | heap.availilable_size_for_dynamic_objects += 0LLU; |
80467 | - state.addr = 18446744073709546471LLU; // 99999998tl''''''''''''''' | |
80899 | + state.addr = 18446744073709546448LLU; // 99999998tP''''''''''''''' | |
80468 | 80900 | break; |
80469 | 80901 | } |
80470 | - case 18446744073709546481LLU: // 99999998tv''''''''''''''' | |
80902 | + case 18446744073709546458LLU: // 99999998tZ''''''''''''''' | |
80471 | 80903 | { |
80472 | 80904 | { |
80473 | 80905 | uint64_t arg = 0; |
80474 | 80906 | LOCAL_PUSH_MOVE(&heap, 20, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
80475 | 80907 | } |
80476 | - *LOCAL_ACCESS(heap.data, 21LLU, 20LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 11LLU))); | |
80477 | - state.addr = 18446744073709546470LLU; // 99999998tk''''''''''''''' | |
80478 | - break; | |
80479 | - } | |
80480 | - case 18446744073709546470LLU: // 99999998tk''''''''''''''' | |
80481 | - { | |
80482 | 80908 | // ACCUMULATE ARGUMENTS - BEGIN |
80483 | 80909 | { |
80484 | - uint64_t arg = /*c_________*/*LOCAL_ACCESS(heap.data, 21LLU, 11LLU); | |
80910 | + uint64_t arg = /*newresults*/LOCAL_ACCESS_ADDR(heap.data, 21LLU, 20LLU); | |
80485 | 80911 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
80486 | 80912 | } |
80487 | - // ACCUMULATE ARGUMENTS - END | |
80488 | - uint64_t return_to = 18446744073709546468LLU; | |
80489 | - const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); | |
80490 | - uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); | |
80491 | - *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; | |
80492 | - heap.data[0].elem1 = heap.data[0].elem0; | |
80493 | - heap.data[0].elem0 = restore; | |
80494 | - state.addr = 839519719621918720LLU; // skipws____ | |
80495 | - break; | |
80496 | - } | |
80497 | - case 18446744073709546468LLU: // 99999998ti''''''''''''''' | |
80498 | - { | |
80499 | - state.addr = 18446744073709546469LLU; // 99999998tj''''''''''''''' | |
80500 | - break; | |
80501 | - } | |
80502 | - case 18446744073709546469LLU: // 99999998tj''''''''''''''' | |
80503 | - { | |
80504 | - | |
80505 | - state.addr = 18446744073709546467LLU; // 99999998th''''''''''''''' | |
80506 | - break; | |
80507 | - } | |
80508 | - case 18446744073709546467LLU: // 99999998th''''''''''''''' | |
80509 | - { | |
80510 | - *LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = 40; | |
80511 | - { | |
80512 | - uint64_t arg = 0; | |
80513 | - LOCAL_PUSH_MOVE(&heap, 21, &(heap.data[0].elem1)/*address of current closure*/, &arg); | |
80514 | - } | |
80515 | - *LOCAL_ACCESS(heap.data, 22LLU, 21LLU) = /*sym_______*/*LOCAL_ACCESS(heap.data, 22LLU, 16LLU) == /*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 22LLU, 11LLU)); | |
80516 | - state.addr = 18446744073709546464LLU; // 99999998te''''''''''''''' | |
80517 | - break; | |
80518 | - } | |
80519 | - case 18446744073709546464LLU: // 99999998te''''''''''''''' | |
80520 | - { | |
80521 | - state.addr = *LOCAL_ACCESS(heap.data, 22LLU, 21LLU) ? 18446744073709546466LLU : 18446744073709546465LLU; | |
80522 | - (void)LOCAL_POP_MOVE(&heap, 22LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 22 | |
80523 | - break; | |
80524 | - } | |
80525 | - case 18446744073709546466LLU: // 99999998tg''''''''''''''' | |
80526 | - { | |
80527 | - { | |
80528 | - uint64_t arg = 0; | |
80529 | - LOCAL_PUSH_MOVE(&heap, 21, &(heap.data[0].elem1)/*address of current closure*/, &arg); | |
80530 | - } | |
80531 | - // ACCUMULATE ARGUMENTS - BEGIN | |
80532 | 80913 | { |
80533 | - uint64_t arg = /*newresults*/LOCAL_ACCESS_ADDR(heap.data, 22LLU, 21LLU); | |
80534 | - LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
80535 | - } | |
80536 | - { | |
80537 | - uint64_t arg = /*respar____*/tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 22LLU, 19LLU), 0LLU); | |
80914 | + uint64_t arg = /*respar____*/tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 21LLU, 19LLU), 0LLU); | |
80538 | 80915 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
80539 | 80916 | } |
80540 | 80917 | { |
80541 | - uint64_t arg = /*respar____*/tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 22LLU, 19LLU), 1LLU); | |
80918 | + uint64_t arg = /*respar____*/tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 21LLU, 19LLU), 1LLU); | |
80542 | 80919 | LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
80543 | 80920 | } |
80544 | 80921 | { |
80545 | - uint64_t arg = /*respar____*/tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 22LLU, 19LLU), 2LLU); | |
80922 | + uint64_t arg = /*respar____*/tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 21LLU, 19LLU), 2LLU); | |
80546 | 80923 | LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
80547 | 80924 | } |
80548 | 80925 | // ACCUMULATE ARGUMENTS - END |
80549 | - uint64_t return_to = 18446744073709546462LLU; | |
80926 | + uint64_t return_to = 18446744073709546446LLU; | |
80550 | 80927 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
80551 | 80928 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
80552 | 80929 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -80555,13 +80932,17 @@ | ||
80555 | 80932 | state.addr = 768289076452424640LLU; // oneresult_ |
80556 | 80933 | break; |
80557 | 80934 | } |
80558 | - case 18446744073709546462LLU: // 99999998tc''''''''''''''' | |
80935 | + case 18446744073709546446LLU: // 99999998tN''''''''''''''' | |
80559 | 80936 | { |
80560 | - state.addr = 18446744073709546463LLU; // 99999998td''''''''''''''' | |
80937 | + state.addr = 18446744073709546447LLU; // 99999998tO''''''''''''''' | |
80561 | 80938 | break; |
80562 | 80939 | } |
80563 | - case 18446744073709546463LLU: // 99999998td''''''''''''''' | |
80940 | + case 18446744073709546447LLU: // 99999998tO''''''''''''''' | |
80564 | 80941 | { |
80942 | + { | |
80943 | + uint64_t arg = 0; | |
80944 | + LOCAL_PUSH_MOVE(&heap, 21, &(heap.data[0].elem1)/*address of current closure*/, &arg); | |
80945 | + } | |
80565 | 80946 | // ACCUMULATE ARGUMENTS - BEGIN |
80566 | 80947 | { |
80567 | 80948 | uint64_t arg = /*def_id____*/*LOCAL_ACCESS(heap.data, 22LLU, 0LLU); |
@@ -80596,68 +80977,68 @@ | ||
80596 | 80977 | LOCAL_PUSH_MOVE(&heap, 7LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
80597 | 80978 | } |
80598 | 80979 | { |
80599 | - uint64_t arg = /*id1_______*/LOCAL_ACCESS_ADDR(heap.data, 22LLU, 20LLU); | |
80980 | + uint64_t arg = /*blocklist_*/*LOCAL_ACCESS(heap.data, 22LLU, 8LLU); | |
80600 | 80981 | LOCAL_PUSH_MOVE(&heap, 8LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
80601 | 80982 | } |
80602 | 80983 | { |
80603 | - uint64_t arg = /*blocklist_*/*LOCAL_ACCESS(heap.data, 22LLU, 8LLU); | |
80984 | + uint64_t arg = /*varlist___*/*LOCAL_ACCESS(heap.data, 22LLU, 9LLU); | |
80604 | 80985 | LOCAL_PUSH_MOVE(&heap, 9LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
80605 | 80986 | } |
80606 | 80987 | { |
80607 | - uint64_t arg = /*varlist___*/*LOCAL_ACCESS(heap.data, 22LLU, 9LLU); | |
80988 | + uint64_t arg = /*results___*/LOCAL_ACCESS_ADDR(heap.data, 22LLU, 21LLU); | |
80608 | 80989 | LOCAL_PUSH_MOVE(&heap, 10LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
80609 | 80990 | } |
80610 | 80991 | { |
80611 | - uint64_t arg = /*newresults*/LOCAL_ACCESS_ADDR(heap.data, 22LLU, 21LLU); | |
80992 | + uint64_t arg = /*c_________*/*LOCAL_ACCESS(heap.data, 22LLU, 11LLU); | |
80612 | 80993 | LOCAL_PUSH_MOVE(&heap, 11LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
80613 | 80994 | } |
80614 | 80995 | { |
80615 | - uint64_t arg = /*c_________*/*LOCAL_ACCESS(heap.data, 22LLU, 11LLU); | |
80996 | + uint64_t arg = /*defargcnt_*/*LOCAL_ACCESS(heap.data, 22LLU, 12LLU); | |
80616 | 80997 | LOCAL_PUSH_MOVE(&heap, 12LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
80617 | 80998 | } |
80618 | 80999 | { |
80619 | - uint64_t arg = /*defargcnt_*/*LOCAL_ACCESS(heap.data, 22LLU, 12LLU); | |
81000 | + uint64_t arg = /*defbodysz_*/*LOCAL_ACCESS(heap.data, 22LLU, 13LLU); | |
80620 | 81001 | LOCAL_PUSH_MOVE(&heap, 13LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
80621 | 81002 | } |
80622 | 81003 | { |
80623 | - uint64_t arg = /*defbodysz_*/*LOCAL_ACCESS(heap.data, 22LLU, 13LLU); | |
81004 | + uint64_t arg = /*remainsize*/*LOCAL_ACCESS(heap.data, 22LLU, 14LLU); | |
80624 | 81005 | LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
80625 | 81006 | } |
80626 | 81007 | { |
80627 | - uint64_t arg = /*remainsize*/*LOCAL_ACCESS(heap.data, 22LLU, 14LLU); | |
81008 | + uint64_t arg = /*remainheap*/*LOCAL_ACCESS(heap.data, 22LLU, 15LLU); | |
80628 | 81009 | LOCAL_PUSH_MOVE(&heap, 15LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
80629 | 81010 | } |
80630 | 81011 | { |
80631 | - uint64_t arg = /*remainheap*/*LOCAL_ACCESS(heap.data, 22LLU, 15LLU); | |
81012 | + uint64_t arg = /*newresults*/LOCAL_ACCESS_ADDR(heap.data, 22LLU, 20LLU); | |
80632 | 81013 | LOCAL_PUSH_MOVE(&heap, 16LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
80633 | 81014 | } |
80634 | 81015 | // ACCUMULATE ARGUMENTS - END |
80635 | - uint64_t return_to = 18446744073709546460LLU; | |
81016 | + uint64_t return_to = 18446744073709546444LLU; | |
80636 | 81017 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 17LLU, 0/*address of closure-in-construction*/, 0)); |
80637 | 81018 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
80638 | 81019 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 17LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
80639 | 81020 | heap.data[0].elem1 = heap.data[0].elem0; |
80640 | 81021 | heap.data[0].elem0 = restore; |
80641 | - state.addr = 782701543315110336LLU; // parsecall_ | |
81022 | + state.addr = 787472338545441824LLU; // procrvalue | |
80642 | 81023 | break; |
80643 | 81024 | } |
80644 | - case 18446744073709546460LLU: // 99999998ta''''''''''''''' | |
81025 | + case 18446744073709546444LLU: // 99999998tL''''''''''''''' | |
80645 | 81026 | { |
80646 | - state.addr = 18446744073709546461LLU; // 99999998tb''''''''''''''' | |
81027 | + state.addr = 18446744073709546445LLU; // 99999998tM''''''''''''''' | |
80647 | 81028 | break; |
80648 | 81029 | } |
80649 | - case 18446744073709546461LLU: // 99999998tb''''''''''''''' | |
81030 | + case 18446744073709546445LLU: // 99999998tM''''''''''''''' | |
80650 | 81031 | { |
80651 | - // variable list<resdest___> newresults goes out of scope | |
81032 | + // variable list<resdest___> results___ goes out of scope | |
80652 | 81033 | // emitted destructur for type list<resdest___> |
80653 | - state.addr = 18446744073709546458LLU; // 99999998tZ''''''''''''''' | |
81034 | + state.addr = 18446744073709546442LLU; // 99999998tJ''''''''''''''' | |
80654 | 81035 | break; |
80655 | 81036 | } |
80656 | - case 18446744073709546458LLU: // 99999998tZ''''''''''''''' | |
81037 | + case 18446744073709546442LLU: // 99999998tJ''''''''''''''' | |
80657 | 81038 | { |
80658 | 81039 | if(!*LOCAL_ACCESS(heap.data, 22LLU, 21LLU)/*list*/) |
80659 | 81040 | { |
80660 | - state.addr = 18446744073709546459LLU; // 99999998t$''''''''''''''' | |
81041 | + state.addr = 18446744073709546443LLU; // 99999998tK''''''''''''''' | |
80661 | 81042 | break; |
80662 | 81043 | } |
80663 | 81044 | // temporary list-element |
@@ -80671,7 +81052,7 @@ | ||
80671 | 81052 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
80672 | 81053 | } |
80673 | 81054 | // ACCUMULATE ARGUMENTS - END |
80674 | - uint64_t return_to = 18446744073709546457LLU; | |
81055 | + uint64_t return_to = 18446744073709546441LLU; | |
80675 | 81056 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
80676 | 81057 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
80677 | 81058 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -80680,26 +81061,31 @@ | ||
80680 | 81061 | state.addr = 18446744073709551475LLU; // 999999997x''''''''''''''' |
80681 | 81062 | break; |
80682 | 81063 | } |
80683 | - case 18446744073709546457LLU: // 99999998tY''''''''''''''' | |
81064 | + case 18446744073709546441LLU: // 99999998tI''''''''''''''' | |
80684 | 81065 | { |
80685 | 81066 | // RELEASE temporary destructor-variable |
80686 | 81067 | (void)LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 23 |
80687 | - state.addr = 18446744073709546458LLU; // 99999998tZ''''''''''''''' | |
81068 | + state.addr = 18446744073709546442LLU; // 99999998tJ''''''''''''''' | |
80688 | 81069 | break; |
80689 | 81070 | } |
80690 | - case 18446744073709546459LLU: // 99999998t$''''''''''''''' | |
81071 | + case 18446744073709546443LLU: // 99999998tK''''''''''''''' | |
80691 | 81072 | { |
80692 | - (void)LOCAL_POP_MOVE(&heap, 22LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference newresults at 22 | |
80693 | - heap.availilable_size_for_dynamic_objects += 0LLU; | |
80694 | - heap.availilable_size_for_dynamic_objects += 0LLU; | |
80695 | - state.addr = 18446744073709546456LLU; // 99999998tX''''''''''''''' | |
81073 | + (void)LOCAL_POP_MOVE(&heap, 22LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference results___ at 22 | |
81074 | + // variable list<resdest___> newresults goes out of scope | |
81075 | + // emitted destructur for type list<resdest___> | |
81076 | + state.addr = 18446744073709546439LLU; // 99999998tG''''''''''''''' | |
80696 | 81077 | break; |
80697 | 81078 | } |
80698 | - case 18446744073709546465LLU: // 99999998tf''''''''''''''' | |
81079 | + case 18446744073709546439LLU: // 99999998tG''''''''''''''' | |
80699 | 81080 | { |
80700 | - fprintf(stdout, "%s", "\n swap(&"); | |
81081 | + if(!*LOCAL_ACCESS(heap.data, 21LLU, 20LLU)/*list*/) | |
80701 | 81082 | { |
80702 | - uint64_t arg = 0; | |
81083 | + state.addr = 18446744073709546440LLU; // 99999998tH''''''''''''''' | |
81084 | + break; | |
81085 | + } | |
81086 | + // temporary list-element | |
81087 | + { | |
81088 | + uint64_t arg = list_pop_move(&heap, &*LOCAL_ACCESS(heap.data, 21LLU, 20LLU)/*list*/, 8); | |
80703 | 81089 | LOCAL_PUSH_MOVE(&heap, 21, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
80704 | 81090 | } |
80705 | 81091 | // ACCUMULATE ARGUMENTS - BEGIN |
@@ -80708,410 +81094,36 @@ | ||
80708 | 81094 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
80709 | 81095 | } |
80710 | 81096 | // ACCUMULATE ARGUMENTS - END |
80711 | - uint64_t return_to = 18446744073709546454LLU; | |
81097 | + uint64_t return_to = 18446744073709546438LLU; | |
80712 | 81098 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
80713 | 81099 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
80714 | 81100 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
80715 | 81101 | heap.data[0].elem1 = heap.data[0].elem0; |
80716 | 81102 | heap.data[0].elem0 = restore; |
80717 | - state.addr = 861504796319285248LLU; // typeu64___ | |
81103 | + state.addr = 18446744073709551475LLU; // 999999997x''''''''''''''' | |
80718 | 81104 | break; |
80719 | 81105 | } |
80720 | - case 18446744073709546454LLU: // 99999998tV''''''''''''''' | |
81106 | + case 18446744073709546438LLU: // 99999998tF''''''''''''''' | |
80721 | 81107 | { |
80722 | - state.addr = 18446744073709546455LLU; // 99999998tW''''''''''''''' | |
80723 | - break; | |
80724 | - } | |
80725 | - case 18446744073709546455LLU: // 99999998tW''''''''''''''' | |
80726 | - { | |
80727 | - { | |
80728 | - uint64_t arg = 0; | |
80729 | - LOCAL_PUSH_MOVE(&heap, 22, &(heap.data[0].elem1)/*address of current closure*/, &arg); | |
81108 | + // RELEASE temporary destructor-variable | |
81109 | + (void)LOCAL_POP_MOVE(&heap, 22LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 22 | |
81110 | + state.addr = 18446744073709546439LLU; // 99999998tG''''''''''''''' | |
81111 | + break; | |
80730 | 81112 | } |
80731 | - *LOCAL_ACCESS(heap.data, 23LLU, 22LLU) = 0; | |
80732 | - { | |
80733 | - uint64_t arg = 0; | |
80734 | - LOCAL_PUSH_MOVE(&heap, 23, &(heap.data[0].elem1)/*address of current closure*/, &arg); | |
80735 | - } | |
80736 | - *LOCAL_ACCESS(heap.data, 24LLU, 23LLU) = 0; | |
80737 | - { | |
80738 | - uint64_t arg = 0; | |
80739 | - LOCAL_PUSH_MOVE(&heap, 24, &(heap.data[0].elem1)/*address of current closure*/, &arg); | |
80740 | - } | |
80741 | - *LOCAL_ACCESS(heap.data, 25LLU, 24LLU) = 0; | |
80742 | - { | |
80743 | - uint64_t arg = 0; | |
80744 | - LOCAL_PUSH_MOVE(&heap, 25, &(heap.data[0].elem1)/*address of current closure*/, &arg); | |
80745 | - } | |
80746 | - *LOCAL_ACCESS(heap.data, 26LLU, 25LLU) = 0; | |
80747 | - { | |
80748 | - uint64_t arg = 0; | |
80749 | - LOCAL_PUSH_MOVE(&heap, 26, &(heap.data[0].elem1)/*address of current closure*/, &arg); | |
80750 | - } | |
80751 | - *LOCAL_ACCESS(heap.data, 27LLU, 26LLU) = 0; | |
80752 | - { | |
80753 | - uint64_t arg = 0; | |
80754 | - LOCAL_PUSH_MOVE(&heap, 27, &(heap.data[0].elem1)/*address of current closure*/, &arg); | |
80755 | - } | |
80756 | - *LOCAL_ACCESS(heap.data, 28LLU, 27LLU) = 0; | |
80757 | - { | |
80758 | - uint64_t arg = 0; | |
80759 | - LOCAL_PUSH_MOVE(&heap, 28, &(heap.data[0].elem1)/*address of current closure*/, &arg); | |
80760 | - } | |
80761 | - *LOCAL_ACCESS(heap.data, 29LLU, 28LLU) = 0; | |
80762 | - // ACCUMULATE ARGUMENTS - BEGIN | |
80763 | - { | |
80764 | - uint64_t arg = /*def_id____*/*LOCAL_ACCESS(heap.data, 29LLU, 0LLU); | |
80765 | - LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
80766 | - } | |
80767 | - { | |
80768 | - uint64_t arg = /*blocklist_*/*LOCAL_ACCESS(heap.data, 29LLU, 8LLU); | |
80769 | - LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
80770 | - } | |
80771 | - { | |
80772 | - uint64_t arg = /*varlist___*/*LOCAL_ACCESS(heap.data, 29LLU, 9LLU); | |
80773 | - LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
80774 | - } | |
80775 | - { | |
80776 | - uint64_t arg = /*id1_______*/LOCAL_ACCESS_ADDR(heap.data, 29LLU, 20LLU); | |
80777 | - LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
80778 | - } | |
80779 | - { | |
80780 | - uint64_t arg = /*idx_______*/LOCAL_ACCESS_ADDR(heap.data, 29LLU, 26LLU); | |
80781 | - LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
80782 | - } | |
80783 | - { | |
80784 | - uint64_t arg = /*INDIRECT__*/LOCAL_ACCESS_ADDR(heap.data, 29LLU, 24LLU); | |
80785 | - LOCAL_PUSH_MOVE(&heap, 5LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
80786 | - } | |
80787 | - { | |
80788 | - uint64_t arg = /*typesrc___*/LOCAL_ACCESS_ADDR(heap.data, 29LLU, 21LLU); | |
80789 | - LOCAL_PUSH_MOVE(&heap, 6LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
80790 | - } | |
80791 | - { | |
80792 | - uint64_t arg = /*mutable___*/LOCAL_ACCESS_ADDR(heap.data, 29LLU, 23LLU); | |
80793 | - LOCAL_PUSH_MOVE(&heap, 7LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
80794 | - } | |
80795 | - { | |
80796 | - uint64_t arg = /*parameter_*/LOCAL_ACCESS_ADDR(heap.data, 29LLU, 25LLU); | |
80797 | - LOCAL_PUSH_MOVE(&heap, 8LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
80798 | - } | |
80799 | - { | |
80800 | - uint64_t arg = /*init1_____*/LOCAL_ACCESS_ADDR(heap.data, 29LLU, 22LLU); | |
80801 | - LOCAL_PUSH_MOVE(&heap, 9LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
80802 | - } | |
80803 | - { | |
80804 | - uint64_t arg = /*optelem___*/LOCAL_ACCESS_ADDR(heap.data, 29LLU, 27LLU); | |
80805 | - LOCAL_PUSH_MOVE(&heap, 10LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
80806 | - } | |
80807 | - { | |
80808 | - uint64_t arg = /*consume___*/LOCAL_ACCESS_ADDR(heap.data, 29LLU, 28LLU); | |
80809 | - LOCAL_PUSH_MOVE(&heap, 11LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
80810 | - } | |
80811 | - // ACCUMULATE ARGUMENTS - END | |
80812 | - uint64_t return_to = 18446744073709546451LLU; | |
80813 | - const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 12LLU, 0/*address of closure-in-construction*/, 0)); | |
80814 | - uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); | |
80815 | - *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 12LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; | |
80816 | - heap.data[0].elem1 = heap.data[0].elem0; | |
80817 | - heap.data[0].elem0 = restore; | |
80818 | - state.addr = 604790753280317473LLU; // findvarref | |
80819 | - break; | |
80820 | - } | |
80821 | - case 18446744073709546451LLU: // 99999998tS''''''''''''''' | |
81113 | + case 18446744073709546440LLU: // 99999998tH''''''''''''''' | |
80822 | 81114 | { |
80823 | - state.addr = 18446744073709546452LLU; // 99999998tT''''''''''''''' | |
80824 | - break; | |
80825 | - } | |
80826 | - case 18446744073709546452LLU: // 99999998tT''''''''''''''' | |
80827 | - { | |
80828 | - // ACCUMULATE ARGUMENTS - BEGIN | |
80829 | - { | |
80830 | - uint64_t arg = /*defargcnt_*/*LOCAL_ACCESS(heap.data, 29LLU, 12LLU); | |
80831 | - LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
80832 | - } | |
80833 | - { | |
80834 | - uint64_t arg = /*defbodysz_*/*LOCAL_ACCESS(heap.data, 29LLU, 13LLU); | |
80835 | - LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
80836 | - } | |
80837 | - { | |
80838 | - uint64_t arg = /*remainsize*/*LOCAL_ACCESS(heap.data, 29LLU, 14LLU); | |
80839 | - LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
80840 | - } | |
80841 | - { | |
80842 | - uint64_t arg = /*idx_______*/LOCAL_ACCESS_ADDR(heap.data, 29LLU, 26LLU); | |
80843 | - LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
80844 | - } | |
80845 | - { | |
80846 | - uint64_t arg = /*INDIRECT__*/LOCAL_ACCESS_ADDR(heap.data, 29LLU, 24LLU); | |
80847 | - LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
80848 | - } | |
80849 | - // ACCUMULATE ARGUMENTS - END | |
80850 | - uint64_t return_to = 18446744073709546449LLU; | |
80851 | - const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)); | |
80852 | - uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); | |
80853 | - *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; | |
80854 | - heap.data[0].elem1 = heap.data[0].elem0; | |
80855 | - heap.data[0].elem0 = restore; | |
80856 | - state.addr = 587881357514113024LLU; // emitpar___ | |
80857 | - break; | |
80858 | - } | |
80859 | - case 18446744073709546449LLU: // 99999998tQ''''''''''''''' | |
80860 | - { | |
80861 | - state.addr = 18446744073709546450LLU; // 99999998tR''''''''''''''' | |
80862 | - break; | |
80863 | - } | |
80864 | - case 18446744073709546450LLU: // 99999998tR''''''''''''''' | |
80865 | - { | |
80866 | - // variable u64 consume___ goes out of scope | |
80867 | - // emitted destructur for type u64 | |
80868 | - (void)LOCAL_POP_MOVE(&heap, 29LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference consume___ at 29 | |
80869 | - // variable u64 optelem___ goes out of scope | |
80870 | - // emitted destructur for type u64 | |
80871 | - (void)LOCAL_POP_MOVE(&heap, 28LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference optelem___ at 28 | |
80872 | - state.addr = 18446744073709546453LLU; // 99999998tU''''''''''''''' | |
80873 | - break; | |
80874 | - } | |
80875 | - case 18446744073709546453LLU: // 99999998tU''''''''''''''' | |
80876 | - { | |
80877 | - // ACCUMULATE ARGUMENTS - BEGIN | |
80878 | - { | |
80879 | - uint64_t arg = /*def_id____*/*LOCAL_ACCESS(heap.data, 27LLU, 0LLU); | |
80880 | - LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
80881 | - } | |
80882 | - { | |
80883 | - uint64_t arg = /*id1_______*/LOCAL_ACCESS_ADDR(heap.data, 27LLU, 20LLU); | |
80884 | - LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
80885 | - } | |
80886 | - { | |
80887 | - uint64_t arg = /*INDIRECT__*/LOCAL_ACCESS_ADDR(heap.data, 27LLU, 24LLU); | |
80888 | - LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
80889 | - } | |
80890 | - { | |
80891 | - uint64_t arg = /*mutable___*/LOCAL_ACCESS_ADDR(heap.data, 27LLU, 23LLU); | |
80892 | - LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
80893 | - } | |
80894 | - { | |
80895 | - uint64_t arg = /*parameter_*/LOCAL_ACCESS_ADDR(heap.data, 27LLU, 25LLU); | |
80896 | - LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
80897 | - } | |
80898 | - // ACCUMULATE ARGUMENTS - END | |
80899 | - uint64_t return_to = 18446744073709546447LLU; | |
80900 | - const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)); | |
80901 | - uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); | |
80902 | - *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; | |
80903 | - heap.data[0].elem1 = heap.data[0].elem0; | |
80904 | - heap.data[0].elem0 = restore; | |
80905 | - state.addr = 842862227159939072LLU; // swappable_ | |
80906 | - break; | |
80907 | - } | |
80908 | - case 18446744073709546447LLU: // 99999998tO''''''''''''''' | |
80909 | - { | |
81115 | + (void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference newresults at 21 | |
80910 | 81116 | state.addr = 18446744073709546448LLU; // 99999998tP''''''''''''''' |
80911 | 81117 | break; |
80912 | 81118 | } |
80913 | 81119 | case 18446744073709546448LLU: // 99999998tP''''''''''''''' |
80914 | 81120 | { |
80915 | - { | |
80916 | - uint64_t arg = 0; | |
80917 | - LOCAL_PUSH_MOVE(&heap, 27, &(heap.data[0].elem1)/*address of current closure*/, &arg); | |
80918 | - } | |
80919 | - *LOCAL_ACCESS(heap.data, 28LLU, 27LLU) = 819865187908583424; | |
80920 | - // ACCUMULATE ARGUMENTS - BEGIN | |
80921 | - { | |
80922 | - uint64_t arg = /*def_id____*/*LOCAL_ACCESS(heap.data, 28LLU, 0LLU); | |
80923 | - LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
80924 | - } | |
80925 | - { | |
80926 | - uint64_t arg = /*info______*/LOCAL_ACCESS_ADDR(heap.data, 28LLU, 27LLU); | |
80927 | - LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
80928 | - } | |
80929 | - { | |
80930 | - uint64_t arg = /*init1_____*/LOCAL_ACCESS_ADDR(heap.data, 28LLU, 22LLU); | |
80931 | - LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
80932 | - } | |
80933 | - { | |
80934 | - uint64_t arg = /*id1_______*/LOCAL_ACCESS_ADDR(heap.data, 28LLU, 20LLU); | |
80935 | - LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
80936 | - } | |
80937 | - // ACCUMULATE ARGUMENTS - END | |
80938 | - uint64_t return_to = 18446744073709546445LLU; | |
80939 | - const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); | |
80940 | - uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); | |
80941 | - *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; | |
80942 | - heap.data[0].elem1 = heap.data[0].elem0; | |
80943 | - heap.data[0].elem0 = restore; | |
80944 | - state.addr = 660220410725010287LLU; // initassert | |
80945 | - break; | |
80946 | - } | |
80947 | - case 18446744073709546445LLU: // 99999998tM''''''''''''''' | |
80948 | - { | |
80949 | - state.addr = 18446744073709546446LLU; // 99999998tN''''''''''''''' | |
80950 | - break; | |
80951 | - } | |
80952 | - case 18446744073709546446LLU: // 99999998tN''''''''''''''' | |
80953 | - { | |
80954 | - // ACCUMULATE ARGUMENTS - BEGIN | |
80955 | - { | |
80956 | - uint64_t arg = /*def_id____*/*LOCAL_ACCESS(heap.data, 28LLU, 0LLU); | |
80957 | - LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
80958 | - } | |
80959 | - { | |
80960 | - uint64_t arg = /*blocklist_*/*LOCAL_ACCESS(heap.data, 28LLU, 8LLU); | |
80961 | - LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
80962 | - } | |
80963 | - { | |
80964 | - uint64_t arg = /*varlist___*/*LOCAL_ACCESS(heap.data, 28LLU, 9LLU); | |
80965 | - LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
80966 | - } | |
80967 | - { | |
80968 | - uint64_t arg = /*id1_______*/LOCAL_ACCESS_ADDR(heap.data, 28LLU, 20LLU); | |
80969 | - LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
80970 | - } | |
80971 | - // ACCUMULATE ARGUMENTS - END | |
80972 | - uint64_t return_to = 18446744073709546443LLU; | |
80973 | - const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); | |
80974 | - uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); | |
80975 | - *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; | |
80976 | - heap.data[0].elem1 = heap.data[0].elem0; | |
80977 | - heap.data[0].elem0 = restore; | |
80978 | - state.addr = 732615645798520865LLU; // movevarref | |
80979 | - break; | |
80980 | - } | |
80981 | - case 18446744073709546443LLU: // 99999998tK''''''''''''''' | |
80982 | - { | |
80983 | - state.addr = 18446744073709546444LLU; // 99999998tL''''''''''''''' | |
80984 | - break; | |
80985 | - } | |
80986 | - case 18446744073709546444LLU: // 99999998tL''''''''''''''' | |
80987 | - { | |
80988 | - // ACCUMULATE ARGUMENTS - BEGIN | |
80989 | - { | |
80990 | - uint64_t arg = /*def_id____*/*LOCAL_ACCESS(heap.data, 28LLU, 0LLU); | |
80991 | - LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
80992 | - } | |
80993 | - { | |
80994 | - uint64_t arg = /*respar____*/tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 28LLU, 19LLU), 0LLU); | |
80995 | - LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
80996 | - } | |
80997 | - { | |
80998 | - uint64_t arg = /*typesrc___*/LOCAL_ACCESS_ADDR(heap.data, 28LLU, 21LLU); | |
80999 | - LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
81000 | - } | |
81001 | - // ACCUMULATE ARGUMENTS - END | |
81002 | - uint64_t return_to = 18446744073709546441LLU; | |
81003 | - const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)); | |
81004 | - uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); | |
81005 | - *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; | |
81006 | - heap.data[0].elem1 = heap.data[0].elem0; | |
81007 | - heap.data[0].elem0 = restore; | |
81008 | - state.addr = 861504774606556015LLU; // typeassert | |
81009 | - break; | |
81010 | - } | |
81011 | - case 18446744073709546441LLU: // 99999998tI''''''''''''''' | |
81012 | - { | |
81013 | - state.addr = 18446744073709546442LLU; // 99999998tJ''''''''''''''' | |
81014 | - break; | |
81015 | - } | |
81016 | - case 18446744073709546442LLU: // 99999998tJ''''''''''''''' | |
81017 | - { | |
81018 | - fprintf(stdout, "%s", ", &"); | |
81019 | - // ACCUMULATE ARGUMENTS - BEGIN | |
81020 | - { | |
81021 | - uint64_t arg = /*defargcnt_*/*LOCAL_ACCESS(heap.data, 28LLU, 12LLU); | |
81022 | - LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
81023 | - } | |
81024 | - { | |
81025 | - uint64_t arg = /*defbodysz_*/*LOCAL_ACCESS(heap.data, 28LLU, 13LLU); | |
81026 | - LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
81027 | - } | |
81028 | - { | |
81029 | - uint64_t arg = /*remainsize*/*LOCAL_ACCESS(heap.data, 28LLU, 14LLU); | |
81030 | - LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
81031 | - } | |
81032 | - { | |
81033 | - uint64_t arg = /*respar____*/tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 28LLU, 19LLU), 1LLU); | |
81034 | - LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
81035 | - } | |
81036 | - { | |
81037 | - uint64_t arg = /*respar____*/tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 28LLU, 19LLU), 2LLU); | |
81038 | - LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
81039 | - } | |
81040 | - // ACCUMULATE ARGUMENTS - END | |
81041 | - uint64_t return_to = 18446744073709546439LLU; | |
81042 | - const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)); | |
81043 | - uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); | |
81044 | - *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; | |
81045 | - heap.data[0].elem1 = heap.data[0].elem0; | |
81046 | - heap.data[0].elem0 = restore; | |
81047 | - state.addr = 587881357514113024LLU; // emitpar___ | |
81048 | - break; | |
81049 | - } | |
81050 | - case 18446744073709546439LLU: // 99999998tG''''''''''''''' | |
81051 | - { | |
81052 | - state.addr = 18446744073709546440LLU; // 99999998tH''''''''''''''' | |
81053 | - break; | |
81054 | - } | |
81055 | - case 18446744073709546440LLU: // 99999998tH''''''''''''''' | |
81056 | - { | |
81057 | - fprintf(stdout, "%s", "); // result"); | |
81058 | - // variable u64 info______ goes out of scope | |
81059 | - // emitted destructur for type u64 | |
81060 | - (void)LOCAL_POP_MOVE(&heap, 28LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference info______ at 28 | |
81061 | - // variable u64 idx_______ goes out of scope | |
81062 | - // emitted destructur for type u64 | |
81063 | - (void)LOCAL_POP_MOVE(&heap, 27LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference idx_______ at 27 | |
81064 | - // variable u64 parameter_ goes out of scope | |
81065 | - // emitted destructur for type u64 | |
81066 | - (void)LOCAL_POP_MOVE(&heap, 26LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference parameter_ at 26 | |
81067 | - // variable u64 INDIRECT__ goes out of scope | |
81068 | - // emitted destructur for type u64 | |
81069 | - (void)LOCAL_POP_MOVE(&heap, 25LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference INDIRECT__ at 25 | |
81070 | - // variable u64 mutable___ goes out of scope | |
81071 | - // emitted destructur for type u64 | |
81072 | - (void)LOCAL_POP_MOVE(&heap, 24LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference mutable___ at 24 | |
81073 | - // variable u64 init1_____ goes out of scope | |
81074 | - // emitted destructur for type u64 | |
81075 | - (void)LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference init1_____ at 23 | |
81076 | - // variable type______ typesrc___ goes out of scope | |
81077 | - // emitted destructur for type type______ | |
81078 | - // ACCUMULATE ARGUMENTS - BEGIN | |
81079 | - { | |
81080 | - uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 22LLU, 21LLU); | |
81081 | - LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
81082 | - } | |
81083 | - // ACCUMULATE ARGUMENTS - END | |
81084 | - uint64_t return_to = 18446744073709546438LLU; | |
81085 | - const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); | |
81086 | - uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); | |
81087 | - *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; | |
81088 | - heap.data[0].elem1 = heap.data[0].elem0; | |
81089 | - heap.data[0].elem0 = restore; | |
81090 | - state.addr = 18446744073709551534LLU; // 999999998s''''''''''''''' | |
81091 | - break; | |
81092 | - } | |
81093 | - case 18446744073709546438LLU: // 99999998tF''''''''''''''' | |
81094 | - { | |
81095 | - (void)LOCAL_POP_MOVE(&heap, 22LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference typesrc___ at 22 | |
81096 | - state.addr = 18446744073709546456LLU; // 99999998tX''''''''''''''' | |
81097 | - break; | |
81098 | - } | |
81099 | - case 18446744073709546456LLU: // 99999998tX''''''''''''''' | |
81100 | - { | |
81101 | - // variable u64 id1_______ goes out of scope | |
81102 | - // emitted destructur for type u64 | |
81103 | - (void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id1_______ at 21 | |
81104 | - state.addr = 18446744073709546471LLU; // 99999998tl''''''''''''''' | |
81105 | - break; | |
81106 | - } | |
81107 | - case 18446744073709546471LLU: // 99999998tl''''''''''''''' | |
81108 | - { | |
81109 | 81121 | // parameter-reference resdest___ respar____ goes out of scope |
81110 | 81122 | // parameter-reference list<resdest___> results___ goes out of scope |
81111 | - state.addr = 18446744073709546492LLU; // 99999998t6''''''''''''''' | |
81123 | + state.addr = 18446744073709546469LLU; // 99999998tj''''''''''''''' | |
81112 | 81124 | break; |
81113 | 81125 | } |
81114 | - case 18446744073709546491LLU: // 99999998t5''''''''''''''' | |
81126 | + case 18446744073709546468LLU: // 99999998ti''''''''''''''' | |
81115 | 81127 | { |
81116 | 81128 | // ACCUMULATE ARGUMENTS - BEGIN |
81117 | 81129 | { |
@@ -81144,7 +81156,7 @@ | ||
81144 | 81156 | state.addr = 18446744073709546435LLU; // 99999998tC''''''''''''''' |
81145 | 81157 | break; |
81146 | 81158 | } |
81147 | - case 18446744073709546493LLU: // 99999998t7''''''''''''''' | |
81159 | + case 18446744073709546470LLU: // 99999998tk''''''''''''''' | |
81148 | 81160 | { |
81149 | 81161 | // ACCUMULATE ARGUMENTS - BEGIN |
81150 | 81162 | { |
@@ -81225,10 +81237,10 @@ | ||
81225 | 81237 | } |
81226 | 81238 | case 18446744073709546435LLU: // 99999998tC''''''''''''''' |
81227 | 81239 | { |
81228 | - state.addr = 18446744073709546495LLU; // 99999998t9''''''''''''''' | |
81240 | + state.addr = 18446744073709546472LLU; // 99999998tm''''''''''''''' | |
81229 | 81241 | break; |
81230 | 81242 | } |
81231 | - case 18446744073709546495LLU: // 99999998t9''''''''''''''' | |
81243 | + case 18446744073709546472LLU: // 99999998tm''''''''''''''' | |
81232 | 81244 | { |
81233 | 81245 | // ACCUMULATE ARGUMENTS - BEGIN |
81234 | 81246 | { |
@@ -82933,6 +82945,305 @@ | ||
82933 | 82945 | } |
82934 | 82946 | break; |
82935 | 82947 | } |
82948 | + case 787411865375803879LLU: // prasrtnull | |
82949 | + { | |
82950 | + // ACCUMULATE ARGUMENTS - BEGIN | |
82951 | + { | |
82952 | + uint64_t arg = /*c_________*/*LOCAL_ACCESS(heap.data, 8LLU, 7LLU); | |
82953 | + LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
82954 | + } | |
82955 | + // ACCUMULATE ARGUMENTS - END | |
82956 | + uint64_t return_to = 18446744073709546327LLU; | |
82957 | + const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); | |
82958 | + uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); | |
82959 | + *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; | |
82960 | + heap.data[0].elem1 = heap.data[0].elem0; | |
82961 | + heap.data[0].elem0 = restore; | |
82962 | + state.addr = 839519665163075584LLU; // skip______ | |
82963 | + break; | |
82964 | + } | |
82965 | + case 18446744073709546327LLU: // 99999998rW''''''''''''''' | |
82966 | + { | |
82967 | + state.addr = 18446744073709546328LLU; // 99999998rX''''''''''''''' | |
82968 | + break; | |
82969 | + } | |
82970 | + case 18446744073709546328LLU: // 99999998rX''''''''''''''' | |
82971 | + { | |
82972 | + { | |
82973 | + uint64_t arg = 0; | |
82974 | + LOCAL_PUSH_MOVE(&heap, 8, &(heap.data[0].elem1)/*address of current closure*/, &arg); | |
82975 | + } | |
82976 | + *LOCAL_ACCESS(heap.data, 9LLU, 8LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 9LLU, 7LLU))); | |
82977 | + state.addr = 18446744073709546326LLU; // 99999998rV''''''''''''''' | |
82978 | + break; | |
82979 | + } | |
82980 | + case 18446744073709546326LLU: // 99999998rV''''''''''''''' | |
82981 | + { | |
82982 | + { | |
82983 | + uint64_t arg = 0; | |
82984 | + LOCAL_PUSH_MOVE(&heap, 9, &(heap.data[0].elem1)/*address of current closure*/, &arg); | |
82985 | + } | |
82986 | + // ACCUMULATE ARGUMENTS - BEGIN | |
82987 | + { | |
82988 | + uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 10LLU, 9LLU); | |
82989 | + LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
82990 | + } | |
82991 | + // ACCUMULATE ARGUMENTS - END | |
82992 | + uint64_t return_to = 18446744073709546324LLU; | |
82993 | + const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); | |
82994 | + uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); | |
82995 | + *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; | |
82996 | + heap.data[0].elem1 = heap.data[0].elem0; | |
82997 | + heap.data[0].elem0 = restore; | |
82998 | + state.addr = 861504796319285248LLU; // typeu64___ | |
82999 | + break; | |
83000 | + } | |
83001 | + case 18446744073709546324LLU: // 99999998rT''''''''''''''' | |
83002 | + { | |
83003 | + state.addr = 18446744073709546325LLU; // 99999998rU''''''''''''''' | |
83004 | + break; | |
83005 | + } | |
83006 | + case 18446744073709546325LLU: // 99999998rU''''''''''''''' | |
83007 | + { | |
83008 | + { | |
83009 | + uint64_t arg = 0; | |
83010 | + LOCAL_PUSH_MOVE(&heap, 10, &(heap.data[0].elem1)/*address of current closure*/, &arg); | |
83011 | + } | |
83012 | + *LOCAL_ACCESS(heap.data, 11LLU, 10LLU) = 0; | |
83013 | + { | |
83014 | + uint64_t arg = 0; | |
83015 | + LOCAL_PUSH_MOVE(&heap, 11, &(heap.data[0].elem1)/*address of current closure*/, &arg); | |
83016 | + } | |
83017 | + *LOCAL_ACCESS(heap.data, 12LLU, 11LLU) = 0; | |
83018 | + { | |
83019 | + uint64_t arg = 0; | |
83020 | + LOCAL_PUSH_MOVE(&heap, 12, &(heap.data[0].elem1)/*address of current closure*/, &arg); | |
83021 | + } | |
83022 | + *LOCAL_ACCESS(heap.data, 13LLU, 12LLU) = 0; | |
83023 | + { | |
83024 | + uint64_t arg = 0; | |
83025 | + LOCAL_PUSH_MOVE(&heap, 13, &(heap.data[0].elem1)/*address of current closure*/, &arg); | |
83026 | + } | |
83027 | + *LOCAL_ACCESS(heap.data, 14LLU, 13LLU) = 0; | |
83028 | + { | |
83029 | + uint64_t arg = 0; | |
83030 | + LOCAL_PUSH_MOVE(&heap, 14, &(heap.data[0].elem1)/*address of current closure*/, &arg); | |
83031 | + } | |
83032 | + *LOCAL_ACCESS(heap.data, 15LLU, 14LLU) = 0; | |
83033 | + { | |
83034 | + uint64_t arg = 0; | |
83035 | + LOCAL_PUSH_MOVE(&heap, 15, &(heap.data[0].elem1)/*address of current closure*/, &arg); | |
83036 | + } | |
83037 | + *LOCAL_ACCESS(heap.data, 16LLU, 15LLU) = 0; | |
83038 | + { | |
83039 | + uint64_t arg = 0; | |
83040 | + LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/*address of current closure*/, &arg); | |
83041 | + } | |
83042 | + *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = 0; | |
83043 | + // ACCUMULATE ARGUMENTS - BEGIN | |
83044 | + { | |
83045 | + uint64_t arg = /*def_id____*/*LOCAL_ACCESS(heap.data, 17LLU, 0LLU); | |
83046 | + LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
83047 | + } | |
83048 | + { | |
83049 | + uint64_t arg = /*blocklist_*/*LOCAL_ACCESS(heap.data, 17LLU, 5LLU); | |
83050 | + LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
83051 | + } | |
83052 | + { | |
83053 | + uint64_t arg = /*varlist___*/*LOCAL_ACCESS(heap.data, 17LLU, 6LLU); | |
83054 | + LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
83055 | + } | |
83056 | + { | |
83057 | + uint64_t arg = /*id________*/LOCAL_ACCESS_ADDR(heap.data, 17LLU, 8LLU); | |
83058 | + LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
83059 | + } | |
83060 | + { | |
83061 | + uint64_t arg = /*dstidx____*/LOCAL_ACCESS_ADDR(heap.data, 17LLU, 11LLU); | |
83062 | + LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
83063 | + } | |
83064 | + { | |
83065 | + uint64_t arg = /*INDIRECT__*/LOCAL_ACCESS_ADDR(heap.data, 17LLU, 10LLU); | |
83066 | + LOCAL_PUSH_MOVE(&heap, 5LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
83067 | + } | |
83068 | + { | |
83069 | + uint64_t arg = /*TYPEDST___*/LOCAL_ACCESS_ADDR(heap.data, 17LLU, 9LLU); | |
83070 | + LOCAL_PUSH_MOVE(&heap, 6LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
83071 | + } | |
83072 | + { | |
83073 | + uint64_t arg = /*mutable___*/LOCAL_ACCESS_ADDR(heap.data, 17LLU, 13LLU); | |
83074 | + LOCAL_PUSH_MOVE(&heap, 7LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
83075 | + } | |
83076 | + { | |
83077 | + uint64_t arg = /*parameter_*/LOCAL_ACCESS_ADDR(heap.data, 17LLU, 14LLU); | |
83078 | + LOCAL_PUSH_MOVE(&heap, 8LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
83079 | + } | |
83080 | + { | |
83081 | + uint64_t arg = /*initialize*/LOCAL_ACCESS_ADDR(heap.data, 17LLU, 12LLU); | |
83082 | + LOCAL_PUSH_MOVE(&heap, 9LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
83083 | + } | |
83084 | + { | |
83085 | + uint64_t arg = /*optelem___*/LOCAL_ACCESS_ADDR(heap.data, 17LLU, 15LLU); | |
83086 | + LOCAL_PUSH_MOVE(&heap, 10LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
83087 | + } | |
83088 | + { | |
83089 | + uint64_t arg = /*consume___*/LOCAL_ACCESS_ADDR(heap.data, 17LLU, 16LLU); | |
83090 | + LOCAL_PUSH_MOVE(&heap, 11LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
83091 | + } | |
83092 | + // ACCUMULATE ARGUMENTS - END | |
83093 | + uint64_t return_to = 18446744073709546321LLU; | |
83094 | + const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 12LLU, 0/*address of closure-in-construction*/, 0)); | |
83095 | + uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); | |
83096 | + *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 12LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; | |
83097 | + heap.data[0].elem1 = heap.data[0].elem0; | |
83098 | + heap.data[0].elem0 = restore; | |
83099 | + state.addr = 604790753280317473LLU; // findvarref | |
83100 | + break; | |
83101 | + } | |
83102 | + case 18446744073709546321LLU: // 99999998rQ''''''''''''''' | |
83103 | + { | |
83104 | + state.addr = 18446744073709546322LLU; // 99999998rR''''''''''''''' | |
83105 | + break; | |
83106 | + } | |
83107 | + case 18446744073709546322LLU: // 99999998rR''''''''''''''' | |
83108 | + { | |
83109 | + // variable u64 consume___ goes out of scope | |
83110 | + // emitted destructur for type u64 | |
83111 | + (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference consume___ at 17 | |
83112 | + // variable u64 optelem___ goes out of scope | |
83113 | + // emitted destructur for type u64 | |
83114 | + (void)LOCAL_POP_MOVE(&heap, 16LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference optelem___ at 16 | |
83115 | + state.addr = 18446744073709546323LLU; // 99999998rS''''''''''''''' | |
83116 | + break; | |
83117 | + } | |
83118 | + case 18446744073709546323LLU: // 99999998rS''''''''''''''' | |
83119 | + { | |
83120 | + state.addr = *LOCAL_ACCESS(heap.data, 15LLU, 12LLU) ? 18446744073709546320LLU : 18446744073709546319LLU; | |
83121 | + break; | |
83122 | + } | |
83123 | + case 18446744073709546320LLU: // 99999998rP''''''''''''''' | |
83124 | + { | |
83125 | + // ACCUMULATE ARGUMENTS - BEGIN | |
83126 | + { | |
83127 | + uint64_t arg = /*def_id____*/*LOCAL_ACCESS(heap.data, 15LLU, 0LLU); | |
83128 | + LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
83129 | + } | |
83130 | + // ACCUMULATE ARGUMENTS - END | |
83131 | + uint64_t return_to = 18446744073709546317LLU; | |
83132 | + const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); | |
83133 | + uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); | |
83134 | + *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; | |
83135 | + heap.data[0].elem1 = heap.data[0].elem0; | |
83136 | + heap.data[0].elem0 = restore; | |
83137 | + state.addr = 819847183515949359LLU; // reportinit | |
83138 | + break; | |
83139 | + } | |
83140 | + case 18446744073709546317LLU: // 99999998rM''''''''''''''' | |
83141 | + { | |
83142 | + state.addr = 18446744073709546318LLU; // 99999998rN''''''''''''''' | |
83143 | + break; | |
83144 | + } | |
83145 | + case 18446744073709546318LLU: // 99999998rN''''''''''''''' | |
83146 | + { | |
83147 | + fprintf(stderr, "%s", "assert failed: variable "); | |
83148 | + // ACCUMULATE ARGUMENTS - BEGIN | |
83149 | + { | |
83150 | + uint64_t arg = /*TYPEDST___*/LOCAL_ACCESS_ADDR(heap.data, 15LLU, 9LLU); | |
83151 | + LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
83152 | + } | |
83153 | + // ACCUMULATE ARGUMENTS - END | |
83154 | + uint64_t return_to = 18446744073709546315LLU; | |
83155 | + const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); | |
83156 | + uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); | |
83157 | + *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; | |
83158 | + heap.data[0].elem1 = heap.data[0].elem0; | |
83159 | + heap.data[0].elem0 = restore; | |
83160 | + state.addr = 819847183518878432LLU; // reporttype | |
83161 | + break; | |
83162 | + } | |
83163 | + case 18446744073709546315LLU: // 99999998rK''''''''''''''' | |
83164 | + { | |
83165 | + state.addr = 18446744073709546316LLU; // 99999998rL''''''''''''''' | |
83166 | + break; | |
83167 | + } | |
83168 | + case 18446744073709546316LLU: // 99999998rL''''''''''''''' | |
83169 | + { | |
83170 | + printid(stderr, /*id________*/*LOCAL_ACCESS(heap.data, 15LLU, 8LLU)); | |
83171 | + fprintf(stderr, "%s", " not empty"); | |
83172 | + { | |
83173 | + fprintf(stderr, "%s\n", ""); | |
83174 | + exit(-1); | |
83175 | + } | |
83176 | + { | |
83177 | + fprintf(stderr, "%s\n", ""); | |
83178 | + exit(-1); | |
83179 | + } | |
83180 | + state.addr = 18446744073709546319LLU; // 99999998rO''''''''''''''' | |
83181 | + break; | |
83182 | + } | |
83183 | + case 18446744073709546319LLU: // 99999998rO''''''''''''''' | |
83184 | + { | |
83185 | + // variable u64 parameter_ goes out of scope | |
83186 | + // emitted destructur for type u64 | |
83187 | + (void)LOCAL_POP_MOVE(&heap, 15LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference parameter_ at 15 | |
83188 | + // variable u64 mutable___ goes out of scope | |
83189 | + // emitted destructur for type u64 | |
83190 | + (void)LOCAL_POP_MOVE(&heap, 14LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference mutable___ at 14 | |
83191 | + // variable u64 initialize goes out of scope | |
83192 | + // emitted destructur for type u64 | |
83193 | + (void)LOCAL_POP_MOVE(&heap, 13LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference initialize at 13 | |
83194 | + // variable u64 dstidx____ goes out of scope | |
83195 | + // emitted destructur for type u64 | |
83196 | + (void)LOCAL_POP_MOVE(&heap, 12LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference dstidx____ at 12 | |
83197 | + // variable u64 INDIRECT__ goes out of scope | |
83198 | + // emitted destructur for type u64 | |
83199 | + (void)LOCAL_POP_MOVE(&heap, 11LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference INDIRECT__ at 11 | |
83200 | + // variable type______ TYPEDST___ goes out of scope | |
83201 | + // emitted destructur for type type______ | |
83202 | + // ACCUMULATE ARGUMENTS - BEGIN | |
83203 | + { | |
83204 | + uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 10LLU, 9LLU); | |
83205 | + LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
83206 | + } | |
83207 | + // ACCUMULATE ARGUMENTS - END | |
83208 | + uint64_t return_to = 18446744073709546314LLU; | |
83209 | + const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); | |
83210 | + uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); | |
83211 | + *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; | |
83212 | + heap.data[0].elem1 = heap.data[0].elem0; | |
83213 | + heap.data[0].elem0 = restore; | |
83214 | + state.addr = 18446744073709551534LLU; // 999999998s''''''''''''''' | |
83215 | + break; | |
83216 | + } | |
83217 | + case 18446744073709546314LLU: // 99999998rJ''''''''''''''' | |
83218 | + { | |
83219 | + (void)LOCAL_POP_MOVE(&heap, 10LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference TYPEDST___ at 10 | |
83220 | + // variable u64 id________ goes out of scope | |
83221 | + // emitted destructur for type u64 | |
83222 | + (void)LOCAL_POP_MOVE(&heap, 9LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id________ at 9 | |
83223 | + // parameter-reference u64 c_________ goes out of scope | |
83224 | + (void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference c_________ at 8 | |
83225 | + // parameter-reference list<varentry__> varlist___ goes out of scope | |
83226 | + (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference varlist___ at 7 | |
83227 | + // parameter-reference list<block_____> blocklist_ goes out of scope | |
83228 | + (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference blocklist_ at 6 | |
83229 | + // parameter-reference list<typedef___> typedefs__ goes out of scope | |
83230 | + (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference typedefs__ at 5 | |
83231 | + // parameter-reference u64 finite____ goes out of scope | |
83232 | + (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference finite____ at 4 | |
83233 | + // parameter-reference u64 complete__ goes out of scope | |
83234 | + (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference complete__ at 3 | |
83235 | + // parameter-reference u64 tmpaddr___ goes out of scope | |
83236 | + (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference tmpaddr___ at 2 | |
83237 | + // parameter-reference u64 def_id____ goes out of scope | |
83238 | + (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference def_id____ at 1 | |
83239 | + { | |
83240 | + uint64_t baseinfo = heap.data[0].elem1; | |
83241 | + struct pair pair = unpair(&heap, &baseinfo); | |
83242 | + *access_heap(heap.data, 1/*memory root*/) = pair.elem0; | |
83243 | + state.addr = pair.elem1; | |
83244 | + } | |
83245 | + break; | |
83246 | + } | |
82936 | 83247 | case 787472320246204585LLU: // procassign |
82937 | 83248 | { |
82938 | 83249 | { |
@@ -82965,7 +83276,7 @@ | ||
82965 | 83276 | LOCAL_PUSH_MOVE(&heap, 5LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
82966 | 83277 | } |
82967 | 83278 | // ACCUMULATE ARGUMENTS - END |
82968 | - uint64_t return_to = 18446744073709546327LLU; | |
83279 | + uint64_t return_to = 18446744073709546312LLU; | |
82969 | 83280 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 6LLU, 0/*address of closure-in-construction*/, 0)); |
82970 | 83281 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
82971 | 83282 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 6LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -82974,12 +83285,12 @@ | ||
82974 | 83285 | state.addr = 533581901922699840LLU; // blockopen_ |
82975 | 83286 | break; |
82976 | 83287 | } |
82977 | - case 18446744073709546327LLU: // 99999998rW''''''''''''''' | |
83288 | + case 18446744073709546312LLU: // 99999998rH''''''''''''''' | |
82978 | 83289 | { |
82979 | - state.addr = 18446744073709546328LLU; // 99999998rX''''''''''''''' | |
83290 | + state.addr = 18446744073709546313LLU; // 99999998rI''''''''''''''' | |
82980 | 83291 | break; |
82981 | 83292 | } |
82982 | - case 18446744073709546328LLU: // 99999998rX''''''''''''''' | |
83293 | + case 18446744073709546313LLU: // 99999998rI''''''''''''''' | |
82983 | 83294 | { |
82984 | 83295 | { |
82985 | 83296 | uint64_t arg = 0; |
@@ -83055,7 +83366,7 @@ | ||
83055 | 83366 | LOCAL_PUSH_MOVE(&heap, 16LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
83056 | 83367 | } |
83057 | 83368 | // ACCUMULATE ARGUMENTS - END |
83058 | - uint64_t return_to = 18446744073709546325LLU; | |
83369 | + uint64_t return_to = 18446744073709546310LLU; | |
83059 | 83370 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 17LLU, 0/*address of closure-in-construction*/, 0)); |
83060 | 83371 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
83061 | 83372 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 17LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -83064,12 +83375,12 @@ | ||
83064 | 83375 | state.addr = 782742327813734400LLU; // pa1_______ |
83065 | 83376 | break; |
83066 | 83377 | } |
83067 | - case 18446744073709546325LLU: // 99999998rU''''''''''''''' | |
83378 | + case 18446744073709546310LLU: // 99999998rF''''''''''''''' | |
83068 | 83379 | { |
83069 | - state.addr = 18446744073709546326LLU; // 99999998rV''''''''''''''' | |
83380 | + state.addr = 18446744073709546311LLU; // 99999998rG''''''''''''''' | |
83070 | 83381 | break; |
83071 | 83382 | } |
83072 | - case 18446744073709546326LLU: // 99999998rV''''''''''''''' | |
83383 | + case 18446744073709546311LLU: // 99999998rG''''''''''''''' | |
83073 | 83384 | { |
83074 | 83385 | list_reverse(heap.data, &/*newresults*/*LOCAL_ACCESS(heap.data, 19LLU, 18LLU)); |
83075 | 83386 | { |
@@ -83133,7 +83444,7 @@ | ||
83133 | 83444 | LOCAL_PUSH_MOVE(&heap, 10LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
83134 | 83445 | } |
83135 | 83446 | // ACCUMULATE ARGUMENTS - END |
83136 | - uint64_t return_to = 18446744073709546322LLU; | |
83447 | + uint64_t return_to = 18446744073709546307LLU; | |
83137 | 83448 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 11LLU, 0/*address of closure-in-construction*/, 0)); |
83138 | 83449 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
83139 | 83450 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 11LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -83142,17 +83453,17 @@ | ||
83142 | 83453 | state.addr = 533581901720365984LLU; // blockclose |
83143 | 83454 | break; |
83144 | 83455 | } |
83145 | - case 18446744073709546322LLU: // 99999998rR''''''''''''''' | |
83456 | + case 18446744073709546307LLU: // 99999998rC''''''''''''''' | |
83146 | 83457 | { |
83147 | - state.addr = 18446744073709546323LLU; // 99999998rS''''''''''''''' | |
83458 | + state.addr = 18446744073709546308LLU; // 99999998rD''''''''''''''' | |
83148 | 83459 | break; |
83149 | 83460 | } |
83150 | - case 18446744073709546323LLU: // 99999998rS''''''''''''''' | |
83461 | + case 18446744073709546308LLU: // 99999998rD''''''''''''''' | |
83151 | 83462 | { |
83152 | - state.addr = *LOCAL_ACCESS(heap.data, 22LLU, 17LLU) ? 18446744073709546321LLU : 18446744073709546320LLU; | |
83463 | + state.addr = *LOCAL_ACCESS(heap.data, 22LLU, 17LLU) ? 18446744073709546306LLU : 18446744073709546305LLU; | |
83153 | 83464 | break; |
83154 | 83465 | } |
83155 | - case 18446744073709546321LLU: // 99999998rQ''''''''''''''' | |
83466 | + case 18446744073709546306LLU: // 99999998rB''''''''''''''' | |
83156 | 83467 | { |
83157 | 83468 | fprintf(stderr, "%s", "INTERNAL ERROR: tmpresults"); |
83158 | 83469 | { |
@@ -83159,10 +83470,10 @@ | ||
83159 | 83470 | fprintf(stderr, "%s\n", ""); |
83160 | 83471 | exit(-1); |
83161 | 83472 | } |
83162 | - state.addr = 18446744073709546320LLU; // 99999998rP''''''''''''''' | |
83473 | + state.addr = 18446744073709546305LLU; // 99999998rA''''''''''''''' | |
83163 | 83474 | break; |
83164 | 83475 | } |
83165 | - case 18446744073709546320LLU: // 99999998rP''''''''''''''' | |
83476 | + case 18446744073709546305LLU: // 99999998rA''''''''''''''' | |
83166 | 83477 | { |
83167 | 83478 | { |
83168 | 83479 | uint64_t arg = 0; |
@@ -83169,16 +83480,16 @@ | ||
83169 | 83480 | LOCAL_PUSH_MOVE(&heap, 22, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
83170 | 83481 | } |
83171 | 83482 | *LOCAL_ACCESS(heap.data, 23LLU, 22LLU) = /*defbodysz_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 23LLU, 14LLU)) != /*ds________*/*LOCAL_ACCESS(heap.data, 23LLU, 19LLU); |
83172 | - state.addr = 18446744073709546317LLU; // 99999998rM''''''''''''''' | |
83483 | + state.addr = 18446744073709546302LLU; // 99999998q8''''''''''''''' | |
83173 | 83484 | break; |
83174 | 83485 | } |
83175 | - case 18446744073709546317LLU: // 99999998rM''''''''''''''' | |
83486 | + case 18446744073709546302LLU: // 99999998q8''''''''''''''' | |
83176 | 83487 | { |
83177 | - state.addr = *LOCAL_ACCESS(heap.data, 23LLU, 22LLU) ? 18446744073709546319LLU : 18446744073709546318LLU; | |
83488 | + state.addr = *LOCAL_ACCESS(heap.data, 23LLU, 22LLU) ? 18446744073709546304LLU : 18446744073709546303LLU; | |
83178 | 83489 | (void)LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 23 |
83179 | 83490 | break; |
83180 | 83491 | } |
83181 | - case 18446744073709546319LLU: // 99999998rO''''''''''''''' | |
83492 | + case 18446744073709546304LLU: // 99999998r_''''''''''''''' | |
83182 | 83493 | { |
83183 | 83494 | fprintf(stderr, "%s", "INTERNAL ERROR: defbodysz mismatch "); |
83184 | 83495 | // ACCUMULATE ARGUMENTS - BEGIN |
@@ -83187,7 +83498,7 @@ | ||
83187 | 83498 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
83188 | 83499 | } |
83189 | 83500 | // ACCUMULATE ARGUMENTS - END |
83190 | - uint64_t return_to = 18446744073709546315LLU; | |
83501 | + uint64_t return_to = 18446744073709546300LLU; | |
83191 | 83502 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
83192 | 83503 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
83193 | 83504 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -83196,12 +83507,12 @@ | ||
83196 | 83507 | state.addr = 819847183517274112LLU; // reportnr__ |
83197 | 83508 | break; |
83198 | 83509 | } |
83199 | - case 18446744073709546315LLU: // 99999998rK''''''''''''''' | |
83510 | + case 18446744073709546300LLU: // 99999998q6''''''''''''''' | |
83200 | 83511 | { |
83201 | - state.addr = 18446744073709546316LLU; // 99999998rL''''''''''''''' | |
83512 | + state.addr = 18446744073709546301LLU; // 99999998q7''''''''''''''' | |
83202 | 83513 | break; |
83203 | 83514 | } |
83204 | - case 18446744073709546316LLU: // 99999998rL''''''''''''''' | |
83515 | + case 18446744073709546301LLU: // 99999998q7''''''''''''''' | |
83205 | 83516 | { |
83206 | 83517 | fprintf(stderr, "%s", " != "); |
83207 | 83518 | // ACCUMULATE ARGUMENTS - BEGIN |
@@ -83210,7 +83521,7 @@ | ||
83210 | 83521 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
83211 | 83522 | } |
83212 | 83523 | // ACCUMULATE ARGUMENTS - END |
83213 | - uint64_t return_to = 18446744073709546313LLU; | |
83524 | + uint64_t return_to = 18446744073709546298LLU; | |
83214 | 83525 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
83215 | 83526 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
83216 | 83527 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -83219,21 +83530,21 @@ | ||
83219 | 83530 | state.addr = 819847183517274112LLU; // reportnr__ |
83220 | 83531 | break; |
83221 | 83532 | } |
83222 | - case 18446744073709546313LLU: // 99999998rI''''''''''''''' | |
83533 | + case 18446744073709546298LLU: // 99999998q4''''''''''''''' | |
83223 | 83534 | { |
83224 | - state.addr = 18446744073709546314LLU; // 99999998rJ''''''''''''''' | |
83535 | + state.addr = 18446744073709546299LLU; // 99999998q5''''''''''''''' | |
83225 | 83536 | break; |
83226 | 83537 | } |
83227 | - case 18446744073709546314LLU: // 99999998rJ''''''''''''''' | |
83538 | + case 18446744073709546299LLU: // 99999998q5''''''''''''''' | |
83228 | 83539 | { |
83229 | 83540 | { |
83230 | 83541 | fprintf(stderr, "%s\n", ""); |
83231 | 83542 | exit(-1); |
83232 | 83543 | } |
83233 | - state.addr = 18446744073709546318LLU; // 99999998rN''''''''''''''' | |
83544 | + state.addr = 18446744073709546303LLU; // 99999998q9''''''''''''''' | |
83234 | 83545 | break; |
83235 | 83546 | } |
83236 | - case 18446744073709546318LLU: // 99999998rN''''''''''''''' | |
83547 | + case 18446744073709546303LLU: // 99999998q9''''''''''''''' | |
83237 | 83548 | { |
83238 | 83549 | { |
83239 | 83550 | uint64_t arg = 0; |
@@ -83240,16 +83551,16 @@ | ||
83240 | 83551 | LOCAL_PUSH_MOVE(&heap, 22, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
83241 | 83552 | } |
83242 | 83553 | *LOCAL_ACCESS(heap.data, 23LLU, 22LLU) = /*remainsize*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 23LLU, 15LLU)) != /*rs________*/*LOCAL_ACCESS(heap.data, 23LLU, 20LLU); |
83243 | - state.addr = 18446744073709546310LLU; // 99999998rF''''''''''''''' | |
83554 | + state.addr = 18446744073709546295LLU; // 99999998q1''''''''''''''' | |
83244 | 83555 | break; |
83245 | 83556 | } |
83246 | - case 18446744073709546310LLU: // 99999998rF''''''''''''''' | |
83557 | + case 18446744073709546295LLU: // 99999998q1''''''''''''''' | |
83247 | 83558 | { |
83248 | - state.addr = *LOCAL_ACCESS(heap.data, 23LLU, 22LLU) ? 18446744073709546312LLU : 18446744073709546311LLU; | |
83559 | + state.addr = *LOCAL_ACCESS(heap.data, 23LLU, 22LLU) ? 18446744073709546297LLU : 18446744073709546296LLU; | |
83249 | 83560 | (void)LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 23 |
83250 | 83561 | break; |
83251 | 83562 | } |
83252 | - case 18446744073709546312LLU: // 99999998rH''''''''''''''' | |
83563 | + case 18446744073709546297LLU: // 99999998q3''''''''''''''' | |
83253 | 83564 | { |
83254 | 83565 | fprintf(stderr, "%s", "INTERNAL ERROR: remainsize mismatch "); |
83255 | 83566 | // ACCUMULATE ARGUMENTS - BEGIN |
@@ -83258,7 +83569,7 @@ | ||
83258 | 83569 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
83259 | 83570 | } |
83260 | 83571 | // ACCUMULATE ARGUMENTS - END |
83261 | - uint64_t return_to = 18446744073709546308LLU; | |
83572 | + uint64_t return_to = 18446744073709546293LLU; | |
83262 | 83573 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
83263 | 83574 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
83264 | 83575 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -83267,12 +83578,12 @@ | ||
83267 | 83578 | state.addr = 819847183517274112LLU; // reportnr__ |
83268 | 83579 | break; |
83269 | 83580 | } |
83270 | - case 18446744073709546308LLU: // 99999998rD''''''''''''''' | |
83581 | + case 18446744073709546293LLU: // 99999998qz''''''''''''''' | |
83271 | 83582 | { |
83272 | - state.addr = 18446744073709546309LLU; // 99999998rE''''''''''''''' | |
83583 | + state.addr = 18446744073709546294LLU; // 99999998q0''''''''''''''' | |
83273 | 83584 | break; |
83274 | 83585 | } |
83275 | - case 18446744073709546309LLU: // 99999998rE''''''''''''''' | |
83586 | + case 18446744073709546294LLU: // 99999998q0''''''''''''''' | |
83276 | 83587 | { |
83277 | 83588 | fprintf(stderr, "%s", " != "); |
83278 | 83589 | // ACCUMULATE ARGUMENTS - BEGIN |
@@ -83281,7 +83592,7 @@ | ||
83281 | 83592 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
83282 | 83593 | } |
83283 | 83594 | // ACCUMULATE ARGUMENTS - END |
83284 | - uint64_t return_to = 18446744073709546306LLU; | |
83595 | + uint64_t return_to = 18446744073709546291LLU; | |
83285 | 83596 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
83286 | 83597 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
83287 | 83598 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -83290,21 +83601,21 @@ | ||
83290 | 83601 | state.addr = 819847183517274112LLU; // reportnr__ |
83291 | 83602 | break; |
83292 | 83603 | } |
83293 | - case 18446744073709546306LLU: // 99999998rB''''''''''''''' | |
83604 | + case 18446744073709546291LLU: // 99999998qx''''''''''''''' | |
83294 | 83605 | { |
83295 | - state.addr = 18446744073709546307LLU; // 99999998rC''''''''''''''' | |
83606 | + state.addr = 18446744073709546292LLU; // 99999998qy''''''''''''''' | |
83296 | 83607 | break; |
83297 | 83608 | } |
83298 | - case 18446744073709546307LLU: // 99999998rC''''''''''''''' | |
83609 | + case 18446744073709546292LLU: // 99999998qy''''''''''''''' | |
83299 | 83610 | { |
83300 | 83611 | { |
83301 | 83612 | fprintf(stderr, "%s\n", ""); |
83302 | 83613 | exit(-1); |
83303 | 83614 | } |
83304 | - state.addr = 18446744073709546311LLU; // 99999998rG''''''''''''''' | |
83615 | + state.addr = 18446744073709546296LLU; // 99999998q2''''''''''''''' | |
83305 | 83616 | break; |
83306 | 83617 | } |
83307 | - case 18446744073709546311LLU: // 99999998rG''''''''''''''' | |
83618 | + case 18446744073709546296LLU: // 99999998q2''''''''''''''' | |
83308 | 83619 | { |
83309 | 83620 | { |
83310 | 83621 | uint64_t arg = 0; |
@@ -83311,16 +83622,16 @@ | ||
83311 | 83622 | LOCAL_PUSH_MOVE(&heap, 22, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
83312 | 83623 | } |
83313 | 83624 | *LOCAL_ACCESS(heap.data, 23LLU, 22LLU) = /*remainheap*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 23LLU, 16LLU)) != /*rh________*/*LOCAL_ACCESS(heap.data, 23LLU, 21LLU); |
83314 | - state.addr = 18446744073709546303LLU; // 99999998q9''''''''''''''' | |
83625 | + state.addr = 18446744073709546288LLU; // 99999998qu''''''''''''''' | |
83315 | 83626 | break; |
83316 | 83627 | } |
83317 | - case 18446744073709546303LLU: // 99999998q9''''''''''''''' | |
83628 | + case 18446744073709546288LLU: // 99999998qu''''''''''''''' | |
83318 | 83629 | { |
83319 | - state.addr = *LOCAL_ACCESS(heap.data, 23LLU, 22LLU) ? 18446744073709546305LLU : 18446744073709546304LLU; | |
83630 | + state.addr = *LOCAL_ACCESS(heap.data, 23LLU, 22LLU) ? 18446744073709546290LLU : 18446744073709546289LLU; | |
83320 | 83631 | (void)LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 23 |
83321 | 83632 | break; |
83322 | 83633 | } |
83323 | - case 18446744073709546305LLU: // 99999998rA''''''''''''''' | |
83634 | + case 18446744073709546290LLU: // 99999998qw''''''''''''''' | |
83324 | 83635 | { |
83325 | 83636 | fprintf(stderr, "%s", "INTERNAL ERROR: remainheap mismatch "); |
83326 | 83637 | // ACCUMULATE ARGUMENTS - BEGIN |
@@ -83329,7 +83640,7 @@ | ||
83329 | 83640 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
83330 | 83641 | } |
83331 | 83642 | // ACCUMULATE ARGUMENTS - END |
83332 | - uint64_t return_to = 18446744073709546301LLU; | |
83643 | + uint64_t return_to = 18446744073709546286LLU; | |
83333 | 83644 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
83334 | 83645 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
83335 | 83646 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -83338,12 +83649,12 @@ | ||
83338 | 83649 | state.addr = 819847183517274112LLU; // reportnr__ |
83339 | 83650 | break; |
83340 | 83651 | } |
83341 | - case 18446744073709546301LLU: // 99999998q7''''''''''''''' | |
83652 | + case 18446744073709546286LLU: // 99999998qs''''''''''''''' | |
83342 | 83653 | { |
83343 | - state.addr = 18446744073709546302LLU; // 99999998q8''''''''''''''' | |
83654 | + state.addr = 18446744073709546287LLU; // 99999998qt''''''''''''''' | |
83344 | 83655 | break; |
83345 | 83656 | } |
83346 | - case 18446744073709546302LLU: // 99999998q8''''''''''''''' | |
83657 | + case 18446744073709546287LLU: // 99999998qt''''''''''''''' | |
83347 | 83658 | { |
83348 | 83659 | fprintf(stderr, "%s", " != "); |
83349 | 83660 | // ACCUMULATE ARGUMENTS - BEGIN |
@@ -83352,7 +83663,7 @@ | ||
83352 | 83663 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
83353 | 83664 | } |
83354 | 83665 | // ACCUMULATE ARGUMENTS - END |
83355 | - uint64_t return_to = 18446744073709546299LLU; | |
83666 | + uint64_t return_to = 18446744073709546284LLU; | |
83356 | 83667 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
83357 | 83668 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
83358 | 83669 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -83361,21 +83672,21 @@ | ||
83361 | 83672 | state.addr = 819847183517274112LLU; // reportnr__ |
83362 | 83673 | break; |
83363 | 83674 | } |
83364 | - case 18446744073709546299LLU: // 99999998q5''''''''''''''' | |
83675 | + case 18446744073709546284LLU: // 99999998qq''''''''''''''' | |
83365 | 83676 | { |
83366 | - state.addr = 18446744073709546300LLU; // 99999998q6''''''''''''''' | |
83677 | + state.addr = 18446744073709546285LLU; // 99999998qr''''''''''''''' | |
83367 | 83678 | break; |
83368 | 83679 | } |
83369 | - case 18446744073709546300LLU: // 99999998q6''''''''''''''' | |
83680 | + case 18446744073709546285LLU: // 99999998qr''''''''''''''' | |
83370 | 83681 | { |
83371 | 83682 | { |
83372 | 83683 | fprintf(stderr, "%s\n", ""); |
83373 | 83684 | exit(-1); |
83374 | 83685 | } |
83375 | - state.addr = 18446744073709546304LLU; // 99999998r_''''''''''''''' | |
83686 | + state.addr = 18446744073709546289LLU; // 99999998qv''''''''''''''' | |
83376 | 83687 | break; |
83377 | 83688 | } |
83378 | - case 18446744073709546304LLU: // 99999998r_''''''''''''''' | |
83689 | + case 18446744073709546289LLU: // 99999998qv''''''''''''''' | |
83379 | 83690 | { |
83380 | 83691 | // variable u64 rh________ goes out of scope |
83381 | 83692 | // emitted destructur for type u64 |
@@ -83386,10 +83697,10 @@ | ||
83386 | 83697 | // variable u64 ds________ goes out of scope |
83387 | 83698 | // emitted destructur for type u64 |
83388 | 83699 | (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference ds________ at 20 |
83389 | - state.addr = 18446744073709546324LLU; // 99999998rT''''''''''''''' | |
83700 | + state.addr = 18446744073709546309LLU; // 99999998rE''''''''''''''' | |
83390 | 83701 | break; |
83391 | 83702 | } |
83392 | - case 18446744073709546324LLU: // 99999998rT''''''''''''''' | |
83703 | + case 18446744073709546309LLU: // 99999998rE''''''''''''''' | |
83393 | 83704 | { |
83394 | 83705 | // ACCUMULATE ARGUMENTS - BEGIN |
83395 | 83706 | { |
@@ -83397,7 +83708,7 @@ | ||
83397 | 83708 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
83398 | 83709 | } |
83399 | 83710 | // ACCUMULATE ARGUMENTS - END |
83400 | - uint64_t return_to = 18446744073709546297LLU; | |
83711 | + uint64_t return_to = 18446744073709546282LLU; | |
83401 | 83712 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
83402 | 83713 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
83403 | 83714 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -83406,12 +83717,12 @@ | ||
83406 | 83717 | state.addr = 839519719621918720LLU; // skipws____ |
83407 | 83718 | break; |
83408 | 83719 | } |
83409 | - case 18446744073709546297LLU: // 99999998q3''''''''''''''' | |
83720 | + case 18446744073709546282LLU: // 99999998qo''''''''''''''' | |
83410 | 83721 | { |
83411 | - state.addr = 18446744073709546298LLU; // 99999998q4''''''''''''''' | |
83722 | + state.addr = 18446744073709546283LLU; // 99999998qp''''''''''''''' | |
83412 | 83723 | break; |
83413 | 83724 | } |
83414 | - case 18446744073709546298LLU: // 99999998q4''''''''''''''' | |
83725 | + case 18446744073709546283LLU: // 99999998qp''''''''''''''' | |
83415 | 83726 | { |
83416 | 83727 | matchid("=", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 11LLU))); |
83417 | 83728 | // ACCUMULATE ARGUMENTS - BEGIN |
@@ -83420,7 +83731,7 @@ | ||
83420 | 83731 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
83421 | 83732 | } |
83422 | 83733 | // ACCUMULATE ARGUMENTS - END |
83423 | - uint64_t return_to = 18446744073709546295LLU; | |
83734 | + uint64_t return_to = 18446744073709546280LLU; | |
83424 | 83735 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
83425 | 83736 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
83426 | 83737 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -83429,12 +83740,12 @@ | ||
83429 | 83740 | state.addr = 839519719621918720LLU; // skipws____ |
83430 | 83741 | break; |
83431 | 83742 | } |
83432 | - case 18446744073709546295LLU: // 99999998q1''''''''''''''' | |
83743 | + case 18446744073709546280LLU: // 99999998qm''''''''''''''' | |
83433 | 83744 | { |
83434 | - state.addr = 18446744073709546296LLU; // 99999998q2''''''''''''''' | |
83745 | + state.addr = 18446744073709546281LLU; // 99999998qn''''''''''''''' | |
83435 | 83746 | break; |
83436 | 83747 | } |
83437 | - case 18446744073709546296LLU: // 99999998q2''''''''''''''' | |
83748 | + case 18446744073709546281LLU: // 99999998qn''''''''''''''' | |
83438 | 83749 | { |
83439 | 83750 | { |
83440 | 83751 | uint64_t arg = 0; |
@@ -83446,16 +83757,16 @@ | ||
83446 | 83757 | LOCAL_PUSH_MOVE(&heap, 20, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
83447 | 83758 | } |
83448 | 83759 | *LOCAL_ACCESS(heap.data, 21LLU, 20LLU) = /*sym_______*/*LOCAL_ACCESS(heap.data, 21LLU, 19LLU) == /*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 11LLU)); |
83449 | - state.addr = 18446744073709546292LLU; // 99999998qy''''''''''''''' | |
83760 | + state.addr = 18446744073709546277LLU; // 99999998qj''''''''''''''' | |
83450 | 83761 | break; |
83451 | 83762 | } |
83452 | - case 18446744073709546292LLU: // 99999998qy''''''''''''''' | |
83763 | + case 18446744073709546277LLU: // 99999998qj''''''''''''''' | |
83453 | 83764 | { |
83454 | - state.addr = *LOCAL_ACCESS(heap.data, 21LLU, 20LLU) ? 18446744073709546294LLU : 18446744073709546293LLU; | |
83765 | + state.addr = *LOCAL_ACCESS(heap.data, 21LLU, 20LLU) ? 18446744073709546279LLU : 18446744073709546278LLU; | |
83455 | 83766 | (void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 21 |
83456 | 83767 | break; |
83457 | 83768 | } |
83458 | - case 18446744073709546294LLU: // 99999998q0''''''''''''''' | |
83769 | + case 18446744073709546279LLU: // 99999998ql''''''''''''''' | |
83459 | 83770 | { |
83460 | 83771 | // ACCUMULATE ARGUMENTS - BEGIN |
83461 | 83772 | { |
@@ -83483,7 +83794,7 @@ | ||
83483 | 83794 | LOCAL_PUSH_MOVE(&heap, 5LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
83484 | 83795 | } |
83485 | 83796 | // ACCUMULATE ARGUMENTS - END |
83486 | - uint64_t return_to = 18446744073709546290LLU; | |
83797 | + uint64_t return_to = 18446744073709546275LLU; | |
83487 | 83798 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 6LLU, 0/*address of closure-in-construction*/, 0)); |
83488 | 83799 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
83489 | 83800 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 6LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -83492,20 +83803,20 @@ | ||
83492 | 83803 | state.addr = 533581901922699840LLU; // blockopen_ |
83493 | 83804 | break; |
83494 | 83805 | } |
83495 | - case 18446744073709546290LLU: // 99999998qw''''''''''''''' | |
83806 | + case 18446744073709546275LLU: // 99999998qh''''''''''''''' | |
83496 | 83807 | { |
83497 | - state.addr = 18446744073709546291LLU; // 99999998qx''''''''''''''' | |
83808 | + state.addr = 18446744073709546276LLU; // 99999998qi''''''''''''''' | |
83498 | 83809 | break; |
83499 | 83810 | } |
83500 | - case 18446744073709546291LLU: // 99999998qx''''''''''''''' | |
83811 | + case 18446744073709546276LLU: // 99999998qi''''''''''''''' | |
83501 | 83812 | { |
83502 | 83813 | swap(&/*results___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 20LLU, 10LLU)), &/*newresults*/*LOCAL_ACCESS(heap.data, 20LLU, 18LLU)); |
83503 | 83814 | heap.availilable_size_for_dynamic_objects += 0LLU; |
83504 | 83815 | heap.availilable_size_for_dynamic_objects += 0LLU; |
83505 | - state.addr = 18446744073709546289LLU; // 99999998qv''''''''''''''' | |
83816 | + state.addr = 18446744073709546274LLU; // 99999998qg''''''''''''''' | |
83506 | 83817 | break; |
83507 | 83818 | } |
83508 | - case 18446744073709546293LLU: // 99999998qz''''''''''''''' | |
83819 | + case 18446744073709546278LLU: // 99999998qk''''''''''''''' | |
83509 | 83820 | { |
83510 | 83821 | // ACCUMULATE ARGUMENTS - BEGIN |
83511 | 83822 | { |
@@ -83577,7 +83888,7 @@ | ||
83577 | 83888 | LOCAL_PUSH_MOVE(&heap, 16LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
83578 | 83889 | } |
83579 | 83890 | // ACCUMULATE ARGUMENTS - END |
83580 | - uint64_t return_to = 18446744073709546287LLU; | |
83891 | + uint64_t return_to = 18446744073709546272LLU; | |
83581 | 83892 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 17LLU, 0/*address of closure-in-construction*/, 0)); |
83582 | 83893 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
83583 | 83894 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 17LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -83586,17 +83897,17 @@ | ||
83586 | 83897 | state.addr = 787472338545441824LLU; // procrvalue |
83587 | 83898 | break; |
83588 | 83899 | } |
83589 | - case 18446744073709546287LLU: // 99999998qt''''''''''''''' | |
83900 | + case 18446744073709546272LLU: // 99999998qe''''''''''''''' | |
83590 | 83901 | { |
83591 | - state.addr = 18446744073709546288LLU; // 99999998qu''''''''''''''' | |
83902 | + state.addr = 18446744073709546273LLU; // 99999998qf''''''''''''''' | |
83592 | 83903 | break; |
83593 | 83904 | } |
83594 | - case 18446744073709546288LLU: // 99999998qu''''''''''''''' | |
83905 | + case 18446744073709546273LLU: // 99999998qf''''''''''''''' | |
83595 | 83906 | { |
83596 | - state.addr = 18446744073709546289LLU; // 99999998qv''''''''''''''' | |
83907 | + state.addr = 18446744073709546274LLU; // 99999998qg''''''''''''''' | |
83597 | 83908 | break; |
83598 | 83909 | } |
83599 | - case 18446744073709546289LLU: // 99999998qv''''''''''''''' | |
83910 | + case 18446744073709546274LLU: // 99999998qg''''''''''''''' | |
83600 | 83911 | { |
83601 | 83912 | // variable u64 sym_______ goes out of scope |
83602 | 83913 | // emitted destructur for type u64 |
@@ -83603,14 +83914,14 @@ | ||
83603 | 83914 | (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference sym_______ at 20 |
83604 | 83915 | // variable list<resdest___> newresults goes out of scope |
83605 | 83916 | // emitted destructur for type list<resdest___> |
83606 | - state.addr = 18446744073709546285LLU; // 99999998qr''''''''''''''' | |
83917 | + state.addr = 18446744073709546270LLU; // 99999998qc''''''''''''''' | |
83607 | 83918 | break; |
83608 | 83919 | } |
83609 | - case 18446744073709546285LLU: // 99999998qr''''''''''''''' | |
83920 | + case 18446744073709546270LLU: // 99999998qc''''''''''''''' | |
83610 | 83921 | { |
83611 | 83922 | if(!*LOCAL_ACCESS(heap.data, 19LLU, 18LLU)/*list*/) |
83612 | 83923 | { |
83613 | - state.addr = 18446744073709546286LLU; // 99999998qs''''''''''''''' | |
83924 | + state.addr = 18446744073709546271LLU; // 99999998qd''''''''''''''' | |
83614 | 83925 | break; |
83615 | 83926 | } |
83616 | 83927 | // temporary list-element |
@@ -83624,7 +83935,7 @@ | ||
83624 | 83935 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
83625 | 83936 | } |
83626 | 83937 | // ACCUMULATE ARGUMENTS - END |
83627 | - uint64_t return_to = 18446744073709546284LLU; | |
83938 | + uint64_t return_to = 18446744073709546269LLU; | |
83628 | 83939 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
83629 | 83940 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
83630 | 83941 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -83633,26 +83944,26 @@ | ||
83633 | 83944 | state.addr = 18446744073709551475LLU; // 999999997x''''''''''''''' |
83634 | 83945 | break; |
83635 | 83946 | } |
83636 | - case 18446744073709546284LLU: // 99999998qq''''''''''''''' | |
83947 | + case 18446744073709546269LLU: // 99999998qb''''''''''''''' | |
83637 | 83948 | { |
83638 | 83949 | // RELEASE temporary destructor-variable |
83639 | 83950 | (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 20 |
83640 | - state.addr = 18446744073709546285LLU; // 99999998qr''''''''''''''' | |
83951 | + state.addr = 18446744073709546270LLU; // 99999998qc''''''''''''''' | |
83641 | 83952 | break; |
83642 | 83953 | } |
83643 | - case 18446744073709546286LLU: // 99999998qs''''''''''''''' | |
83954 | + case 18446744073709546271LLU: // 99999998qd''''''''''''''' | |
83644 | 83955 | { |
83645 | 83956 | (void)LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference newresults at 19 |
83646 | 83957 | // variable list<resdest___> tmpresults goes out of scope |
83647 | 83958 | // emitted destructur for type list<resdest___> |
83648 | - state.addr = 18446744073709546282LLU; // 99999998qo''''''''''''''' | |
83959 | + state.addr = 18446744073709546267LLU; // 99999998q$''''''''''''''' | |
83649 | 83960 | break; |
83650 | 83961 | } |
83651 | - case 18446744073709546282LLU: // 99999998qo''''''''''''''' | |
83962 | + case 18446744073709546267LLU: // 99999998q$''''''''''''''' | |
83652 | 83963 | { |
83653 | 83964 | if(!*LOCAL_ACCESS(heap.data, 18LLU, 17LLU)/*list*/) |
83654 | 83965 | { |
83655 | - state.addr = 18446744073709546283LLU; // 99999998qp''''''''''''''' | |
83966 | + state.addr = 18446744073709546268LLU; // 99999998qa''''''''''''''' | |
83656 | 83967 | break; |
83657 | 83968 | } |
83658 | 83969 | // temporary list-element |
@@ -83666,7 +83977,7 @@ | ||
83666 | 83977 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
83667 | 83978 | } |
83668 | 83979 | // ACCUMULATE ARGUMENTS - END |
83669 | - uint64_t return_to = 18446744073709546281LLU; | |
83980 | + uint64_t return_to = 18446744073709546266LLU; | |
83670 | 83981 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
83671 | 83982 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
83672 | 83983 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -83675,14 +83986,14 @@ | ||
83675 | 83986 | state.addr = 18446744073709551475LLU; // 999999997x''''''''''''''' |
83676 | 83987 | break; |
83677 | 83988 | } |
83678 | - case 18446744073709546281LLU: // 99999998qn''''''''''''''' | |
83989 | + case 18446744073709546266LLU: // 99999998qZ''''''''''''''' | |
83679 | 83990 | { |
83680 | 83991 | // RELEASE temporary destructor-variable |
83681 | 83992 | (void)LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 19 |
83682 | - state.addr = 18446744073709546282LLU; // 99999998qo''''''''''''''' | |
83993 | + state.addr = 18446744073709546267LLU; // 99999998q$''''''''''''''' | |
83683 | 83994 | break; |
83684 | 83995 | } |
83685 | - case 18446744073709546283LLU: // 99999998qp''''''''''''''' | |
83996 | + case 18446744073709546268LLU: // 99999998qa''''''''''''''' | |
83686 | 83997 | { |
83687 | 83998 | (void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference tmpresults at 18 |
83688 | 83999 | // parameter-reference u64 remainheap goes out of scope |
@@ -83759,7 +84070,7 @@ | ||
83759 | 84070 | LOCAL_PUSH_MOVE(&heap, 5LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
83760 | 84071 | } |
83761 | 84072 | // ACCUMULATE ARGUMENTS - END |
83762 | - uint64_t return_to = 18446744073709546279LLU; | |
84073 | + uint64_t return_to = 18446744073709546264LLU; | |
83763 | 84074 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 6LLU, 0/*address of closure-in-construction*/, 0)); |
83764 | 84075 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
83765 | 84076 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 6LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -83768,12 +84079,12 @@ | ||
83768 | 84079 | state.addr = 533581901922699840LLU; // blockopen_ |
83769 | 84080 | break; |
83770 | 84081 | } |
83771 | - case 18446744073709546279LLU: // 99999998ql''''''''''''''' | |
84082 | + case 18446744073709546264LLU: // 99999998qX''''''''''''''' | |
83772 | 84083 | { |
83773 | - state.addr = 18446744073709546280LLU; // 99999998qm''''''''''''''' | |
84084 | + state.addr = 18446744073709546265LLU; // 99999998qY''''''''''''''' | |
83774 | 84085 | break; |
83775 | 84086 | } |
83776 | - case 18446744073709546280LLU: // 99999998qm''''''''''''''' | |
84087 | + case 18446744073709546265LLU: // 99999998qY''''''''''''''' | |
83777 | 84088 | { |
83778 | 84089 | { |
83779 | 84090 | uint64_t arg = 0; |
@@ -83785,7 +84096,7 @@ | ||
83785 | 84096 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
83786 | 84097 | } |
83787 | 84098 | // ACCUMULATE ARGUMENTS - END |
83788 | - uint64_t return_to = 18446744073709546277LLU; | |
84099 | + uint64_t return_to = 18446744073709546262LLU; | |
83789 | 84100 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
83790 | 84101 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
83791 | 84102 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -83794,12 +84105,12 @@ | ||
83794 | 84105 | state.addr = 839519719621918720LLU; // skipws____ |
83795 | 84106 | break; |
83796 | 84107 | } |
83797 | - case 18446744073709546277LLU: // 99999998qj''''''''''''''' | |
84108 | + case 18446744073709546262LLU: // 99999998qV''''''''''''''' | |
83798 | 84109 | { |
83799 | - state.addr = 18446744073709546278LLU; // 99999998qk''''''''''''''' | |
84110 | + state.addr = 18446744073709546263LLU; // 99999998qW''''''''''''''' | |
83800 | 84111 | break; |
83801 | 84112 | } |
83802 | - case 18446744073709546278LLU: // 99999998qk''''''''''''''' | |
84113 | + case 18446744073709546263LLU: // 99999998qW''''''''''''''' | |
83803 | 84114 | { |
83804 | 84115 | ungetc((int)/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 18LLU, 11LLU)), stdin); |
83805 | 84116 | if('(' != (char)getchar()) |
@@ -83807,15 +84118,15 @@ | ||
83807 | 84118 | fprintf(stderr, "match failed at char %c\n", (char)40LLU); |
83808 | 84119 | exit(-1); |
83809 | 84120 | } |
83810 | - state.addr = 18446744073709546276LLU; // 99999998qi''''''''''''''' | |
84121 | + state.addr = 18446744073709546261LLU; // 99999998qU''''''''''''''' | |
83811 | 84122 | break; |
83812 | 84123 | } |
83813 | - case 18446744073709546276LLU: // 99999998qi''''''''''''''' | |
84124 | + case 18446744073709546261LLU: // 99999998qU''''''''''''''' | |
83814 | 84125 | { |
83815 | 84126 | *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 18LLU, 11LLU)) = (uint64_t)getchar(); |
83816 | 84127 | if(!*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 18LLU, 11LLU)) || *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 18LLU, 11LLU)) > 255) |
83817 | 84128 | { |
83818 | - state.addr = 18446744073709546275LLU; // 99999998qh''''''''''''''' | |
84129 | + state.addr = 18446744073709546260LLU; // 99999998qT''''''''''''''' | |
83819 | 84130 | break; |
83820 | 84131 | } |
83821 | 84132 | // ACCUMULATE ARGUMENTS - BEGIN |
@@ -83824,7 +84135,7 @@ | ||
83824 | 84135 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
83825 | 84136 | } |
83826 | 84137 | // ACCUMULATE ARGUMENTS - END |
83827 | - uint64_t return_to = 18446744073709546273LLU; | |
84138 | + uint64_t return_to = 18446744073709546258LLU; | |
83828 | 84139 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
83829 | 84140 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
83830 | 84141 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -83833,12 +84144,12 @@ | ||
83833 | 84144 | state.addr = 839519719621918720LLU; // skipws____ |
83834 | 84145 | break; |
83835 | 84146 | } |
83836 | - case 18446744073709546273LLU: // 99999998qf''''''''''''''' | |
84147 | + case 18446744073709546258LLU: // 99999998qR''''''''''''''' | |
83837 | 84148 | { |
83838 | - state.addr = 18446744073709546274LLU; // 99999998qg''''''''''''''' | |
84149 | + state.addr = 18446744073709546259LLU; // 99999998qS''''''''''''''' | |
83839 | 84150 | break; |
83840 | 84151 | } |
83841 | - case 18446744073709546274LLU: // 99999998qg''''''''''''''' | |
84152 | + case 18446744073709546259LLU: // 99999998qS''''''''''''''' | |
83842 | 84153 | { |
83843 | 84154 | { |
83844 | 84155 | uint64_t arg = 0; |
@@ -83855,16 +84166,16 @@ | ||
83855 | 84166 | LOCAL_PUSH_MOVE(&heap, 20, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
83856 | 84167 | } |
83857 | 84168 | *LOCAL_ACCESS(heap.data, 21LLU, 20LLU) = /*terminator*/*LOCAL_ACCESS(heap.data, 21LLU, 19LLU) != /*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 11LLU)); |
83858 | - state.addr = 18446744073709546270LLU; // 99999998qc''''''''''''''' | |
84169 | + state.addr = 18446744073709546255LLU; // 99999998qO''''''''''''''' | |
83859 | 84170 | break; |
83860 | 84171 | } |
83861 | - case 18446744073709546270LLU: // 99999998qc''''''''''''''' | |
84172 | + case 18446744073709546255LLU: // 99999998qO''''''''''''''' | |
83862 | 84173 | { |
83863 | - state.addr = *LOCAL_ACCESS(heap.data, 21LLU, 20LLU) ? 18446744073709546272LLU : 18446744073709546271LLU; | |
84174 | + state.addr = *LOCAL_ACCESS(heap.data, 21LLU, 20LLU) ? 18446744073709546257LLU : 18446744073709546256LLU; | |
83864 | 84175 | (void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 21 |
83865 | 84176 | break; |
83866 | 84177 | } |
83867 | - case 18446744073709546272LLU: // 99999998qe''''''''''''''' | |
84178 | + case 18446744073709546257LLU: // 99999998qQ''''''''''''''' | |
83868 | 84179 | { |
83869 | 84180 | // ACCUMULATE ARGUMENTS - BEGIN |
83870 | 84181 | { |
@@ -83872,7 +84183,7 @@ | ||
83872 | 84183 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
83873 | 84184 | } |
83874 | 84185 | // ACCUMULATE ARGUMENTS - END |
83875 | - uint64_t return_to = 18446744073709546267LLU; | |
84186 | + uint64_t return_to = 18446744073709546252LLU; | |
83876 | 84187 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
83877 | 84188 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
83878 | 84189 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -83881,12 +84192,12 @@ | ||
83881 | 84192 | state.addr = 839519719621918720LLU; // skipws____ |
83882 | 84193 | break; |
83883 | 84194 | } |
83884 | - case 18446744073709546267LLU: // 99999998q$''''''''''''''' | |
84195 | + case 18446744073709546252LLU: // 99999998qL''''''''''''''' | |
83885 | 84196 | { |
83886 | - state.addr = 18446744073709546268LLU; // 99999998qa''''''''''''''' | |
84197 | + state.addr = 18446744073709546253LLU; // 99999998qM''''''''''''''' | |
83887 | 84198 | break; |
83888 | 84199 | } |
83889 | - case 18446744073709546268LLU: // 99999998qa''''''''''''''' | |
84200 | + case 18446744073709546253LLU: // 99999998qM''''''''''''''' | |
83890 | 84201 | { |
83891 | 84202 | { |
83892 | 84203 | uint64_t arg = 0; |
@@ -83893,10 +84204,10 @@ | ||
83893 | 84204 | LOCAL_PUSH_MOVE(&heap, 20, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
83894 | 84205 | } |
83895 | 84206 | *LOCAL_ACCESS(heap.data, 21LLU, 20LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 11LLU))); |
83896 | - state.addr = 18446744073709546266LLU; // 99999998qZ''''''''''''''' | |
84207 | + state.addr = 18446744073709546251LLU; // 99999998qK''''''''''''''' | |
83897 | 84208 | break; |
83898 | 84209 | } |
83899 | - case 18446744073709546266LLU: // 99999998qZ''''''''''''''' | |
84210 | + case 18446744073709546251LLU: // 99999998qK''''''''''''''' | |
83900 | 84211 | { |
83901 | 84212 | // ACCUMULATE ARGUMENTS - BEGIN |
83902 | 84213 | { |
@@ -83968,7 +84279,7 @@ | ||
83968 | 84279 | LOCAL_PUSH_MOVE(&heap, 16LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
83969 | 84280 | } |
83970 | 84281 | // ACCUMULATE ARGUMENTS - END |
83971 | - uint64_t return_to = 18446744073709546264LLU; | |
84282 | + uint64_t return_to = 18446744073709546249LLU; | |
83972 | 84283 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 17LLU, 0/*address of closure-in-construction*/, 0)); |
83973 | 84284 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
83974 | 84285 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 17LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -83977,20 +84288,20 @@ | ||
83977 | 84288 | state.addr = 782742327813734400LLU; // pa1_______ |
83978 | 84289 | break; |
83979 | 84290 | } |
83980 | - case 18446744073709546264LLU: // 99999998qX''''''''''''''' | |
84291 | + case 18446744073709546249LLU: // 99999998qI''''''''''''''' | |
83981 | 84292 | { |
83982 | - state.addr = 18446744073709546265LLU; // 99999998qY''''''''''''''' | |
84293 | + state.addr = 18446744073709546250LLU; // 99999998qJ''''''''''''''' | |
83983 | 84294 | break; |
83984 | 84295 | } |
83985 | - case 18446744073709546265LLU: // 99999998qY''''''''''''''' | |
84296 | + case 18446744073709546250LLU: // 99999998qJ''''''''''''''' | |
83986 | 84297 | { |
83987 | 84298 | // variable u64 resultid__ goes out of scope |
83988 | 84299 | // emitted destructur for type u64 |
83989 | 84300 | (void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference resultid__ at 21 |
83990 | - state.addr = 18446744073709546269LLU; // 99999998qb''''''''''''''' | |
84301 | + state.addr = 18446744073709546254LLU; // 99999998qN''''''''''''''' | |
83991 | 84302 | break; |
83992 | 84303 | } |
83993 | - case 18446744073709546269LLU: // 99999998qb''''''''''''''' | |
84304 | + case 18446744073709546254LLU: // 99999998qN''''''''''''''' | |
83994 | 84305 | { |
83995 | 84306 | // ACCUMULATE ARGUMENTS - BEGIN |
83996 | 84307 | { |
@@ -83998,7 +84309,7 @@ | ||
83998 | 84309 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
83999 | 84310 | } |
84000 | 84311 | // ACCUMULATE ARGUMENTS - END |
84001 | - uint64_t return_to = 18446744073709546262LLU; | |
84312 | + uint64_t return_to = 18446744073709546247LLU; | |
84002 | 84313 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
84003 | 84314 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
84004 | 84315 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -84007,12 +84318,12 @@ | ||
84007 | 84318 | state.addr = 839519719621918720LLU; // skipws____ |
84008 | 84319 | break; |
84009 | 84320 | } |
84010 | - case 18446744073709546262LLU: // 99999998qV''''''''''''''' | |
84321 | + case 18446744073709546247LLU: // 99999998qG''''''''''''''' | |
84011 | 84322 | { |
84012 | - state.addr = 18446744073709546263LLU; // 99999998qW''''''''''''''' | |
84323 | + state.addr = 18446744073709546248LLU; // 99999998qH''''''''''''''' | |
84013 | 84324 | break; |
84014 | 84325 | } |
84015 | - case 18446744073709546263LLU: // 99999998qW''''''''''''''' | |
84326 | + case 18446744073709546248LLU: // 99999998qH''''''''''''''' | |
84016 | 84327 | { |
84017 | 84328 | { |
84018 | 84329 | uint64_t arg = 0; |
@@ -84019,16 +84330,16 @@ | ||
84019 | 84330 | LOCAL_PUSH_MOVE(&heap, 20, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
84020 | 84331 | } |
84021 | 84332 | *LOCAL_ACCESS(heap.data, 21LLU, 20LLU) = /*separator_*/*LOCAL_ACCESS(heap.data, 21LLU, 18LLU) != /*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 11LLU)); |
84022 | - state.addr = 18446744073709546259LLU; // 99999998qS''''''''''''''' | |
84333 | + state.addr = 18446744073709546244LLU; // 99999998qD''''''''''''''' | |
84023 | 84334 | break; |
84024 | 84335 | } |
84025 | - case 18446744073709546259LLU: // 99999998qS''''''''''''''' | |
84336 | + case 18446744073709546244LLU: // 99999998qD''''''''''''''' | |
84026 | 84337 | { |
84027 | - state.addr = *LOCAL_ACCESS(heap.data, 21LLU, 20LLU) ? 18446744073709546261LLU : 18446744073709546260LLU; | |
84338 | + state.addr = *LOCAL_ACCESS(heap.data, 21LLU, 20LLU) ? 18446744073709546246LLU : 18446744073709546245LLU; | |
84028 | 84339 | (void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 21 |
84029 | 84340 | break; |
84030 | 84341 | } |
84031 | - case 18446744073709546261LLU: // 99999998qU''''''''''''''' | |
84342 | + case 18446744073709546246LLU: // 99999998qF''''''''''''''' | |
84032 | 84343 | { |
84033 | 84344 | { |
84034 | 84345 | uint64_t arg = 0; |
@@ -84035,24 +84346,24 @@ | ||
84035 | 84346 | LOCAL_PUSH_MOVE(&heap, 20, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
84036 | 84347 | } |
84037 | 84348 | *LOCAL_ACCESS(heap.data, 21LLU, 20LLU) = /*terminator*/*LOCAL_ACCESS(heap.data, 21LLU, 19LLU) == /*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 11LLU)); |
84038 | - state.addr = 18446744073709546256LLU; // 99999998qP''''''''''''''' | |
84349 | + state.addr = 18446744073709546241LLU; // 99999998qA''''''''''''''' | |
84039 | 84350 | break; |
84040 | 84351 | } |
84041 | - case 18446744073709546256LLU: // 99999998qP''''''''''''''' | |
84352 | + case 18446744073709546241LLU: // 99999998qA''''''''''''''' | |
84042 | 84353 | { |
84043 | - state.addr = *LOCAL_ACCESS(heap.data, 21LLU, 20LLU) ? 18446744073709546258LLU : 18446744073709546257LLU; | |
84354 | + state.addr = *LOCAL_ACCESS(heap.data, 21LLU, 20LLU) ? 18446744073709546243LLU : 18446744073709546242LLU; | |
84044 | 84355 | (void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 21 |
84045 | 84356 | break; |
84046 | 84357 | } |
84047 | - case 18446744073709546258LLU: // 99999998qR''''''''''''''' | |
84358 | + case 18446744073709546243LLU: // 99999998qC''''''''''''''' | |
84048 | 84359 | { |
84049 | 84360 | ungetc(0, stdin); |
84050 | 84361 | heap.availilable_size_for_dynamic_objects += 0LLU; |
84051 | 84362 | heap.availilable_size_for_dynamic_objects += 0LLU; |
84052 | - state.addr = 18446744073709546255LLU; // 99999998qO''''''''''''''' | |
84363 | + state.addr = 18446744073709546240LLU; // 99999998q_''''''''''''''' | |
84053 | 84364 | break; |
84054 | 84365 | } |
84055 | - case 18446744073709546257LLU: // 99999998qQ''''''''''''''' | |
84366 | + case 18446744073709546242LLU: // 99999998qB''''''''''''''' | |
84056 | 84367 | { |
84057 | 84368 | // ACCUMULATE ARGUMENTS - BEGIN |
84058 | 84369 | { |
@@ -84060,7 +84371,7 @@ | ||
84060 | 84371 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
84061 | 84372 | } |
84062 | 84373 | // ACCUMULATE ARGUMENTS - END |
84063 | - uint64_t return_to = 18446744073709546253LLU; | |
84374 | + uint64_t return_to = 18446744073709546238LLU; | |
84064 | 84375 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
84065 | 84376 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
84066 | 84377 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -84069,12 +84380,12 @@ | ||
84069 | 84380 | state.addr = 819847183515949359LLU; // reportinit |
84070 | 84381 | break; |
84071 | 84382 | } |
84072 | - case 18446744073709546253LLU: // 99999998qM''''''''''''''' | |
84383 | + case 18446744073709546238LLU: // 99999998p8''''''''''''''' | |
84073 | 84384 | { |
84074 | - state.addr = 18446744073709546254LLU; // 99999998qN''''''''''''''' | |
84385 | + state.addr = 18446744073709546239LLU; // 99999998p9''''''''''''''' | |
84075 | 84386 | break; |
84076 | 84387 | } |
84077 | - case 18446744073709546254LLU: // 99999998qN''''''''''''''' | |
84388 | + case 18446744073709546239LLU: // 99999998p9''''''''''''''' | |
84078 | 84389 | { |
84079 | 84390 | fprintf(stderr, "%s", "expected ',' or ')' but found "); |
84080 | 84391 | putc((char)/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 20LLU, 11LLU)), stderr); |
@@ -84082,28 +84393,28 @@ | ||
84082 | 84393 | fprintf(stderr, "%s\n", ""); |
84083 | 84394 | exit(-1); |
84084 | 84395 | } |
84085 | - state.addr = 18446744073709546255LLU; // 99999998qO''''''''''''''' | |
84396 | + state.addr = 18446744073709546240LLU; // 99999998q_''''''''''''''' | |
84086 | 84397 | break; |
84087 | 84398 | } |
84088 | - case 18446744073709546255LLU: // 99999998qO''''''''''''''' | |
84399 | + case 18446744073709546240LLU: // 99999998q_''''''''''''''' | |
84089 | 84400 | { |
84090 | - state.addr = 18446744073709546260LLU; // 99999998qT''''''''''''''' | |
84401 | + state.addr = 18446744073709546245LLU; // 99999998qE''''''''''''''' | |
84091 | 84402 | break; |
84092 | 84403 | } |
84093 | - case 18446744073709546260LLU: // 99999998qT''''''''''''''' | |
84404 | + case 18446744073709546245LLU: // 99999998qE''''''''''''''' | |
84094 | 84405 | { |
84095 | 84406 | heap.availilable_size_for_dynamic_objects += 0LLU; |
84096 | 84407 | heap.availilable_size_for_dynamic_objects += 0LLU; |
84097 | - state.addr = 18446744073709546252LLU; // 99999998qL''''''''''''''' | |
84408 | + state.addr = 18446744073709546237LLU; // 99999998p7''''''''''''''' | |
84098 | 84409 | break; |
84099 | 84410 | } |
84100 | - case 18446744073709546271LLU: // 99999998qd''''''''''''''' | |
84411 | + case 18446744073709546256LLU: // 99999998qP''''''''''''''' | |
84101 | 84412 | { |
84102 | 84413 | ungetc(0, stdin); |
84103 | - state.addr = 18446744073709546252LLU; // 99999998qL''''''''''''''' | |
84414 | + state.addr = 18446744073709546237LLU; // 99999998p7''''''''''''''' | |
84104 | 84415 | break; |
84105 | 84416 | } |
84106 | - case 18446744073709546252LLU: // 99999998qL''''''''''''''' | |
84417 | + case 18446744073709546237LLU: // 99999998p7''''''''''''''' | |
84107 | 84418 | { |
84108 | 84419 | // variable u64 terminator goes out of scope |
84109 | 84420 | // emitted destructur for type u64 |
@@ -84111,22 +84422,22 @@ | ||
84111 | 84422 | // variable u64 separator_ goes out of scope |
84112 | 84423 | // emitted destructur for type u64 |
84113 | 84424 | (void)LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference separator_ at 19 |
84114 | - state.addr = 18446744073709546276LLU; // 99999998qi''''''''''''''' | |
84425 | + state.addr = 18446744073709546261LLU; // 99999998qU''''''''''''''' | |
84115 | 84426 | break; |
84116 | 84427 | } |
84117 | - case 18446744073709546275LLU: // 99999998qh''''''''''''''' | |
84428 | + case 18446744073709546260LLU: // 99999998qT''''''''''''''' | |
84118 | 84429 | { |
84119 | 84430 | |
84120 | - state.addr = 18446744073709546251LLU; // 99999998qK''''''''''''''' | |
84431 | + state.addr = 18446744073709546236LLU; // 99999998p6''''''''''''''' | |
84121 | 84432 | break; |
84122 | 84433 | } |
84123 | - case 18446744073709546251LLU: // 99999998qK''''''''''''''' | |
84434 | + case 18446744073709546236LLU: // 99999998p6''''''''''''''' | |
84124 | 84435 | { |
84125 | 84436 | *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 18LLU, 11LLU)) = (uint64_t)getchar(); |
84126 | - state.addr = 18446744073709546250LLU; // 99999998qJ''''''''''''''' | |
84437 | + state.addr = 18446744073709546235LLU; // 99999998p5''''''''''''''' | |
84127 | 84438 | break; |
84128 | 84439 | } |
84129 | - case 18446744073709546250LLU: // 99999998qJ''''''''''''''' | |
84440 | + case 18446744073709546235LLU: // 99999998p5''''''''''''''' | |
84130 | 84441 | { |
84131 | 84442 | list_reverse(heap.data, &/*newresults*/*LOCAL_ACCESS(heap.data, 18LLU, 17LLU)); |
84132 | 84443 | { |
@@ -84190,7 +84501,7 @@ | ||
84190 | 84501 | LOCAL_PUSH_MOVE(&heap, 10LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
84191 | 84502 | } |
84192 | 84503 | // ACCUMULATE ARGUMENTS - END |
84193 | - uint64_t return_to = 18446744073709546247LLU; | |
84504 | + uint64_t return_to = 18446744073709546232LLU; | |
84194 | 84505 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 11LLU, 0/*address of closure-in-construction*/, 0)); |
84195 | 84506 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
84196 | 84507 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 11LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -84199,17 +84510,17 @@ | ||
84199 | 84510 | state.addr = 533581901720365984LLU; // blockclose |
84200 | 84511 | break; |
84201 | 84512 | } |
84202 | - case 18446744073709546247LLU: // 99999998qG''''''''''''''' | |
84513 | + case 18446744073709546232LLU: // 99999998p2''''''''''''''' | |
84203 | 84514 | { |
84204 | - state.addr = 18446744073709546248LLU; // 99999998qH''''''''''''''' | |
84515 | + state.addr = 18446744073709546233LLU; // 99999998p3''''''''''''''' | |
84205 | 84516 | break; |
84206 | 84517 | } |
84207 | - case 18446744073709546248LLU: // 99999998qH''''''''''''''' | |
84518 | + case 18446744073709546233LLU: // 99999998p3''''''''''''''' | |
84208 | 84519 | { |
84209 | - state.addr = *LOCAL_ACCESS(heap.data, 21LLU, 16LLU) ? 18446744073709546246LLU : 18446744073709546245LLU; | |
84520 | + state.addr = *LOCAL_ACCESS(heap.data, 21LLU, 16LLU) ? 18446744073709546231LLU : 18446744073709546230LLU; | |
84210 | 84521 | break; |
84211 | 84522 | } |
84212 | - case 18446744073709546246LLU: // 99999998qF''''''''''''''' | |
84523 | + case 18446744073709546231LLU: // 99999998p1''''''''''''''' | |
84213 | 84524 | { |
84214 | 84525 | fprintf(stderr, "%s", "INTERNAL ERROR: tmpresults"); |
84215 | 84526 | { |
@@ -84216,10 +84527,10 @@ | ||
84216 | 84527 | fprintf(stderr, "%s\n", ""); |
84217 | 84528 | exit(-1); |
84218 | 84529 | } |
84219 | - state.addr = 18446744073709546245LLU; // 99999998qE''''''''''''''' | |
84530 | + state.addr = 18446744073709546230LLU; // 99999998p0''''''''''''''' | |
84220 | 84531 | break; |
84221 | 84532 | } |
84222 | - case 18446744073709546245LLU: // 99999998qE''''''''''''''' | |
84533 | + case 18446744073709546230LLU: // 99999998p0''''''''''''''' | |
84223 | 84534 | { |
84224 | 84535 | { |
84225 | 84536 | uint64_t arg = 0; |
@@ -84226,16 +84537,16 @@ | ||
84226 | 84537 | LOCAL_PUSH_MOVE(&heap, 21, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
84227 | 84538 | } |
84228 | 84539 | *LOCAL_ACCESS(heap.data, 22LLU, 21LLU) = /*defbodysz_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 22LLU, 13LLU)) != /*ds________*/*LOCAL_ACCESS(heap.data, 22LLU, 18LLU); |
84229 | - state.addr = 18446744073709546242LLU; // 99999998qB''''''''''''''' | |
84540 | + state.addr = 18446744073709546227LLU; // 99999998px''''''''''''''' | |
84230 | 84541 | break; |
84231 | 84542 | } |
84232 | - case 18446744073709546242LLU: // 99999998qB''''''''''''''' | |
84543 | + case 18446744073709546227LLU: // 99999998px''''''''''''''' | |
84233 | 84544 | { |
84234 | - state.addr = *LOCAL_ACCESS(heap.data, 22LLU, 21LLU) ? 18446744073709546244LLU : 18446744073709546243LLU; | |
84545 | + state.addr = *LOCAL_ACCESS(heap.data, 22LLU, 21LLU) ? 18446744073709546229LLU : 18446744073709546228LLU; | |
84235 | 84546 | (void)LOCAL_POP_MOVE(&heap, 22LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 22 |
84236 | 84547 | break; |
84237 | 84548 | } |
84238 | - case 18446744073709546244LLU: // 99999998qD''''''''''''''' | |
84549 | + case 18446744073709546229LLU: // 99999998pz''''''''''''''' | |
84239 | 84550 | { |
84240 | 84551 | fprintf(stderr, "%s", "INTERNAL ERROR: defbodysz mismatch "); |
84241 | 84552 | // ACCUMULATE ARGUMENTS - BEGIN |
@@ -84244,7 +84555,7 @@ | ||
84244 | 84555 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
84245 | 84556 | } |
84246 | 84557 | // ACCUMULATE ARGUMENTS - END |
84247 | - uint64_t return_to = 18446744073709546240LLU; | |
84558 | + uint64_t return_to = 18446744073709546225LLU; | |
84248 | 84559 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
84249 | 84560 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
84250 | 84561 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -84253,12 +84564,12 @@ | ||
84253 | 84564 | state.addr = 819847183517274112LLU; // reportnr__ |
84254 | 84565 | break; |
84255 | 84566 | } |
84256 | - case 18446744073709546240LLU: // 99999998q_''''''''''''''' | |
84567 | + case 18446744073709546225LLU: // 99999998pv''''''''''''''' | |
84257 | 84568 | { |
84258 | - state.addr = 18446744073709546241LLU; // 99999998qA''''''''''''''' | |
84569 | + state.addr = 18446744073709546226LLU; // 99999998pw''''''''''''''' | |
84259 | 84570 | break; |
84260 | 84571 | } |
84261 | - case 18446744073709546241LLU: // 99999998qA''''''''''''''' | |
84572 | + case 18446744073709546226LLU: // 99999998pw''''''''''''''' | |
84262 | 84573 | { |
84263 | 84574 | fprintf(stderr, "%s", " != "); |
84264 | 84575 | // ACCUMULATE ARGUMENTS - BEGIN |
@@ -84267,7 +84578,7 @@ | ||
84267 | 84578 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
84268 | 84579 | } |
84269 | 84580 | // ACCUMULATE ARGUMENTS - END |
84270 | - uint64_t return_to = 18446744073709546238LLU; | |
84581 | + uint64_t return_to = 18446744073709546223LLU; | |
84271 | 84582 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
84272 | 84583 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
84273 | 84584 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -84276,21 +84587,21 @@ | ||
84276 | 84587 | state.addr = 819847183517274112LLU; // reportnr__ |
84277 | 84588 | break; |
84278 | 84589 | } |
84279 | - case 18446744073709546238LLU: // 99999998p8''''''''''''''' | |
84590 | + case 18446744073709546223LLU: // 99999998pt''''''''''''''' | |
84280 | 84591 | { |
84281 | - state.addr = 18446744073709546239LLU; // 99999998p9''''''''''''''' | |
84592 | + state.addr = 18446744073709546224LLU; // 99999998pu''''''''''''''' | |
84282 | 84593 | break; |
84283 | 84594 | } |
84284 | - case 18446744073709546239LLU: // 99999998p9''''''''''''''' | |
84595 | + case 18446744073709546224LLU: // 99999998pu''''''''''''''' | |
84285 | 84596 | { |
84286 | 84597 | { |
84287 | 84598 | fprintf(stderr, "%s\n", ""); |
84288 | 84599 | exit(-1); |
84289 | 84600 | } |
84290 | - state.addr = 18446744073709546243LLU; // 99999998qC''''''''''''''' | |
84601 | + state.addr = 18446744073709546228LLU; // 99999998py''''''''''''''' | |
84291 | 84602 | break; |
84292 | 84603 | } |
84293 | - case 18446744073709546243LLU: // 99999998qC''''''''''''''' | |
84604 | + case 18446744073709546228LLU: // 99999998py''''''''''''''' | |
84294 | 84605 | { |
84295 | 84606 | { |
84296 | 84607 | uint64_t arg = 0; |
@@ -84297,16 +84608,16 @@ | ||
84297 | 84608 | LOCAL_PUSH_MOVE(&heap, 21, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
84298 | 84609 | } |
84299 | 84610 | *LOCAL_ACCESS(heap.data, 22LLU, 21LLU) = /*remainsize*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 22LLU, 14LLU)) != /*rs________*/*LOCAL_ACCESS(heap.data, 22LLU, 19LLU); |
84300 | - state.addr = 18446744073709546235LLU; // 99999998p5''''''''''''''' | |
84611 | + state.addr = 18446744073709546220LLU; // 99999998pq''''''''''''''' | |
84301 | 84612 | break; |
84302 | 84613 | } |
84303 | - case 18446744073709546235LLU: // 99999998p5''''''''''''''' | |
84614 | + case 18446744073709546220LLU: // 99999998pq''''''''''''''' | |
84304 | 84615 | { |
84305 | - state.addr = *LOCAL_ACCESS(heap.data, 22LLU, 21LLU) ? 18446744073709546237LLU : 18446744073709546236LLU; | |
84616 | + state.addr = *LOCAL_ACCESS(heap.data, 22LLU, 21LLU) ? 18446744073709546222LLU : 18446744073709546221LLU; | |
84306 | 84617 | (void)LOCAL_POP_MOVE(&heap, 22LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 22 |
84307 | 84618 | break; |
84308 | 84619 | } |
84309 | - case 18446744073709546237LLU: // 99999998p7''''''''''''''' | |
84620 | + case 18446744073709546222LLU: // 99999998ps''''''''''''''' | |
84310 | 84621 | { |
84311 | 84622 | fprintf(stderr, "%s", "INTERNAL ERROR: remainsize mismatch "); |
84312 | 84623 | // ACCUMULATE ARGUMENTS - BEGIN |
@@ -84315,7 +84626,7 @@ | ||
84315 | 84626 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
84316 | 84627 | } |
84317 | 84628 | // ACCUMULATE ARGUMENTS - END |
84318 | - uint64_t return_to = 18446744073709546233LLU; | |
84629 | + uint64_t return_to = 18446744073709546218LLU; | |
84319 | 84630 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
84320 | 84631 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
84321 | 84632 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -84324,12 +84635,12 @@ | ||
84324 | 84635 | state.addr = 819847183517274112LLU; // reportnr__ |
84325 | 84636 | break; |
84326 | 84637 | } |
84327 | - case 18446744073709546233LLU: // 99999998p3''''''''''''''' | |
84638 | + case 18446744073709546218LLU: // 99999998po''''''''''''''' | |
84328 | 84639 | { |
84329 | - state.addr = 18446744073709546234LLU; // 99999998p4''''''''''''''' | |
84640 | + state.addr = 18446744073709546219LLU; // 99999998pp''''''''''''''' | |
84330 | 84641 | break; |
84331 | 84642 | } |
84332 | - case 18446744073709546234LLU: // 99999998p4''''''''''''''' | |
84643 | + case 18446744073709546219LLU: // 99999998pp''''''''''''''' | |
84333 | 84644 | { |
84334 | 84645 | fprintf(stderr, "%s", " != "); |
84335 | 84646 | // ACCUMULATE ARGUMENTS - BEGIN |
@@ -84338,7 +84649,7 @@ | ||
84338 | 84649 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
84339 | 84650 | } |
84340 | 84651 | // ACCUMULATE ARGUMENTS - END |
84341 | - uint64_t return_to = 18446744073709546231LLU; | |
84652 | + uint64_t return_to = 18446744073709546216LLU; | |
84342 | 84653 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
84343 | 84654 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
84344 | 84655 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -84347,21 +84658,21 @@ | ||
84347 | 84658 | state.addr = 819847183517274112LLU; // reportnr__ |
84348 | 84659 | break; |
84349 | 84660 | } |
84350 | - case 18446744073709546231LLU: // 99999998p1''''''''''''''' | |
84661 | + case 18446744073709546216LLU: // 99999998pm''''''''''''''' | |
84351 | 84662 | { |
84352 | - state.addr = 18446744073709546232LLU; // 99999998p2''''''''''''''' | |
84663 | + state.addr = 18446744073709546217LLU; // 99999998pn''''''''''''''' | |
84353 | 84664 | break; |
84354 | 84665 | } |
84355 | - case 18446744073709546232LLU: // 99999998p2''''''''''''''' | |
84666 | + case 18446744073709546217LLU: // 99999998pn''''''''''''''' | |
84356 | 84667 | { |
84357 | 84668 | { |
84358 | 84669 | fprintf(stderr, "%s\n", ""); |
84359 | 84670 | exit(-1); |
84360 | 84671 | } |
84361 | - state.addr = 18446744073709546236LLU; // 99999998p6''''''''''''''' | |
84672 | + state.addr = 18446744073709546221LLU; // 99999998pr''''''''''''''' | |
84362 | 84673 | break; |
84363 | 84674 | } |
84364 | - case 18446744073709546236LLU: // 99999998p6''''''''''''''' | |
84675 | + case 18446744073709546221LLU: // 99999998pr''''''''''''''' | |
84365 | 84676 | { |
84366 | 84677 | { |
84367 | 84678 | uint64_t arg = 0; |
@@ -84368,16 +84679,16 @@ | ||
84368 | 84679 | LOCAL_PUSH_MOVE(&heap, 21, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
84369 | 84680 | } |
84370 | 84681 | *LOCAL_ACCESS(heap.data, 22LLU, 21LLU) = /*remainheap*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 22LLU, 15LLU)) != /*rh________*/*LOCAL_ACCESS(heap.data, 22LLU, 20LLU); |
84371 | - state.addr = 18446744073709546228LLU; // 99999998py''''''''''''''' | |
84682 | + state.addr = 18446744073709546213LLU; // 99999998pj''''''''''''''' | |
84372 | 84683 | break; |
84373 | 84684 | } |
84374 | - case 18446744073709546228LLU: // 99999998py''''''''''''''' | |
84685 | + case 18446744073709546213LLU: // 99999998pj''''''''''''''' | |
84375 | 84686 | { |
84376 | - state.addr = *LOCAL_ACCESS(heap.data, 22LLU, 21LLU) ? 18446744073709546230LLU : 18446744073709546229LLU; | |
84687 | + state.addr = *LOCAL_ACCESS(heap.data, 22LLU, 21LLU) ? 18446744073709546215LLU : 18446744073709546214LLU; | |
84377 | 84688 | (void)LOCAL_POP_MOVE(&heap, 22LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 22 |
84378 | 84689 | break; |
84379 | 84690 | } |
84380 | - case 18446744073709546230LLU: // 99999998p0''''''''''''''' | |
84691 | + case 18446744073709546215LLU: // 99999998pl''''''''''''''' | |
84381 | 84692 | { |
84382 | 84693 | fprintf(stderr, "%s", "INTERNAL ERROR: remainheap mismatch "); |
84383 | 84694 | // ACCUMULATE ARGUMENTS - BEGIN |
@@ -84386,7 +84697,7 @@ | ||
84386 | 84697 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
84387 | 84698 | } |
84388 | 84699 | // ACCUMULATE ARGUMENTS - END |
84389 | - uint64_t return_to = 18446744073709546226LLU; | |
84700 | + uint64_t return_to = 18446744073709546211LLU; | |
84390 | 84701 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
84391 | 84702 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
84392 | 84703 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -84395,12 +84706,12 @@ | ||
84395 | 84706 | state.addr = 819847183517274112LLU; // reportnr__ |
84396 | 84707 | break; |
84397 | 84708 | } |
84398 | - case 18446744073709546226LLU: // 99999998pw''''''''''''''' | |
84709 | + case 18446744073709546211LLU: // 99999998ph''''''''''''''' | |
84399 | 84710 | { |
84400 | - state.addr = 18446744073709546227LLU; // 99999998px''''''''''''''' | |
84711 | + state.addr = 18446744073709546212LLU; // 99999998pi''''''''''''''' | |
84401 | 84712 | break; |
84402 | 84713 | } |
84403 | - case 18446744073709546227LLU: // 99999998px''''''''''''''' | |
84714 | + case 18446744073709546212LLU: // 99999998pi''''''''''''''' | |
84404 | 84715 | { |
84405 | 84716 | fprintf(stderr, "%s", " != "); |
84406 | 84717 | // ACCUMULATE ARGUMENTS - BEGIN |
@@ -84409,7 +84720,7 @@ | ||
84409 | 84720 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
84410 | 84721 | } |
84411 | 84722 | // ACCUMULATE ARGUMENTS - END |
84412 | - uint64_t return_to = 18446744073709546224LLU; | |
84723 | + uint64_t return_to = 18446744073709546209LLU; | |
84413 | 84724 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
84414 | 84725 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
84415 | 84726 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -84418,21 +84729,21 @@ | ||
84418 | 84729 | state.addr = 819847183517274112LLU; // reportnr__ |
84419 | 84730 | break; |
84420 | 84731 | } |
84421 | - case 18446744073709546224LLU: // 99999998pu''''''''''''''' | |
84732 | + case 18446744073709546209LLU: // 99999998pf''''''''''''''' | |
84422 | 84733 | { |
84423 | - state.addr = 18446744073709546225LLU; // 99999998pv''''''''''''''' | |
84734 | + state.addr = 18446744073709546210LLU; // 99999998pg''''''''''''''' | |
84424 | 84735 | break; |
84425 | 84736 | } |
84426 | - case 18446744073709546225LLU: // 99999998pv''''''''''''''' | |
84737 | + case 18446744073709546210LLU: // 99999998pg''''''''''''''' | |
84427 | 84738 | { |
84428 | 84739 | { |
84429 | 84740 | fprintf(stderr, "%s\n", ""); |
84430 | 84741 | exit(-1); |
84431 | 84742 | } |
84432 | - state.addr = 18446744073709546229LLU; // 99999998pz''''''''''''''' | |
84743 | + state.addr = 18446744073709546214LLU; // 99999998pk''''''''''''''' | |
84433 | 84744 | break; |
84434 | 84745 | } |
84435 | - case 18446744073709546229LLU: // 99999998pz''''''''''''''' | |
84746 | + case 18446744073709546214LLU: // 99999998pk''''''''''''''' | |
84436 | 84747 | { |
84437 | 84748 | // variable u64 rh________ goes out of scope |
84438 | 84749 | // emitted destructur for type u64 |
@@ -84443,10 +84754,10 @@ | ||
84443 | 84754 | // variable u64 ds________ goes out of scope |
84444 | 84755 | // emitted destructur for type u64 |
84445 | 84756 | (void)LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference ds________ at 19 |
84446 | - state.addr = 18446744073709546249LLU; // 99999998qI''''''''''''''' | |
84757 | + state.addr = 18446744073709546234LLU; // 99999998p4''''''''''''''' | |
84447 | 84758 | break; |
84448 | 84759 | } |
84449 | - case 18446744073709546249LLU: // 99999998qI''''''''''''''' | |
84760 | + case 18446744073709546234LLU: // 99999998p4''''''''''''''' | |
84450 | 84761 | { |
84451 | 84762 | // ACCUMULATE ARGUMENTS - BEGIN |
84452 | 84763 | { |
@@ -84454,7 +84765,7 @@ | ||
84454 | 84765 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
84455 | 84766 | } |
84456 | 84767 | // ACCUMULATE ARGUMENTS - END |
84457 | - uint64_t return_to = 18446744073709546222LLU; | |
84768 | + uint64_t return_to = 18446744073709546207LLU; | |
84458 | 84769 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
84459 | 84770 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
84460 | 84771 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -84463,12 +84774,12 @@ | ||
84463 | 84774 | state.addr = 839519719621918720LLU; // skipws____ |
84464 | 84775 | break; |
84465 | 84776 | } |
84466 | - case 18446744073709546222LLU: // 99999998ps''''''''''''''' | |
84777 | + case 18446744073709546207LLU: // 99999998pd''''''''''''''' | |
84467 | 84778 | { |
84468 | - state.addr = 18446744073709546223LLU; // 99999998pt''''''''''''''' | |
84779 | + state.addr = 18446744073709546208LLU; // 99999998pe''''''''''''''' | |
84469 | 84780 | break; |
84470 | 84781 | } |
84471 | - case 18446744073709546223LLU: // 99999998pt''''''''''''''' | |
84782 | + case 18446744073709546208LLU: // 99999998pe''''''''''''''' | |
84472 | 84783 | { |
84473 | 84784 | matchid("=", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 18LLU, 11LLU))); |
84474 | 84785 | // ACCUMULATE ARGUMENTS - BEGIN |
@@ -84477,7 +84788,7 @@ | ||
84477 | 84788 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
84478 | 84789 | } |
84479 | 84790 | // ACCUMULATE ARGUMENTS - END |
84480 | - uint64_t return_to = 18446744073709546220LLU; | |
84791 | + uint64_t return_to = 18446744073709546205LLU; | |
84481 | 84792 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
84482 | 84793 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
84483 | 84794 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -84486,12 +84797,12 @@ | ||
84486 | 84797 | state.addr = 839519719621918720LLU; // skipws____ |
84487 | 84798 | break; |
84488 | 84799 | } |
84489 | - case 18446744073709546220LLU: // 99999998pq''''''''''''''' | |
84800 | + case 18446744073709546205LLU: // 99999998pb''''''''''''''' | |
84490 | 84801 | { |
84491 | - state.addr = 18446744073709546221LLU; // 99999998pr''''''''''''''' | |
84802 | + state.addr = 18446744073709546206LLU; // 99999998pc''''''''''''''' | |
84492 | 84803 | break; |
84493 | 84804 | } |
84494 | - case 18446744073709546221LLU: // 99999998pr''''''''''''''' | |
84805 | + case 18446744073709546206LLU: // 99999998pc''''''''''''''' | |
84495 | 84806 | { |
84496 | 84807 | { |
84497 | 84808 | uint64_t arg = 0; |
@@ -84503,16 +84814,16 @@ | ||
84503 | 84814 | LOCAL_PUSH_MOVE(&heap, 19, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
84504 | 84815 | } |
84505 | 84816 | *LOCAL_ACCESS(heap.data, 20LLU, 19LLU) = /*sym_______*/*LOCAL_ACCESS(heap.data, 20LLU, 18LLU) == /*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 20LLU, 11LLU)); |
84506 | - state.addr = 18446744073709546217LLU; // 99999998pn''''''''''''''' | |
84817 | + state.addr = 18446744073709546202LLU; // 99999998pZ''''''''''''''' | |
84507 | 84818 | break; |
84508 | 84819 | } |
84509 | - case 18446744073709546217LLU: // 99999998pn''''''''''''''' | |
84820 | + case 18446744073709546202LLU: // 99999998pZ''''''''''''''' | |
84510 | 84821 | { |
84511 | - state.addr = *LOCAL_ACCESS(heap.data, 20LLU, 19LLU) ? 18446744073709546219LLU : 18446744073709546218LLU; | |
84822 | + state.addr = *LOCAL_ACCESS(heap.data, 20LLU, 19LLU) ? 18446744073709546204LLU : 18446744073709546203LLU; | |
84512 | 84823 | (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 20 |
84513 | 84824 | break; |
84514 | 84825 | } |
84515 | - case 18446744073709546219LLU: // 99999998pp''''''''''''''' | |
84826 | + case 18446744073709546204LLU: // 99999998pa''''''''''''''' | |
84516 | 84827 | { |
84517 | 84828 | // ACCUMULATE ARGUMENTS - BEGIN |
84518 | 84829 | { |
@@ -84540,7 +84851,7 @@ | ||
84540 | 84851 | LOCAL_PUSH_MOVE(&heap, 5LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
84541 | 84852 | } |
84542 | 84853 | // ACCUMULATE ARGUMENTS - END |
84543 | - uint64_t return_to = 18446744073709546215LLU; | |
84854 | + uint64_t return_to = 18446744073709546200LLU; | |
84544 | 84855 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 6LLU, 0/*address of closure-in-construction*/, 0)); |
84545 | 84856 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
84546 | 84857 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 6LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -84549,20 +84860,20 @@ | ||
84549 | 84860 | state.addr = 533581901922699840LLU; // blockopen_ |
84550 | 84861 | break; |
84551 | 84862 | } |
84552 | - case 18446744073709546215LLU: // 99999998pl''''''''''''''' | |
84863 | + case 18446744073709546200LLU: // 99999998pX''''''''''''''' | |
84553 | 84864 | { |
84554 | - state.addr = 18446744073709546216LLU; // 99999998pm''''''''''''''' | |
84865 | + state.addr = 18446744073709546201LLU; // 99999998pY''''''''''''''' | |
84555 | 84866 | break; |
84556 | 84867 | } |
84557 | - case 18446744073709546216LLU: // 99999998pm''''''''''''''' | |
84868 | + case 18446744073709546201LLU: // 99999998pY''''''''''''''' | |
84558 | 84869 | { |
84559 | 84870 | swap(&/*results___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 10LLU)), &/*newresults*/*LOCAL_ACCESS(heap.data, 19LLU, 17LLU)); |
84560 | 84871 | heap.availilable_size_for_dynamic_objects += 0LLU; |
84561 | 84872 | heap.availilable_size_for_dynamic_objects += 0LLU; |
84562 | - state.addr = 18446744073709546214LLU; // 99999998pk''''''''''''''' | |
84873 | + state.addr = 18446744073709546199LLU; // 99999998pW''''''''''''''' | |
84563 | 84874 | break; |
84564 | 84875 | } |
84565 | - case 18446744073709546218LLU: // 99999998po''''''''''''''' | |
84876 | + case 18446744073709546203LLU: // 99999998p$''''''''''''''' | |
84566 | 84877 | { |
84567 | 84878 | // ACCUMULATE ARGUMENTS - BEGIN |
84568 | 84879 | { |
@@ -84634,7 +84945,7 @@ | ||
84634 | 84945 | LOCAL_PUSH_MOVE(&heap, 16LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
84635 | 84946 | } |
84636 | 84947 | // ACCUMULATE ARGUMENTS - END |
84637 | - uint64_t return_to = 18446744073709546212LLU; | |
84948 | + uint64_t return_to = 18446744073709546197LLU; | |
84638 | 84949 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 17LLU, 0/*address of closure-in-construction*/, 0)); |
84639 | 84950 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
84640 | 84951 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 17LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -84643,17 +84954,17 @@ | ||
84643 | 84954 | state.addr = 787472338545441824LLU; // procrvalue |
84644 | 84955 | break; |
84645 | 84956 | } |
84646 | - case 18446744073709546212LLU: // 99999998pi''''''''''''''' | |
84957 | + case 18446744073709546197LLU: // 99999998pU''''''''''''''' | |
84647 | 84958 | { |
84648 | - state.addr = 18446744073709546213LLU; // 99999998pj''''''''''''''' | |
84959 | + state.addr = 18446744073709546198LLU; // 99999998pV''''''''''''''' | |
84649 | 84960 | break; |
84650 | 84961 | } |
84651 | - case 18446744073709546213LLU: // 99999998pj''''''''''''''' | |
84962 | + case 18446744073709546198LLU: // 99999998pV''''''''''''''' | |
84652 | 84963 | { |
84653 | - state.addr = 18446744073709546214LLU; // 99999998pk''''''''''''''' | |
84964 | + state.addr = 18446744073709546199LLU; // 99999998pW''''''''''''''' | |
84654 | 84965 | break; |
84655 | 84966 | } |
84656 | - case 18446744073709546214LLU: // 99999998pk''''''''''''''' | |
84967 | + case 18446744073709546199LLU: // 99999998pW''''''''''''''' | |
84657 | 84968 | { |
84658 | 84969 | // variable u64 sym_______ goes out of scope |
84659 | 84970 | // emitted destructur for type u64 |
@@ -84660,14 +84971,14 @@ | ||
84660 | 84971 | (void)LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference sym_______ at 19 |
84661 | 84972 | // variable list<resdest___> newresults goes out of scope |
84662 | 84973 | // emitted destructur for type list<resdest___> |
84663 | - state.addr = 18446744073709546210LLU; // 99999998pg''''''''''''''' | |
84974 | + state.addr = 18446744073709546195LLU; // 99999998pS''''''''''''''' | |
84664 | 84975 | break; |
84665 | 84976 | } |
84666 | - case 18446744073709546210LLU: // 99999998pg''''''''''''''' | |
84977 | + case 18446744073709546195LLU: // 99999998pS''''''''''''''' | |
84667 | 84978 | { |
84668 | 84979 | if(!*LOCAL_ACCESS(heap.data, 18LLU, 17LLU)/*list*/) |
84669 | 84980 | { |
84670 | - state.addr = 18446744073709546211LLU; // 99999998ph''''''''''''''' | |
84981 | + state.addr = 18446744073709546196LLU; // 99999998pT''''''''''''''' | |
84671 | 84982 | break; |
84672 | 84983 | } |
84673 | 84984 | // temporary list-element |
@@ -84681,7 +84992,7 @@ | ||
84681 | 84992 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
84682 | 84993 | } |
84683 | 84994 | // ACCUMULATE ARGUMENTS - END |
84684 | - uint64_t return_to = 18446744073709546209LLU; | |
84995 | + uint64_t return_to = 18446744073709546194LLU; | |
84685 | 84996 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
84686 | 84997 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
84687 | 84998 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -84690,26 +85001,26 @@ | ||
84690 | 85001 | state.addr = 18446744073709551475LLU; // 999999997x''''''''''''''' |
84691 | 85002 | break; |
84692 | 85003 | } |
84693 | - case 18446744073709546209LLU: // 99999998pf''''''''''''''' | |
85004 | + case 18446744073709546194LLU: // 99999998pR''''''''''''''' | |
84694 | 85005 | { |
84695 | 85006 | // RELEASE temporary destructor-variable |
84696 | 85007 | (void)LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 19 |
84697 | - state.addr = 18446744073709546210LLU; // 99999998pg''''''''''''''' | |
85008 | + state.addr = 18446744073709546195LLU; // 99999998pS''''''''''''''' | |
84698 | 85009 | break; |
84699 | 85010 | } |
84700 | - case 18446744073709546211LLU: // 99999998ph''''''''''''''' | |
85011 | + case 18446744073709546196LLU: // 99999998pT''''''''''''''' | |
84701 | 85012 | { |
84702 | 85013 | (void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference newresults at 18 |
84703 | 85014 | // variable list<resdest___> tmpresults goes out of scope |
84704 | 85015 | // emitted destructur for type list<resdest___> |
84705 | - state.addr = 18446744073709546207LLU; // 99999998pd''''''''''''''' | |
85016 | + state.addr = 18446744073709546192LLU; // 99999998pP''''''''''''''' | |
84706 | 85017 | break; |
84707 | 85018 | } |
84708 | - case 18446744073709546207LLU: // 99999998pd''''''''''''''' | |
85019 | + case 18446744073709546192LLU: // 99999998pP''''''''''''''' | |
84709 | 85020 | { |
84710 | 85021 | if(!*LOCAL_ACCESS(heap.data, 17LLU, 16LLU)/*list*/) |
84711 | 85022 | { |
84712 | - state.addr = 18446744073709546208LLU; // 99999998pe''''''''''''''' | |
85023 | + state.addr = 18446744073709546193LLU; // 99999998pQ''''''''''''''' | |
84713 | 85024 | break; |
84714 | 85025 | } |
84715 | 85026 | // temporary list-element |
@@ -84723,7 +85034,7 @@ | ||
84723 | 85034 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
84724 | 85035 | } |
84725 | 85036 | // ACCUMULATE ARGUMENTS - END |
84726 | - uint64_t return_to = 18446744073709546206LLU; | |
85037 | + uint64_t return_to = 18446744073709546191LLU; | |
84727 | 85038 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
84728 | 85039 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
84729 | 85040 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -84732,14 +85043,14 @@ | ||
84732 | 85043 | state.addr = 18446744073709551475LLU; // 999999997x''''''''''''''' |
84733 | 85044 | break; |
84734 | 85045 | } |
84735 | - case 18446744073709546206LLU: // 99999998pc''''''''''''''' | |
85046 | + case 18446744073709546191LLU: // 99999998pO''''''''''''''' | |
84736 | 85047 | { |
84737 | 85048 | // RELEASE temporary destructor-variable |
84738 | 85049 | (void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 18 |
84739 | - state.addr = 18446744073709546207LLU; // 99999998pd''''''''''''''' | |
85050 | + state.addr = 18446744073709546192LLU; // 99999998pP''''''''''''''' | |
84740 | 85051 | break; |
84741 | 85052 | } |
84742 | - case 18446744073709546208LLU: // 99999998pe''''''''''''''' | |
85053 | + case 18446744073709546193LLU: // 99999998pQ''''''''''''''' | |
84743 | 85054 | { |
84744 | 85055 | (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference tmpresults at 17 |
84745 | 85056 | // parameter-reference u64 remainheap goes out of scope |
@@ -84790,7 +85101,7 @@ | ||
84790 | 85101 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
84791 | 85102 | } |
84792 | 85103 | // ACCUMULATE ARGUMENTS - END |
84793 | - uint64_t return_to = 18446744073709546204LLU; | |
85104 | + uint64_t return_to = 18446744073709546189LLU; | |
84794 | 85105 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
84795 | 85106 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
84796 | 85107 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -84799,12 +85110,12 @@ | ||
84799 | 85110 | state.addr = 839519719621918720LLU; // skipws____ |
84800 | 85111 | break; |
84801 | 85112 | } |
84802 | - case 18446744073709546204LLU: // 99999998pa''''''''''''''' | |
85113 | + case 18446744073709546189LLU: // 99999998pM''''''''''''''' | |
84803 | 85114 | { |
84804 | - state.addr = 18446744073709546205LLU; // 99999998pb''''''''''''''' | |
85115 | + state.addr = 18446744073709546190LLU; // 99999998pN''''''''''''''' | |
84805 | 85116 | break; |
84806 | 85117 | } |
84807 | - case 18446744073709546205LLU: // 99999998pb''''''''''''''' | |
85118 | + case 18446744073709546190LLU: // 99999998pN''''''''''''''' | |
84808 | 85119 | { |
84809 | 85120 | { |
84810 | 85121 | uint64_t arg = 0; |
@@ -84811,10 +85122,10 @@ | ||
84811 | 85122 | LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
84812 | 85123 | } |
84813 | 85124 | *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 10LLU))); |
84814 | - state.addr = 18446744073709546203LLU; // 99999998p$''''''''''''''' | |
85125 | + state.addr = 18446744073709546188LLU; // 99999998pL''''''''''''''' | |
84815 | 85126 | break; |
84816 | 85127 | } |
84817 | - case 18446744073709546203LLU: // 99999998p$''''''''''''''' | |
85128 | + case 18446744073709546188LLU: // 99999998pL''''''''''''''' | |
84818 | 85129 | { |
84819 | 85130 | { |
84820 | 85131 | uint64_t arg = 0; |
@@ -84843,7 +85154,7 @@ | ||
84843 | 85154 | LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
84844 | 85155 | } |
84845 | 85156 | // ACCUMULATE ARGUMENTS - END |
84846 | - uint64_t return_to = 18446744073709546201LLU; | |
85157 | + uint64_t return_to = 18446744073709546186LLU; | |
84847 | 85158 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
84848 | 85159 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
84849 | 85160 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -84852,12 +85163,12 @@ | ||
84852 | 85163 | state.addr = 782701543487916768LLU; // parsemtype |
84853 | 85164 | break; |
84854 | 85165 | } |
84855 | - case 18446744073709546201LLU: // 99999998pY''''''''''''''' | |
85166 | + case 18446744073709546186LLU: // 99999998pJ''''''''''''''' | |
84856 | 85167 | { |
84857 | - state.addr = 18446744073709546202LLU; // 99999998pZ''''''''''''''' | |
85168 | + state.addr = 18446744073709546187LLU; // 99999998pK''''''''''''''' | |
84858 | 85169 | break; |
84859 | 85170 | } |
84860 | - case 18446744073709546202LLU: // 99999998pZ''''''''''''''' | |
85171 | + case 18446744073709546187LLU: // 99999998pK''''''''''''''' | |
84861 | 85172 | { |
84862 | 85173 | // ACCUMULATE ARGUMENTS - BEGIN |
84863 | 85174 | { |
@@ -84865,7 +85176,7 @@ | ||
84865 | 85176 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
84866 | 85177 | } |
84867 | 85178 | // ACCUMULATE ARGUMENTS - END |
84868 | - uint64_t return_to = 18446744073709546199LLU; | |
85179 | + uint64_t return_to = 18446744073709546184LLU; | |
84869 | 85180 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
84870 | 85181 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
84871 | 85182 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -84874,24 +85185,24 @@ | ||
84874 | 85185 | state.addr = 839519719621918720LLU; // skipws____ |
84875 | 85186 | break; |
84876 | 85187 | } |
84877 | - case 18446744073709546199LLU: // 99999998pW''''''''''''''' | |
85188 | + case 18446744073709546184LLU: // 99999998pH''''''''''''''' | |
84878 | 85189 | { |
84879 | - state.addr = 18446744073709546200LLU; // 99999998pX''''''''''''''' | |
85190 | + state.addr = 18446744073709546185LLU; // 99999998pI''''''''''''''' | |
84880 | 85191 | break; |
84881 | 85192 | } |
84882 | - case 18446744073709546200LLU: // 99999998pX''''''''''''''' | |
85193 | + case 18446744073709546185LLU: // 99999998pI''''''''''''''' | |
84883 | 85194 | { |
84884 | 85195 | |
84885 | - state.addr = 18446744073709546198LLU; // 99999998pV''''''''''''''' | |
85196 | + state.addr = 18446744073709546183LLU; // 99999998pG''''''''''''''' | |
84886 | 85197 | break; |
84887 | 85198 | } |
84888 | - case 18446744073709546198LLU: // 99999998pV''''''''''''''' | |
85199 | + case 18446744073709546183LLU: // 99999998pG''''''''''''''' | |
84889 | 85200 | { |
84890 | 85201 | *LOCAL_ACCESS(heap.data, 19LLU, 16LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 10LLU))); |
84891 | - state.addr = 18446744073709546197LLU; // 99999998pU''''''''''''''' | |
85202 | + state.addr = 18446744073709546182LLU; // 99999998pF''''''''''''''' | |
84892 | 85203 | break; |
84893 | 85204 | } |
84894 | - case 18446744073709546197LLU: // 99999998pU''''''''''''''' | |
85205 | + case 18446744073709546182LLU: // 99999998pF''''''''''''''' | |
84895 | 85206 | { |
84896 | 85207 | { |
84897 | 85208 | uint64_t arg = 0; |
@@ -84916,7 +85227,7 @@ | ||
84916 | 85227 | LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
84917 | 85228 | } |
84918 | 85229 | // ACCUMULATE ARGUMENTS - END |
84919 | - uint64_t return_to = 18446744073709546195LLU; | |
85230 | + uint64_t return_to = 18446744073709546180LLU; | |
84920 | 85231 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
84921 | 85232 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
84922 | 85233 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -84925,17 +85236,17 @@ | ||
84925 | 85236 | state.addr = 696275824427849761LLU; // knowvarref |
84926 | 85237 | break; |
84927 | 85238 | } |
84928 | - case 18446744073709546195LLU: // 99999998pS''''''''''''''' | |
85239 | + case 18446744073709546180LLU: // 99999998pD''''''''''''''' | |
84929 | 85240 | { |
84930 | - state.addr = 18446744073709546196LLU; // 99999998pT''''''''''''''' | |
85241 | + state.addr = 18446744073709546181LLU; // 99999998pE''''''''''''''' | |
84931 | 85242 | break; |
84932 | 85243 | } |
84933 | - case 18446744073709546196LLU: // 99999998pT''''''''''''''' | |
85244 | + case 18446744073709546181LLU: // 99999998pE''''''''''''''' | |
84934 | 85245 | { |
84935 | - state.addr = *LOCAL_ACCESS(heap.data, 20LLU, 19LLU) ? 18446744073709546194LLU : 18446744073709546193LLU; | |
85246 | + state.addr = *LOCAL_ACCESS(heap.data, 20LLU, 19LLU) ? 18446744073709546179LLU : 18446744073709546178LLU; | |
84936 | 85247 | break; |
84937 | 85248 | } |
84938 | - case 18446744073709546194LLU: // 99999998pR''''''''''''''' | |
85249 | + case 18446744073709546179LLU: // 99999998pC''''''''''''''' | |
84939 | 85250 | { |
84940 | 85251 | // ACCUMULATE ARGUMENTS - BEGIN |
84941 | 85252 | { |
@@ -84943,7 +85254,7 @@ | ||
84943 | 85254 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
84944 | 85255 | } |
84945 | 85256 | // ACCUMULATE ARGUMENTS - END |
84946 | - uint64_t return_to = 18446744073709546191LLU; | |
85257 | + uint64_t return_to = 18446744073709546176LLU; | |
84947 | 85258 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
84948 | 85259 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
84949 | 85260 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -84952,12 +85263,12 @@ | ||
84952 | 85263 | state.addr = 839519719621918720LLU; // skipws____ |
84953 | 85264 | break; |
84954 | 85265 | } |
84955 | - case 18446744073709546191LLU: // 99999998pO''''''''''''''' | |
85266 | + case 18446744073709546176LLU: // 99999998p_''''''''''''''' | |
84956 | 85267 | { |
84957 | - state.addr = 18446744073709546192LLU; // 99999998pP''''''''''''''' | |
85268 | + state.addr = 18446744073709546177LLU; // 99999998pA''''''''''''''' | |
84958 | 85269 | break; |
84959 | 85270 | } |
84960 | - case 18446744073709546192LLU: // 99999998pP''''''''''''''' | |
85271 | + case 18446744073709546177LLU: // 99999998pA''''''''''''''' | |
84961 | 85272 | { |
84962 | 85273 | { |
84963 | 85274 | uint64_t arg = 0; |
@@ -84964,10 +85275,10 @@ | ||
84964 | 85275 | LOCAL_PUSH_MOVE(&heap, 20, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
84965 | 85276 | } |
84966 | 85277 | *LOCAL_ACCESS(heap.data, 21LLU, 20LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 10LLU))); |
84967 | - state.addr = 18446744073709546190LLU; // 99999998pN''''''''''''''' | |
85278 | + state.addr = 18446744073709546175LLU; // 99999998o9''''''''''''''' | |
84968 | 85279 | break; |
84969 | 85280 | } |
84970 | - case 18446744073709546190LLU: // 99999998pN''''''''''''''' | |
85281 | + case 18446744073709546175LLU: // 99999998o9''''''''''''''' | |
84971 | 85282 | { |
84972 | 85283 | { |
84973 | 85284 | uint64_t arg = 0; |
@@ -84979,23 +85290,23 @@ | ||
84979 | 85290 | LOCAL_PUSH_MOVE(&heap, 22, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
84980 | 85291 | } |
84981 | 85292 | *LOCAL_ACCESS(heap.data, 23LLU, 22LLU) = /*buf_______*/*LOCAL_ACCESS(heap.data, 23LLU, 20LLU) == /*shadow____*/*LOCAL_ACCESS(heap.data, 23LLU, 21LLU); |
84982 | - state.addr = 18446744073709546187LLU; // 99999998pK''''''''''''''' | |
85293 | + state.addr = 18446744073709546172LLU; // 99999998o6''''''''''''''' | |
84983 | 85294 | break; |
84984 | 85295 | } |
84985 | - case 18446744073709546187LLU: // 99999998pK''''''''''''''' | |
85296 | + case 18446744073709546172LLU: // 99999998o6''''''''''''''' | |
84986 | 85297 | { |
84987 | - state.addr = *LOCAL_ACCESS(heap.data, 23LLU, 22LLU) ? 18446744073709546189LLU : 18446744073709546188LLU; | |
85298 | + state.addr = *LOCAL_ACCESS(heap.data, 23LLU, 22LLU) ? 18446744073709546174LLU : 18446744073709546173LLU; | |
84988 | 85299 | (void)LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 23 |
84989 | 85300 | break; |
84990 | 85301 | } |
84991 | - case 18446744073709546189LLU: // 99999998pM''''''''''''''' | |
85302 | + case 18446744073709546174LLU: // 99999998o8''''''''''''''' | |
84992 | 85303 | { |
84993 | 85304 | heap.availilable_size_for_dynamic_objects += 0LLU; |
84994 | 85305 | heap.availilable_size_for_dynamic_objects += 0LLU; |
84995 | - state.addr = 18446744073709546186LLU; // 99999998pJ''''''''''''''' | |
85306 | + state.addr = 18446744073709546171LLU; // 99999998o5''''''''''''''' | |
84996 | 85307 | break; |
84997 | 85308 | } |
84998 | - case 18446744073709546188LLU: // 99999998pL''''''''''''''' | |
85309 | + case 18446744073709546173LLU: // 99999998o7''''''''''''''' | |
84999 | 85310 | { |
85000 | 85311 | // ACCUMULATE ARGUMENTS - BEGIN |
85001 | 85312 | { |
@@ -85003,7 +85314,7 @@ | ||
85003 | 85314 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
85004 | 85315 | } |
85005 | 85316 | // ACCUMULATE ARGUMENTS - END |
85006 | - uint64_t return_to = 18446744073709546184LLU; | |
85317 | + uint64_t return_to = 18446744073709546169LLU; | |
85007 | 85318 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
85008 | 85319 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
85009 | 85320 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -85012,12 +85323,12 @@ | ||
85012 | 85323 | state.addr = 819847183515949359LLU; // reportinit |
85013 | 85324 | break; |
85014 | 85325 | } |
85015 | - case 18446744073709546184LLU: // 99999998pH''''''''''''''' | |
85326 | + case 18446744073709546169LLU: // 99999998o3''''''''''''''' | |
85016 | 85327 | { |
85017 | - state.addr = 18446744073709546185LLU; // 99999998pI''''''''''''''' | |
85328 | + state.addr = 18446744073709546170LLU; // 99999998o4''''''''''''''' | |
85018 | 85329 | break; |
85019 | 85330 | } |
85020 | - case 18446744073709546185LLU: // 99999998pI''''''''''''''' | |
85331 | + case 18446744073709546170LLU: // 99999998o4''''''''''''''' | |
85021 | 85332 | { |
85022 | 85333 | fprintf(stderr, "%s", "variable "); |
85023 | 85334 | printid(stderr, /*id________*/*LOCAL_ACCESS(heap.data, 22LLU, 16LLU)); |
@@ -85027,10 +85338,10 @@ | ||
85027 | 85338 | fprintf(stderr, "%s\n", ""); |
85028 | 85339 | exit(-1); |
85029 | 85340 | } |
85030 | - state.addr = 18446744073709546186LLU; // 99999998pJ''''''''''''''' | |
85341 | + state.addr = 18446744073709546171LLU; // 99999998o5''''''''''''''' | |
85031 | 85342 | break; |
85032 | 85343 | } |
85033 | - case 18446744073709546186LLU: // 99999998pJ''''''''''''''' | |
85344 | + case 18446744073709546171LLU: // 99999998o5''''''''''''''' | |
85034 | 85345 | { |
85035 | 85346 | // variable u64 shadow____ goes out of scope |
85036 | 85347 | // emitted destructur for type u64 |
@@ -85038,10 +85349,10 @@ | ||
85038 | 85349 | // variable u64 buf_______ goes out of scope |
85039 | 85350 | // emitted destructur for type u64 |
85040 | 85351 | (void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference buf_______ at 21 |
85041 | - state.addr = 18446744073709546193LLU; // 99999998pQ''''''''''''''' | |
85352 | + state.addr = 18446744073709546178LLU; // 99999998pB''''''''''''''' | |
85042 | 85353 | break; |
85043 | 85354 | } |
85044 | - case 18446744073709546193LLU: // 99999998pQ''''''''''''''' | |
85355 | + case 18446744073709546178LLU: // 99999998pB''''''''''''''' | |
85045 | 85356 | { |
85046 | 85357 | // ACCUMULATE ARGUMENTS - BEGIN |
85047 | 85358 | { |
@@ -85065,7 +85376,7 @@ | ||
85065 | 85376 | LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
85066 | 85377 | } |
85067 | 85378 | // ACCUMULATE ARGUMENTS - END |
85068 | - uint64_t return_to = 18446744073709546182LLU; | |
85379 | + uint64_t return_to = 18446744073709546167LLU; | |
85069 | 85380 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)); |
85070 | 85381 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
85071 | 85382 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -85074,12 +85385,12 @@ | ||
85074 | 85385 | state.addr = 515555125197130432LLU; // allocheap_ |
85075 | 85386 | break; |
85076 | 85387 | } |
85077 | - case 18446744073709546182LLU: // 99999998pF''''''''''''''' | |
85388 | + case 18446744073709546167LLU: // 99999998o1''''''''''''''' | |
85078 | 85389 | { |
85079 | - state.addr = 18446744073709546183LLU; // 99999998pG''''''''''''''' | |
85390 | + state.addr = 18446744073709546168LLU; // 99999998o2''''''''''''''' | |
85080 | 85391 | break; |
85081 | 85392 | } |
85082 | - case 18446744073709546183LLU: // 99999998pG''''''''''''''' | |
85393 | + case 18446744073709546168LLU: // 99999998o2''''''''''''''' | |
85083 | 85394 | { |
85084 | 85395 | { |
85085 | 85396 | uint64_t arg = 0; |
@@ -85088,7 +85399,7 @@ | ||
85088 | 85399 | *LOCAL_ACCESS(heap.data, 21LLU, 20LLU) = 0; |
85089 | 85400 | // ACCUMULATE ARGUMENTS - BEGIN |
85090 | 85401 | // ACCUMULATE ARGUMENTS - END |
85091 | - uint64_t return_to = 18446744073709546179LLU; | |
85402 | + uint64_t return_to = 18446744073709546164LLU; | |
85092 | 85403 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 0LLU, 0/*address of closure-in-construction*/, 0)); |
85093 | 85404 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
85094 | 85405 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 0LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -85097,12 +85408,12 @@ | ||
85097 | 85408 | state.addr = 890787671342055424LLU; // varopen___ |
85098 | 85409 | break; |
85099 | 85410 | } |
85100 | - case 18446744073709546179LLU: // 99999998pC''''''''''''''' | |
85411 | + case 18446744073709546164LLU: // 99999998oy''''''''''''''' | |
85101 | 85412 | { |
85102 | - state.addr = 18446744073709546180LLU; // 99999998pD''''''''''''''' | |
85413 | + state.addr = 18446744073709546165LLU; // 99999998oz''''''''''''''' | |
85103 | 85414 | break; |
85104 | 85415 | } |
85105 | - case 18446744073709546180LLU: // 99999998pD''''''''''''''' | |
85416 | + case 18446744073709546165LLU: // 99999998oz''''''''''''''' | |
85106 | 85417 | { |
85107 | 85418 | fprintf(stdout, "%s", "0"); |
85108 | 85419 | // ACCUMULATE ARGUMENTS - BEGIN |
@@ -85127,7 +85438,7 @@ | ||
85127 | 85438 | LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
85128 | 85439 | } |
85129 | 85440 | // ACCUMULATE ARGUMENTS - END |
85130 | - uint64_t return_to = 18446744073709546177LLU; | |
85441 | + uint64_t return_to = 18446744073709546162LLU; | |
85131 | 85442 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)); |
85132 | 85443 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
85133 | 85444 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -85136,12 +85447,12 @@ | ||
85136 | 85447 | state.addr = 890786842582581248LLU; // varclose__ |
85137 | 85448 | break; |
85138 | 85449 | } |
85139 | - case 18446744073709546177LLU: // 99999998pA''''''''''''''' | |
85450 | + case 18446744073709546162LLU: // 99999998ow''''''''''''''' | |
85140 | 85451 | { |
85141 | - state.addr = 18446744073709546178LLU; // 99999998pB''''''''''''''' | |
85452 | + state.addr = 18446744073709546163LLU; // 99999998ox''''''''''''''' | |
85142 | 85453 | break; |
85143 | 85454 | } |
85144 | - case 18446744073709546178LLU: // 99999998pB''''''''''''''' | |
85455 | + case 18446744073709546163LLU: // 99999998ox''''''''''''''' | |
85145 | 85456 | { |
85146 | 85457 | // ACCUMULATE ARGUMENTS - BEGIN |
85147 | 85458 | { |
@@ -85149,7 +85460,7 @@ | ||
85149 | 85460 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
85150 | 85461 | } |
85151 | 85462 | // ACCUMULATE ARGUMENTS - END |
85152 | - uint64_t return_to = 18446744073709546175LLU; | |
85463 | + uint64_t return_to = 18446744073709546160LLU; | |
85153 | 85464 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
85154 | 85465 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
85155 | 85466 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -85158,12 +85469,12 @@ | ||
85158 | 85469 | state.addr = 839519719621918720LLU; // skipws____ |
85159 | 85470 | break; |
85160 | 85471 | } |
85161 | - case 18446744073709546175LLU: // 99999998o9''''''''''''''' | |
85472 | + case 18446744073709546160LLU: // 99999998ou''''''''''''''' | |
85162 | 85473 | { |
85163 | - state.addr = 18446744073709546176LLU; // 99999998p_''''''''''''''' | |
85474 | + state.addr = 18446744073709546161LLU; // 99999998ov''''''''''''''' | |
85164 | 85475 | break; |
85165 | 85476 | } |
85166 | - case 18446744073709546176LLU: // 99999998p_''''''''''''''' | |
85477 | + case 18446744073709546161LLU: // 99999998ov''''''''''''''' | |
85167 | 85478 | { |
85168 | 85479 | { |
85169 | 85480 | uint64_t arg = 0; |
@@ -85189,7 +85500,7 @@ | ||
85189 | 85500 | LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
85190 | 85501 | } |
85191 | 85502 | // ACCUMULATE ARGUMENTS - END |
85192 | - uint64_t return_to = 18446744073709546173LLU; | |
85503 | + uint64_t return_to = 18446744073709546158LLU; | |
85193 | 85504 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)); |
85194 | 85505 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
85195 | 85506 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -85198,17 +85509,17 @@ | ||
85198 | 85509 | state.addr = 728666047794575267LLU; // matchoptch |
85199 | 85510 | break; |
85200 | 85511 | } |
85201 | - case 18446744073709546173LLU: // 99999998o7''''''''''''''' | |
85512 | + case 18446744073709546158LLU: // 99999998os''''''''''''''' | |
85202 | 85513 | { |
85203 | - state.addr = 18446744073709546174LLU; // 99999998o8''''''''''''''' | |
85514 | + state.addr = 18446744073709546159LLU; // 99999998ot''''''''''''''' | |
85204 | 85515 | break; |
85205 | 85516 | } |
85206 | - case 18446744073709546174LLU: // 99999998o8''''''''''''''' | |
85517 | + case 18446744073709546159LLU: // 99999998ot''''''''''''''' | |
85207 | 85518 | { |
85208 | - state.addr = *LOCAL_ACCESS(heap.data, 23LLU, 22LLU) ? 18446744073709546172LLU : 18446744073709546171LLU; | |
85519 | + state.addr = *LOCAL_ACCESS(heap.data, 23LLU, 22LLU) ? 18446744073709546157LLU : 18446744073709546156LLU; | |
85209 | 85520 | break; |
85210 | 85521 | } |
85211 | - case 18446744073709546172LLU: // 99999998o6''''''''''''''' | |
85522 | + case 18446744073709546157LLU: // 99999998or''''''''''''''' | |
85212 | 85523 | { |
85213 | 85524 | { |
85214 | 85525 | uint64_t arg = 0; |
@@ -85229,7 +85540,7 @@ | ||
85229 | 85540 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
85230 | 85541 | } |
85231 | 85542 | // ACCUMULATE ARGUMENTS - END |
85232 | - uint64_t return_to = 18446744073709546169LLU; | |
85543 | + uint64_t return_to = 18446744073709546154LLU; | |
85233 | 85544 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
85234 | 85545 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
85235 | 85546 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -85238,12 +85549,12 @@ | ||
85238 | 85549 | state.addr = 661640243165790208LLU; // islist____ |
85239 | 85550 | break; |
85240 | 85551 | } |
85241 | - case 18446744073709546169LLU: // 99999998o3''''''''''''''' | |
85552 | + case 18446744073709546154LLU: // 99999998oo''''''''''''''' | |
85242 | 85553 | { |
85243 | - state.addr = 18446744073709546170LLU; // 99999998o4''''''''''''''' | |
85554 | + state.addr = 18446744073709546155LLU; // 99999998op''''''''''''''' | |
85244 | 85555 | break; |
85245 | 85556 | } |
85246 | - case 18446744073709546170LLU: // 99999998o4''''''''''''''' | |
85557 | + case 18446744073709546155LLU: // 99999998op''''''''''''''' | |
85247 | 85558 | { |
85248 | 85559 | // ACCUMULATE ARGUMENTS - BEGIN |
85249 | 85560 | { |
@@ -85275,7 +85586,7 @@ | ||
85275 | 85586 | LOCAL_PUSH_MOVE(&heap, 6LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
85276 | 85587 | } |
85277 | 85588 | // ACCUMULATE ARGUMENTS - END |
85278 | - uint64_t return_to = 18446744073709546167LLU; | |
85589 | + uint64_t return_to = 18446744073709546152LLU; | |
85279 | 85590 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 7LLU, 0/*address of closure-in-construction*/, 0)); |
85280 | 85591 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
85281 | 85592 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 7LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -85284,12 +85595,12 @@ | ||
85284 | 85595 | state.addr = 788334703205941248LLU; // pushvar___ |
85285 | 85596 | break; |
85286 | 85597 | } |
85287 | - case 18446744073709546167LLU: // 99999998o1''''''''''''''' | |
85598 | + case 18446744073709546152LLU: // 99999998om''''''''''''''' | |
85288 | 85599 | { |
85289 | - state.addr = 18446744073709546168LLU; // 99999998o2''''''''''''''' | |
85600 | + state.addr = 18446744073709546153LLU; // 99999998on''''''''''''''' | |
85290 | 85601 | break; |
85291 | 85602 | } |
85292 | - case 18446744073709546168LLU: // 99999998o2''''''''''''''' | |
85603 | + case 18446744073709546153LLU: // 99999998on''''''''''''''' | |
85293 | 85604 | { |
85294 | 85605 | // variable u64 initialize goes out of scope |
85295 | 85606 | // emitted destructur for type u64 |
@@ -85299,10 +85610,10 @@ | ||
85299 | 85610 | (void)LOCAL_POP_MOVE(&heap, 24LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference reference_ at 24 |
85300 | 85611 | heap.availilable_size_for_dynamic_objects += 0LLU; |
85301 | 85612 | heap.availilable_size_for_dynamic_objects += 0LLU; |
85302 | - state.addr = 18446744073709546166LLU; // 99999998o0''''''''''''''' | |
85613 | + state.addr = 18446744073709546151LLU; // 99999998ol''''''''''''''' | |
85303 | 85614 | break; |
85304 | 85615 | } |
85305 | - case 18446744073709546171LLU: // 99999998o5''''''''''''''' | |
85616 | + case 18446744073709546156LLU: // 99999998oq''''''''''''''' | |
85306 | 85617 | { |
85307 | 85618 | matchid("=", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 23LLU, 10LLU))); |
85308 | 85619 | // ACCUMULATE ARGUMENTS - BEGIN |
@@ -85311,7 +85622,7 @@ | ||
85311 | 85622 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
85312 | 85623 | } |
85313 | 85624 | // ACCUMULATE ARGUMENTS - END |
85314 | - uint64_t return_to = 18446744073709546164LLU; | |
85625 | + uint64_t return_to = 18446744073709546149LLU; | |
85315 | 85626 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
85316 | 85627 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
85317 | 85628 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -85320,12 +85631,12 @@ | ||
85320 | 85631 | state.addr = 839519719621918720LLU; // skipws____ |
85321 | 85632 | break; |
85322 | 85633 | } |
85323 | - case 18446744073709546164LLU: // 99999998oy''''''''''''''' | |
85634 | + case 18446744073709546149LLU: // 99999998oj''''''''''''''' | |
85324 | 85635 | { |
85325 | - state.addr = 18446744073709546165LLU; // 99999998oz''''''''''''''' | |
85636 | + state.addr = 18446744073709546150LLU; // 99999998ok''''''''''''''' | |
85326 | 85637 | break; |
85327 | 85638 | } |
85328 | - case 18446744073709546165LLU: // 99999998oz''''''''''''''' | |
85639 | + case 18446744073709546150LLU: // 99999998ok''''''''''''''' | |
85329 | 85640 | { |
85330 | 85641 | { |
85331 | 85642 | uint64_t arg = 0; |
@@ -85354,7 +85665,7 @@ | ||
85354 | 85665 | LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
85355 | 85666 | } |
85356 | 85667 | // ACCUMULATE ARGUMENTS - END |
85357 | - uint64_t return_to = 18446744073709546162LLU; | |
85668 | + uint64_t return_to = 18446744073709546147LLU; | |
85358 | 85669 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
85359 | 85670 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
85360 | 85671 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -85363,18 +85674,18 @@ | ||
85363 | 85674 | state.addr = 768289076452424640LLU; // oneresult_ |
85364 | 85675 | break; |
85365 | 85676 | } |
85366 | - case 18446744073709546162LLU: // 99999998ow''''''''''''''' | |
85677 | + case 18446744073709546147LLU: // 99999998oh''''''''''''''' | |
85367 | 85678 | { |
85368 | - state.addr = 18446744073709546163LLU; // 99999998ox''''''''''''''' | |
85679 | + state.addr = 18446744073709546148LLU; // 99999998oi''''''''''''''' | |
85369 | 85680 | break; |
85370 | 85681 | } |
85371 | - case 18446744073709546163LLU: // 99999998ox''''''''''''''' | |
85682 | + case 18446744073709546148LLU: // 99999998oi''''''''''''''' | |
85372 | 85683 | { |
85373 | 85684 | |
85374 | - state.addr = 18446744073709546161LLU; // 99999998ov''''''''''''''' | |
85685 | + state.addr = 18446744073709546146LLU; // 99999998og''''''''''''''' | |
85375 | 85686 | break; |
85376 | 85687 | } |
85377 | - case 18446744073709546161LLU: // 99999998ov''''''''''''''' | |
85688 | + case 18446744073709546146LLU: // 99999998og''''''''''''''' | |
85378 | 85689 | { |
85379 | 85690 | *LOCAL_ACCESS(heap.data, 25LLU, 21LLU) = 123; |
85380 | 85691 | { |
@@ -85382,21 +85693,21 @@ | ||
85382 | 85693 | LOCAL_PUSH_MOVE(&heap, 25, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
85383 | 85694 | } |
85384 | 85695 | *LOCAL_ACCESS(heap.data, 26LLU, 25LLU) = /*sym_______*/*LOCAL_ACCESS(heap.data, 26LLU, 21LLU) == /*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 26LLU, 10LLU)); |
85385 | - state.addr = 18446744073709546158LLU; // 99999998os''''''''''''''' | |
85696 | + state.addr = 18446744073709546143LLU; // 99999998od''''''''''''''' | |
85386 | 85697 | break; |
85387 | 85698 | } |
85388 | - case 18446744073709546158LLU: // 99999998os''''''''''''''' | |
85699 | + case 18446744073709546143LLU: // 99999998od''''''''''''''' | |
85389 | 85700 | { |
85390 | - state.addr = *LOCAL_ACCESS(heap.data, 26LLU, 25LLU) ? 18446744073709546160LLU : 18446744073709546159LLU; | |
85701 | + state.addr = *LOCAL_ACCESS(heap.data, 26LLU, 25LLU) ? 18446744073709546145LLU : 18446744073709546144LLU; | |
85391 | 85702 | (void)LOCAL_POP_MOVE(&heap, 26LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 26 |
85392 | 85703 | break; |
85393 | 85704 | } |
85394 | - case 18446744073709546160LLU: // 99999998ou''''''''''''''' | |
85705 | + case 18446744073709546145LLU: // 99999998of''''''''''''''' | |
85395 | 85706 | { |
85396 | - state.addr = *LOCAL_ACCESS(heap.data, 25LLU, 19LLU) ? 18446744073709546157LLU : 18446744073709546156LLU; | |
85707 | + state.addr = *LOCAL_ACCESS(heap.data, 25LLU, 19LLU) ? 18446744073709546142LLU : 18446744073709546141LLU; | |
85397 | 85708 | break; |
85398 | 85709 | } |
85399 | - case 18446744073709546157LLU: // 99999998or''''''''''''''' | |
85710 | + case 18446744073709546142LLU: // 99999998oc''''''''''''''' | |
85400 | 85711 | { |
85401 | 85712 | { |
85402 | 85713 | uint64_t arg = 0; |
@@ -85408,7 +85719,7 @@ | ||
85408 | 85719 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
85409 | 85720 | } |
85410 | 85721 | // ACCUMULATE ARGUMENTS - END |
85411 | - uint64_t return_to = 18446744073709546154LLU; | |
85722 | + uint64_t return_to = 18446744073709546139LLU; | |
85412 | 85723 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
85413 | 85724 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
85414 | 85725 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -85417,12 +85728,12 @@ | ||
85417 | 85728 | state.addr = 861504796319285248LLU; // typeu64___ |
85418 | 85729 | break; |
85419 | 85730 | } |
85420 | - case 18446744073709546154LLU: // 99999998oo''''''''''''''' | |
85731 | + case 18446744073709546139LLU: // 99999998o$''''''''''''''' | |
85421 | 85732 | { |
85422 | - state.addr = 18446744073709546155LLU; // 99999998op''''''''''''''' | |
85733 | + state.addr = 18446744073709546140LLU; // 99999998oa''''''''''''''' | |
85423 | 85734 | break; |
85424 | 85735 | } |
85425 | - case 18446744073709546155LLU: // 99999998op''''''''''''''' | |
85736 | + case 18446744073709546140LLU: // 99999998oa''''''''''''''' | |
85426 | 85737 | { |
85427 | 85738 | { |
85428 | 85739 | uint64_t arg = 0; |
@@ -85509,7 +85820,7 @@ | ||
85509 | 85820 | LOCAL_PUSH_MOVE(&heap, 11LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
85510 | 85821 | } |
85511 | 85822 | // ACCUMULATE ARGUMENTS - END |
85512 | - uint64_t return_to = 18446744073709546151LLU; | |
85823 | + uint64_t return_to = 18446744073709546136LLU; | |
85513 | 85824 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 12LLU, 0/*address of closure-in-construction*/, 0)); |
85514 | 85825 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
85515 | 85826 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 12LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -85518,12 +85829,12 @@ | ||
85518 | 85829 | state.addr = 604790753280317473LLU; // findvarref |
85519 | 85830 | break; |
85520 | 85831 | } |
85521 | - case 18446744073709546151LLU: // 99999998ol''''''''''''''' | |
85832 | + case 18446744073709546136LLU: // 99999998oX''''''''''''''' | |
85522 | 85833 | { |
85523 | - state.addr = 18446744073709546152LLU; // 99999998om''''''''''''''' | |
85834 | + state.addr = 18446744073709546137LLU; // 99999998oY''''''''''''''' | |
85524 | 85835 | break; |
85525 | 85836 | } |
85526 | - case 18446744073709546152LLU: // 99999998om''''''''''''''' | |
85837 | + case 18446744073709546137LLU: // 99999998oY''''''''''''''' | |
85527 | 85838 | { |
85528 | 85839 | // variable u64 consume___ goes out of scope |
85529 | 85840 | // emitted destructur for type u64 |
@@ -85531,10 +85842,10 @@ | ||
85531 | 85842 | // variable u64 optelem___ goes out of scope |
85532 | 85843 | // emitted destructur for type u64 |
85533 | 85844 | (void)LOCAL_POP_MOVE(&heap, 32LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference optelem___ at 32 |
85534 | - state.addr = 18446744073709546153LLU; // 99999998on''''''''''''''' | |
85845 | + state.addr = 18446744073709546138LLU; // 99999998oZ''''''''''''''' | |
85535 | 85846 | break; |
85536 | 85847 | } |
85537 | - case 18446744073709546153LLU: // 99999998on''''''''''''''' | |
85848 | + case 18446744073709546138LLU: // 99999998oZ''''''''''''''' | |
85538 | 85849 | { |
85539 | 85850 | { |
85540 | 85851 | uint64_t arg = 0; |
@@ -85571,7 +85882,7 @@ | ||
85571 | 85882 | LOCAL_PUSH_MOVE(&heap, 6LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
85572 | 85883 | } |
85573 | 85884 | // ACCUMULATE ARGUMENTS - END |
85574 | - uint64_t return_to = 18446744073709546148LLU; | |
85885 | + uint64_t return_to = 18446744073709546133LLU; | |
85575 | 85886 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 7LLU, 0/*address of closure-in-construction*/, 0)); |
85576 | 85887 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
85577 | 85888 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 7LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -85580,20 +85891,20 @@ | ||
85580 | 85891 | state.addr = 788334703205941248LLU; // pushvar___ |
85581 | 85892 | break; |
85582 | 85893 | } |
85583 | - case 18446744073709546148LLU: // 99999998oi''''''''''''''' | |
85894 | + case 18446744073709546133LLU: // 99999998oU''''''''''''''' | |
85584 | 85895 | { |
85585 | - state.addr = 18446744073709546149LLU; // 99999998oj''''''''''''''' | |
85896 | + state.addr = 18446744073709546134LLU; // 99999998oV''''''''''''''' | |
85586 | 85897 | break; |
85587 | 85898 | } |
85588 | - case 18446744073709546149LLU: // 99999998oj''''''''''''''' | |
85899 | + case 18446744073709546134LLU: // 99999998oV''''''''''''''' | |
85589 | 85900 | { |
85590 | 85901 | // variable u64 initialize goes out of scope |
85591 | 85902 | // emitted destructur for type u64 |
85592 | 85903 | (void)LOCAL_POP_MOVE(&heap, 32LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference initialize at 32 |
85593 | - state.addr = 18446744073709546150LLU; // 99999998ok''''''''''''''' | |
85904 | + state.addr = 18446744073709546135LLU; // 99999998oW''''''''''''''' | |
85594 | 85905 | break; |
85595 | 85906 | } |
85596 | - case 18446744073709546150LLU: // 99999998ok''''''''''''''' | |
85907 | + case 18446744073709546135LLU: // 99999998oW''''''''''''''' | |
85597 | 85908 | { |
85598 | 85909 | // ACCUMULATE ARGUMENTS - BEGIN |
85599 | 85910 | { |
@@ -85621,7 +85932,7 @@ | ||
85621 | 85932 | LOCAL_PUSH_MOVE(&heap, 5LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
85622 | 85933 | } |
85623 | 85934 | // ACCUMULATE ARGUMENTS - END |
85624 | - uint64_t return_to = 18446744073709546146LLU; | |
85935 | + uint64_t return_to = 18446744073709546131LLU; | |
85625 | 85936 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 6LLU, 0/*address of closure-in-construction*/, 0)); |
85626 | 85937 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
85627 | 85938 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 6LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -85630,12 +85941,12 @@ | ||
85630 | 85941 | state.addr = 533581901922699840LLU; // blockopen_ |
85631 | 85942 | break; |
85632 | 85943 | } |
85633 | - case 18446744073709546146LLU: // 99999998og''''''''''''''' | |
85944 | + case 18446744073709546131LLU: // 99999998oS''''''''''''''' | |
85634 | 85945 | { |
85635 | - state.addr = 18446744073709546147LLU; // 99999998oh''''''''''''''' | |
85946 | + state.addr = 18446744073709546132LLU; // 99999998oT''''''''''''''' | |
85636 | 85947 | break; |
85637 | 85948 | } |
85638 | - case 18446744073709546147LLU: // 99999998oh''''''''''''''' | |
85949 | + case 18446744073709546132LLU: // 99999998oT''''''''''''''' | |
85639 | 85950 | { |
85640 | 85951 | swap(&/*results___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 31LLU, 15LLU)), &/*newresults*/*LOCAL_ACCESS(heap.data, 31LLU, 24LLU)); |
85641 | 85952 | // ACCUMULATE ARGUMENTS - BEGIN |
@@ -85668,7 +85979,7 @@ | ||
85668 | 85979 | LOCAL_PUSH_MOVE(&heap, 6LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
85669 | 85980 | } |
85670 | 85981 | // ACCUMULATE ARGUMENTS - END |
85671 | - uint64_t return_to = 18446744073709546143LLU; | |
85982 | + uint64_t return_to = 18446744073709546128LLU; | |
85672 | 85983 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 7LLU, 0/*address of closure-in-construction*/, 0)); |
85673 | 85984 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
85674 | 85985 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 7LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -85677,17 +85988,17 @@ | ||
85677 | 85988 | state.addr = 788334703340351488LLU; // pushvirt__ |
85678 | 85989 | break; |
85679 | 85990 | } |
85680 | - case 18446744073709546143LLU: // 99999998od''''''''''''''' | |
85991 | + case 18446744073709546128LLU: // 99999998oP''''''''''''''' | |
85681 | 85992 | { |
85682 | - state.addr = 18446744073709546144LLU; // 99999998oe''''''''''''''' | |
85993 | + state.addr = 18446744073709546129LLU; // 99999998oQ''''''''''''''' | |
85683 | 85994 | break; |
85684 | 85995 | } |
85685 | - case 18446744073709546144LLU: // 99999998oe''''''''''''''' | |
85996 | + case 18446744073709546129LLU: // 99999998oQ''''''''''''''' | |
85686 | 85997 | { |
85687 | - state.addr = 18446744073709546145LLU; // 99999998of''''''''''''''' | |
85998 | + state.addr = 18446744073709546130LLU; // 99999998oR''''''''''''''' | |
85688 | 85999 | break; |
85689 | 86000 | } |
85690 | - case 18446744073709546145LLU: // 99999998of''''''''''''''' | |
86001 | + case 18446744073709546130LLU: // 99999998oR''''''''''''''' | |
85691 | 86002 | { |
85692 | 86003 | // variable u64 initialize goes out of scope |
85693 | 86004 | // emitted destructur for type u64 |
@@ -85712,7 +86023,7 @@ | ||
85712 | 86023 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
85713 | 86024 | } |
85714 | 86025 | // ACCUMULATE ARGUMENTS - END |
85715 | - uint64_t return_to = 18446744073709546142LLU; | |
86026 | + uint64_t return_to = 18446744073709546127LLU; | |
85716 | 86027 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
85717 | 86028 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
85718 | 86029 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -85721,15 +86032,15 @@ | ||
85721 | 86032 | state.addr = 18446744073709551534LLU; // 999999998s''''''''''''''' |
85722 | 86033 | break; |
85723 | 86034 | } |
85724 | - case 18446744073709546142LLU: // 99999998oc''''''''''''''' | |
86035 | + case 18446744073709546127LLU: // 99999998oO''''''''''''''' | |
85725 | 86036 | { |
85726 | 86037 | (void)LOCAL_POP_MOVE(&heap, 26LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type______ at 26 |
85727 | 86038 | heap.availilable_size_for_dynamic_objects += 0LLU; |
85728 | 86039 | heap.availilable_size_for_dynamic_objects += 0LLU; |
85729 | - state.addr = 18446744073709546141LLU; // 99999998ob''''''''''''''' | |
86040 | + state.addr = 18446744073709546126LLU; // 99999998oN''''''''''''''' | |
85730 | 86041 | break; |
85731 | 86042 | } |
85732 | - case 18446744073709546156LLU: // 99999998oq''''''''''''''' | |
86043 | + case 18446744073709546141LLU: // 99999998ob''''''''''''''' | |
85733 | 86044 | { |
85734 | 86045 | { |
85735 | 86046 | uint64_t arg = 0; |
@@ -85766,7 +86077,7 @@ | ||
85766 | 86077 | LOCAL_PUSH_MOVE(&heap, 6LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
85767 | 86078 | } |
85768 | 86079 | // ACCUMULATE ARGUMENTS - END |
85769 | - uint64_t return_to = 18446744073709546138LLU; | |
86080 | + uint64_t return_to = 18446744073709546123LLU; | |
85770 | 86081 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 7LLU, 0/*address of closure-in-construction*/, 0)); |
85771 | 86082 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
85772 | 86083 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 7LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -85775,20 +86086,20 @@ | ||
85775 | 86086 | state.addr = 788334703205941248LLU; // pushvar___ |
85776 | 86087 | break; |
85777 | 86088 | } |
85778 | - case 18446744073709546138LLU: // 99999998oZ''''''''''''''' | |
86089 | + case 18446744073709546123LLU: // 99999998oK''''''''''''''' | |
85779 | 86090 | { |
85780 | - state.addr = 18446744073709546139LLU; // 99999998o$''''''''''''''' | |
86091 | + state.addr = 18446744073709546124LLU; // 99999998oL''''''''''''''' | |
85781 | 86092 | break; |
85782 | 86093 | } |
85783 | - case 18446744073709546139LLU: // 99999998o$''''''''''''''' | |
86094 | + case 18446744073709546124LLU: // 99999998oL''''''''''''''' | |
85784 | 86095 | { |
85785 | 86096 | // variable u64 initialize goes out of scope |
85786 | 86097 | // emitted destructur for type u64 |
85787 | 86098 | (void)LOCAL_POP_MOVE(&heap, 26LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference initialize at 26 |
85788 | - state.addr = 18446744073709546140LLU; // 99999998oa''''''''''''''' | |
86099 | + state.addr = 18446744073709546125LLU; // 99999998oM''''''''''''''' | |
85789 | 86100 | break; |
85790 | 86101 | } |
85791 | - case 18446744073709546140LLU: // 99999998oa''''''''''''''' | |
86102 | + case 18446744073709546125LLU: // 99999998oM''''''''''''''' | |
85792 | 86103 | { |
85793 | 86104 | // ACCUMULATE ARGUMENTS - BEGIN |
85794 | 86105 | { |
@@ -85816,7 +86127,7 @@ | ||
85816 | 86127 | LOCAL_PUSH_MOVE(&heap, 5LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
85817 | 86128 | } |
85818 | 86129 | // ACCUMULATE ARGUMENTS - END |
85819 | - uint64_t return_to = 18446744073709546136LLU; | |
86130 | + uint64_t return_to = 18446744073709546121LLU; | |
85820 | 86131 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 6LLU, 0/*address of closure-in-construction*/, 0)); |
85821 | 86132 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
85822 | 86133 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 6LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -85825,25 +86136,25 @@ | ||
85825 | 86136 | state.addr = 533581901922699840LLU; // blockopen_ |
85826 | 86137 | break; |
85827 | 86138 | } |
85828 | - case 18446744073709546136LLU: // 99999998oX''''''''''''''' | |
86139 | + case 18446744073709546121LLU: // 99999998oI''''''''''''''' | |
85829 | 86140 | { |
85830 | - state.addr = 18446744073709546137LLU; // 99999998oY''''''''''''''' | |
86141 | + state.addr = 18446744073709546122LLU; // 99999998oJ''''''''''''''' | |
85831 | 86142 | break; |
85832 | 86143 | } |
85833 | - case 18446744073709546137LLU: // 99999998oY''''''''''''''' | |
86144 | + case 18446744073709546122LLU: // 99999998oJ''''''''''''''' | |
85834 | 86145 | { |
85835 | 86146 | swap(&/*results___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 25LLU, 15LLU)), &/*newresults*/*LOCAL_ACCESS(heap.data, 25LLU, 24LLU)); |
85836 | - state.addr = 18446744073709546141LLU; // 99999998ob''''''''''''''' | |
86147 | + state.addr = 18446744073709546126LLU; // 99999998oN''''''''''''''' | |
85837 | 86148 | break; |
85838 | 86149 | } |
85839 | - case 18446744073709546141LLU: // 99999998ob''''''''''''''' | |
86150 | + case 18446744073709546126LLU: // 99999998oN''''''''''''''' | |
85840 | 86151 | { |
85841 | 86152 | heap.availilable_size_for_dynamic_objects += 0LLU; |
85842 | 86153 | heap.availilable_size_for_dynamic_objects += 0LLU; |
85843 | - state.addr = 18446744073709546135LLU; // 99999998oW''''''''''''''' | |
86154 | + state.addr = 18446744073709546120LLU; // 99999998oH''''''''''''''' | |
85844 | 86155 | break; |
85845 | 86156 | } |
85846 | - case 18446744073709546159LLU: // 99999998ot''''''''''''''' | |
86157 | + case 18446744073709546144LLU: // 99999998oe''''''''''''''' | |
85847 | 86158 | { |
85848 | 86159 | // ACCUMULATE ARGUMENTS - BEGIN |
85849 | 86160 | { |
@@ -85915,7 +86226,7 @@ | ||
85915 | 86226 | LOCAL_PUSH_MOVE(&heap, 16LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
85916 | 86227 | } |
85917 | 86228 | // ACCUMULATE ARGUMENTS - END |
85918 | - uint64_t return_to = 18446744073709546133LLU; | |
86229 | + uint64_t return_to = 18446744073709546118LLU; | |
85919 | 86230 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 17LLU, 0/*address of closure-in-construction*/, 0)); |
85920 | 86231 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
85921 | 86232 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 17LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -85924,12 +86235,12 @@ | ||
85924 | 86235 | state.addr = 787472338545441824LLU; // procrvalue |
85925 | 86236 | break; |
85926 | 86237 | } |
85927 | - case 18446744073709546133LLU: // 99999998oU''''''''''''''' | |
86238 | + case 18446744073709546118LLU: // 99999998oF''''''''''''''' | |
85928 | 86239 | { |
85929 | - state.addr = 18446744073709546134LLU; // 99999998oV''''''''''''''' | |
86240 | + state.addr = 18446744073709546119LLU; // 99999998oG''''''''''''''' | |
85930 | 86241 | break; |
85931 | 86242 | } |
85932 | - case 18446744073709546134LLU: // 99999998oV''''''''''''''' | |
86243 | + case 18446744073709546119LLU: // 99999998oG''''''''''''''' | |
85933 | 86244 | { |
85934 | 86245 | { |
85935 | 86246 | uint64_t arg = 0; |
@@ -85966,7 +86277,7 @@ | ||
85966 | 86277 | LOCAL_PUSH_MOVE(&heap, 6LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
85967 | 86278 | } |
85968 | 86279 | // ACCUMULATE ARGUMENTS - END |
85969 | - uint64_t return_to = 18446744073709546130LLU; | |
86280 | + uint64_t return_to = 18446744073709546115LLU; | |
85970 | 86281 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 7LLU, 0/*address of closure-in-construction*/, 0)); |
85971 | 86282 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
85972 | 86283 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 7LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -85975,36 +86286,36 @@ | ||
85975 | 86286 | state.addr = 788334703205941248LLU; // pushvar___ |
85976 | 86287 | break; |
85977 | 86288 | } |
85978 | - case 18446744073709546130LLU: // 99999998oR''''''''''''''' | |
86289 | + case 18446744073709546115LLU: // 99999998oC''''''''''''''' | |
85979 | 86290 | { |
85980 | - state.addr = 18446744073709546131LLU; // 99999998oS''''''''''''''' | |
86291 | + state.addr = 18446744073709546116LLU; // 99999998oD''''''''''''''' | |
85981 | 86292 | break; |
85982 | 86293 | } |
85983 | - case 18446744073709546131LLU: // 99999998oS''''''''''''''' | |
86294 | + case 18446744073709546116LLU: // 99999998oD''''''''''''''' | |
85984 | 86295 | { |
85985 | 86296 | // variable u64 initialize goes out of scope |
85986 | 86297 | // emitted destructur for type u64 |
85987 | 86298 | (void)LOCAL_POP_MOVE(&heap, 26LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference initialize at 26 |
85988 | - state.addr = 18446744073709546132LLU; // 99999998oT''''''''''''''' | |
86299 | + state.addr = 18446744073709546117LLU; // 99999998oE''''''''''''''' | |
85989 | 86300 | break; |
85990 | 86301 | } |
85991 | - case 18446744073709546132LLU: // 99999998oT''''''''''''''' | |
86302 | + case 18446744073709546117LLU: // 99999998oE''''''''''''''' | |
85992 | 86303 | { |
85993 | - state.addr = 18446744073709546135LLU; // 99999998oW''''''''''''''' | |
86304 | + state.addr = 18446744073709546120LLU; // 99999998oH''''''''''''''' | |
85994 | 86305 | break; |
85995 | 86306 | } |
85996 | - case 18446744073709546135LLU: // 99999998oW''''''''''''''' | |
86307 | + case 18446744073709546120LLU: // 99999998oH''''''''''''''' | |
85997 | 86308 | { |
85998 | 86309 | // variable list<resdest___> newresults goes out of scope |
85999 | 86310 | // emitted destructur for type list<resdest___> |
86000 | - state.addr = 18446744073709546128LLU; // 99999998oP''''''''''''''' | |
86311 | + state.addr = 18446744073709546113LLU; // 99999998oA''''''''''''''' | |
86001 | 86312 | break; |
86002 | 86313 | } |
86003 | - case 18446744073709546128LLU: // 99999998oP''''''''''''''' | |
86314 | + case 18446744073709546113LLU: // 99999998oA''''''''''''''' | |
86004 | 86315 | { |
86005 | 86316 | if(!*LOCAL_ACCESS(heap.data, 25LLU, 24LLU)/*list*/) |
86006 | 86317 | { |
86007 | - state.addr = 18446744073709546129LLU; // 99999998oQ''''''''''''''' | |
86318 | + state.addr = 18446744073709546114LLU; // 99999998oB''''''''''''''' | |
86008 | 86319 | break; |
86009 | 86320 | } |
86010 | 86321 | // temporary list-element |
@@ -86018,7 +86329,7 @@ | ||
86018 | 86329 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
86019 | 86330 | } |
86020 | 86331 | // ACCUMULATE ARGUMENTS - END |
86021 | - uint64_t return_to = 18446744073709546127LLU; | |
86332 | + uint64_t return_to = 18446744073709546112LLU; | |
86022 | 86333 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
86023 | 86334 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
86024 | 86335 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -86027,23 +86338,23 @@ | ||
86027 | 86338 | state.addr = 18446744073709551475LLU; // 999999997x''''''''''''''' |
86028 | 86339 | break; |
86029 | 86340 | } |
86030 | - case 18446744073709546127LLU: // 99999998oO''''''''''''''' | |
86341 | + case 18446744073709546112LLU: // 99999998o_''''''''''''''' | |
86031 | 86342 | { |
86032 | 86343 | // RELEASE temporary destructor-variable |
86033 | 86344 | (void)LOCAL_POP_MOVE(&heap, 26LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 26 |
86034 | - state.addr = 18446744073709546128LLU; // 99999998oP''''''''''''''' | |
86345 | + state.addr = 18446744073709546113LLU; // 99999998oA''''''''''''''' | |
86035 | 86346 | break; |
86036 | 86347 | } |
86037 | - case 18446744073709546129LLU: // 99999998oQ''''''''''''''' | |
86348 | + case 18446744073709546114LLU: // 99999998oB''''''''''''''' | |
86038 | 86349 | { |
86039 | 86350 | (void)LOCAL_POP_MOVE(&heap, 25LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference newresults at 25 |
86040 | 86351 | // variable u64 reference_ goes out of scope |
86041 | 86352 | // emitted destructur for type u64 |
86042 | 86353 | (void)LOCAL_POP_MOVE(&heap, 24LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference reference_ at 24 |
86043 | - state.addr = 18446744073709546166LLU; // 99999998o0''''''''''''''' | |
86354 | + state.addr = 18446744073709546151LLU; // 99999998ol''''''''''''''' | |
86044 | 86355 | break; |
86045 | 86356 | } |
86046 | - case 18446744073709546166LLU: // 99999998o0''''''''''''''' | |
86357 | + case 18446744073709546151LLU: // 99999998ol''''''''''''''' | |
86047 | 86358 | { |
86048 | 86359 | // variable u64 match_____ goes out of scope |
86049 | 86360 | // emitted destructur for type u64 |
@@ -86054,10 +86365,10 @@ | ||
86054 | 86365 | // variable u64 varidx____ goes out of scope |
86055 | 86366 | // emitted destructur for type u64 |
86056 | 86367 | (void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference varidx____ at 21 |
86057 | - state.addr = 18446744073709546181LLU; // 99999998pE''''''''''''''' | |
86368 | + state.addr = 18446744073709546166LLU; // 99999998o0''''''''''''''' | |
86058 | 86369 | break; |
86059 | 86370 | } |
86060 | - case 18446744073709546181LLU: // 99999998pE''''''''''''''' | |
86371 | + case 18446744073709546166LLU: // 99999998o0''''''''''''''' | |
86061 | 86372 | { |
86062 | 86373 | // variable u64 redef_____ goes out of scope |
86063 | 86374 | // emitted destructur for type u64 |
@@ -86070,7 +86381,7 @@ | ||
86070 | 86381 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
86071 | 86382 | } |
86072 | 86383 | // ACCUMULATE ARGUMENTS - END |
86073 | - uint64_t return_to = 18446744073709546126LLU; | |
86384 | + uint64_t return_to = 18446744073709546111LLU; | |
86074 | 86385 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
86075 | 86386 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
86076 | 86387 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -86079,7 +86390,7 @@ | ||
86079 | 86390 | state.addr = 18446744073709551534LLU; // 999999998s''''''''''''''' |
86080 | 86391 | break; |
86081 | 86392 | } |
86082 | - case 18446744073709546126LLU: // 99999998oN''''''''''''''' | |
86393 | + case 18446744073709546111LLU: // 99999998n9''''''''''''''' | |
86083 | 86394 | { |
86084 | 86395 | (void)LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference typedst___ at 19 |
86085 | 86396 | // variable u64 mutable___ goes out of scope |
@@ -86136,28 +86447,28 @@ | ||
86136 | 86447 | } |
86137 | 86448 | *LOCAL_ACCESS(heap.data, 15LLU, 14LLU) = 0; |
86138 | 86449 | |
86139 | - state.addr = 18446744073709546125LLU; // 99999998oM''''''''''''''' | |
86450 | + state.addr = 18446744073709546110LLU; // 99999998n8''''''''''''''' | |
86140 | 86451 | break; |
86141 | 86452 | } |
86142 | - case 18446744073709546125LLU: // 99999998oM''''''''''''''' | |
86453 | + case 18446744073709546110LLU: // 99999998n8''''''''''''''' | |
86143 | 86454 | { |
86144 | 86455 | *LOCAL_ACCESS(heap.data, 15LLU, 14LLU) = 876383386118840320; |
86145 | 86456 | |
86146 | - state.addr = 18446744073709546124LLU; // 99999998oL''''''''''''''' | |
86457 | + state.addr = 18446744073709546109LLU; // 99999998n7''''''''''''''' | |
86147 | 86458 | break; |
86148 | 86459 | } |
86149 | - case 18446744073709546124LLU: // 99999998oL''''''''''''''' | |
86460 | + case 18446744073709546109LLU: // 99999998n7''''''''''''''' | |
86150 | 86461 | { |
86151 | 86462 | *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) = /*sym_______*/*LOCAL_ACCESS(heap.data, 15LLU, 14LLU) == /*callee_id_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 6LLU)); |
86152 | - state.addr = 18446744073709546123LLU; // 99999998oK''''''''''''''' | |
86463 | + state.addr = 18446744073709546108LLU; // 99999998n6''''''''''''''' | |
86153 | 86464 | break; |
86154 | 86465 | } |
86155 | - case 18446744073709546123LLU: // 99999998oK''''''''''''''' | |
86466 | + case 18446744073709546108LLU: // 99999998n6''''''''''''''' | |
86156 | 86467 | { |
86157 | - state.addr = *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709546122LLU : 18446744073709546121LLU; | |
86468 | + state.addr = *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709546107LLU : 18446744073709546106LLU; | |
86158 | 86469 | break; |
86159 | 86470 | } |
86160 | - case 18446744073709546122LLU: // 99999998oJ''''''''''''''' | |
86471 | + case 18446744073709546107LLU: // 99999998n5''''''''''''''' | |
86161 | 86472 | { |
86162 | 86473 | // ACCUMULATE ARGUMENTS - BEGIN |
86163 | 86474 | { |
@@ -86165,7 +86476,7 @@ | ||
86165 | 86476 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
86166 | 86477 | } |
86167 | 86478 | // ACCUMULATE ARGUMENTS - END |
86168 | - uint64_t return_to = 18446744073709546119LLU; | |
86479 | + uint64_t return_to = 18446744073709546104LLU; | |
86169 | 86480 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
86170 | 86481 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
86171 | 86482 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -86174,12 +86485,12 @@ | ||
86174 | 86485 | state.addr = 839519719621918720LLU; // skipws____ |
86175 | 86486 | break; |
86176 | 86487 | } |
86177 | - case 18446744073709546119LLU: // 99999998oG''''''''''''''' | |
86488 | + case 18446744073709546104LLU: // 99999998n2''''''''''''''' | |
86178 | 86489 | { |
86179 | - state.addr = 18446744073709546120LLU; // 99999998oH''''''''''''''' | |
86490 | + state.addr = 18446744073709546105LLU; // 99999998n3''''''''''''''' | |
86180 | 86491 | break; |
86181 | 86492 | } |
86182 | - case 18446744073709546120LLU: // 99999998oH''''''''''''''' | |
86493 | + case 18446744073709546105LLU: // 99999998n3''''''''''''''' | |
86183 | 86494 | { |
86184 | 86495 | matchid("(", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 7LLU))); |
86185 | 86496 | // ACCUMULATE ARGUMENTS - BEGIN |
@@ -86188,7 +86499,7 @@ | ||
86188 | 86499 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
86189 | 86500 | } |
86190 | 86501 | // ACCUMULATE ARGUMENTS - END |
86191 | - uint64_t return_to = 18446744073709546117LLU; | |
86502 | + uint64_t return_to = 18446744073709546102LLU; | |
86192 | 86503 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
86193 | 86504 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
86194 | 86505 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -86197,12 +86508,12 @@ | ||
86197 | 86508 | state.addr = 839519719621918720LLU; // skipws____ |
86198 | 86509 | break; |
86199 | 86510 | } |
86200 | - case 18446744073709546117LLU: // 99999998oE''''''''''''''' | |
86511 | + case 18446744073709546102LLU: // 99999998n0''''''''''''''' | |
86201 | 86512 | { |
86202 | - state.addr = 18446744073709546118LLU; // 99999998oF''''''''''''''' | |
86513 | + state.addr = 18446744073709546103LLU; // 99999998n1''''''''''''''' | |
86203 | 86514 | break; |
86204 | 86515 | } |
86205 | - case 18446744073709546118LLU: // 99999998oF''''''''''''''' | |
86516 | + case 18446744073709546103LLU: // 99999998n1''''''''''''''' | |
86206 | 86517 | { |
86207 | 86518 | ungetc((int)/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 7LLU)), stdin); |
86208 | 86519 | if(')' != (char)getchar()) |
@@ -86213,34 +86524,34 @@ | ||
86213 | 86524 | fprintf(stdout, "%s", "\n ungetc(0, stdin);"); |
86214 | 86525 | heap.availilable_size_for_dynamic_objects += 0LLU; |
86215 | 86526 | heap.availilable_size_for_dynamic_objects += 0LLU; |
86216 | - state.addr = 18446744073709546116LLU; // 99999998oD''''''''''''''' | |
86527 | + state.addr = 18446744073709546101LLU; // 99999998nz''''''''''''''' | |
86217 | 86528 | break; |
86218 | 86529 | } |
86219 | - case 18446744073709546121LLU: // 99999998oI''''''''''''''' | |
86530 | + case 18446744073709546106LLU: // 99999998n4''''''''''''''' | |
86220 | 86531 | { |
86221 | 86532 | |
86222 | - state.addr = 18446744073709546115LLU; // 99999998oC''''''''''''''' | |
86533 | + state.addr = 18446744073709546100LLU; // 99999998ny''''''''''''''' | |
86223 | 86534 | break; |
86224 | 86535 | } |
86225 | - case 18446744073709546115LLU: // 99999998oC''''''''''''''' | |
86536 | + case 18446744073709546100LLU: // 99999998ny''''''''''''''' | |
86226 | 86537 | { |
86227 | 86538 | *LOCAL_ACCESS(heap.data, 15LLU, 14LLU) = 605666980531466240; |
86228 | 86539 | |
86229 | - state.addr = 18446744073709546114LLU; // 99999998oB''''''''''''''' | |
86540 | + state.addr = 18446744073709546099LLU; // 99999998nx''''''''''''''' | |
86230 | 86541 | break; |
86231 | 86542 | } |
86232 | - case 18446744073709546114LLU: // 99999998oB''''''''''''''' | |
86543 | + case 18446744073709546099LLU: // 99999998nx''''''''''''''' | |
86233 | 86544 | { |
86234 | 86545 | *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) = /*sym_______*/*LOCAL_ACCESS(heap.data, 15LLU, 14LLU) == /*callee_id_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 6LLU)); |
86235 | - state.addr = 18446744073709546113LLU; // 99999998oA''''''''''''''' | |
86546 | + state.addr = 18446744073709546098LLU; // 99999998nw''''''''''''''' | |
86236 | 86547 | break; |
86237 | 86548 | } |
86238 | - case 18446744073709546113LLU: // 99999998oA''''''''''''''' | |
86549 | + case 18446744073709546098LLU: // 99999998nw''''''''''''''' | |
86239 | 86550 | { |
86240 | - state.addr = *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709546112LLU : 18446744073709546111LLU; | |
86551 | + state.addr = *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709546097LLU : 18446744073709546096LLU; | |
86241 | 86552 | break; |
86242 | 86553 | } |
86243 | - case 18446744073709546112LLU: // 99999998o_''''''''''''''' | |
86554 | + case 18446744073709546097LLU: // 99999998nv''''''''''''''' | |
86244 | 86555 | { |
86245 | 86556 | // ACCUMULATE ARGUMENTS - BEGIN |
86246 | 86557 | { |
@@ -86248,7 +86559,7 @@ | ||
86248 | 86559 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
86249 | 86560 | } |
86250 | 86561 | // ACCUMULATE ARGUMENTS - END |
86251 | - uint64_t return_to = 18446744073709546109LLU; | |
86562 | + uint64_t return_to = 18446744073709546094LLU; | |
86252 | 86563 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
86253 | 86564 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
86254 | 86565 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -86257,12 +86568,12 @@ | ||
86257 | 86568 | state.addr = 839519719621918720LLU; // skipws____ |
86258 | 86569 | break; |
86259 | 86570 | } |
86260 | - case 18446744073709546109LLU: // 99999998n7''''''''''''''' | |
86571 | + case 18446744073709546094LLU: // 99999998ns''''''''''''''' | |
86261 | 86572 | { |
86262 | - state.addr = 18446744073709546110LLU; // 99999998n8''''''''''''''' | |
86573 | + state.addr = 18446744073709546095LLU; // 99999998nt''''''''''''''' | |
86263 | 86574 | break; |
86264 | 86575 | } |
86265 | - case 18446744073709546110LLU: // 99999998n8''''''''''''''' | |
86576 | + case 18446744073709546095LLU: // 99999998nt''''''''''''''' | |
86266 | 86577 | { |
86267 | 86578 | matchid("(", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 7LLU))); |
86268 | 86579 | // ACCUMULATE ARGUMENTS - BEGIN |
@@ -86271,7 +86582,7 @@ | ||
86271 | 86582 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
86272 | 86583 | } |
86273 | 86584 | // ACCUMULATE ARGUMENTS - END |
86274 | - uint64_t return_to = 18446744073709546107LLU; | |
86585 | + uint64_t return_to = 18446744073709546092LLU; | |
86275 | 86586 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
86276 | 86587 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
86277 | 86588 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -86280,12 +86591,12 @@ | ||
86280 | 86591 | state.addr = 839519719621918720LLU; // skipws____ |
86281 | 86592 | break; |
86282 | 86593 | } |
86283 | - case 18446744073709546107LLU: // 99999998n5''''''''''''''' | |
86594 | + case 18446744073709546092LLU: // 99999998nq''''''''''''''' | |
86284 | 86595 | { |
86285 | - state.addr = 18446744073709546108LLU; // 99999998n6''''''''''''''' | |
86596 | + state.addr = 18446744073709546093LLU; // 99999998nr''''''''''''''' | |
86286 | 86597 | break; |
86287 | 86598 | } |
86288 | - case 18446744073709546108LLU: // 99999998n6''''''''''''''' | |
86599 | + case 18446744073709546093LLU: // 99999998nr''''''''''''''' | |
86289 | 86600 | { |
86290 | 86601 | ungetc((int)/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 7LLU)), stdin); |
86291 | 86602 | if(')' != (char)getchar()) |
@@ -86296,20 +86607,20 @@ | ||
86296 | 86607 | fprintf(stdout, "%s", "\n fflush(stdout);"); |
86297 | 86608 | heap.availilable_size_for_dynamic_objects += 0LLU; |
86298 | 86609 | heap.availilable_size_for_dynamic_objects += 0LLU; |
86299 | - state.addr = 18446744073709546106LLU; // 99999998n4''''''''''''''' | |
86610 | + state.addr = 18446744073709546091LLU; // 99999998np''''''''''''''' | |
86300 | 86611 | break; |
86301 | 86612 | } |
86302 | - case 18446744073709546111LLU: // 99999998n9''''''''''''''' | |
86613 | + case 18446744073709546096LLU: // 99999998nu''''''''''''''' | |
86303 | 86614 | { |
86304 | - state.addr = 18446744073709546106LLU; // 99999998n4''''''''''''''' | |
86615 | + state.addr = 18446744073709546091LLU; // 99999998np''''''''''''''' | |
86305 | 86616 | break; |
86306 | 86617 | } |
86307 | - case 18446744073709546106LLU: // 99999998n4''''''''''''''' | |
86618 | + case 18446744073709546091LLU: // 99999998np''''''''''''''' | |
86308 | 86619 | { |
86309 | - state.addr = 18446744073709546116LLU; // 99999998oD''''''''''''''' | |
86620 | + state.addr = 18446744073709546101LLU; // 99999998nz''''''''''''''' | |
86310 | 86621 | break; |
86311 | 86622 | } |
86312 | - case 18446744073709546116LLU: // 99999998oD''''''''''''''' | |
86623 | + case 18446744073709546101LLU: // 99999998nz''''''''''''''' | |
86313 | 86624 | { |
86314 | 86625 | // variable u64 sym_______ goes out of scope |
86315 | 86626 | // emitted destructur for type u64 |
@@ -86358,28 +86669,28 @@ | ||
86358 | 86669 | } |
86359 | 86670 | *LOCAL_ACCESS(heap.data, 15LLU, 14LLU) = 0; |
86360 | 86671 | |
86361 | - state.addr = 18446744073709546105LLU; // 99999998n3''''''''''''''' | |
86672 | + state.addr = 18446744073709546090LLU; // 99999998no''''''''''''''' | |
86362 | 86673 | break; |
86363 | 86674 | } |
86364 | - case 18446744073709546105LLU: // 99999998n3''''''''''''''' | |
86675 | + case 18446744073709546090LLU: // 99999998no''''''''''''''' | |
86365 | 86676 | { |
86366 | 86677 | *LOCAL_ACCESS(heap.data, 15LLU, 14LLU) = 819847183514351405; |
86367 | 86678 | |
86368 | - state.addr = 18446744073709546104LLU; // 99999998n2''''''''''''''' | |
86679 | + state.addr = 18446744073709546089LLU; // 99999998nn''''''''''''''' | |
86369 | 86680 | break; |
86370 | 86681 | } |
86371 | - case 18446744073709546104LLU: // 99999998n2''''''''''''''' | |
86682 | + case 18446744073709546089LLU: // 99999998nn''''''''''''''' | |
86372 | 86683 | { |
86373 | 86684 | *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) = /*sym_______*/*LOCAL_ACCESS(heap.data, 15LLU, 14LLU) == /*callee_id_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 6LLU)); |
86374 | - state.addr = 18446744073709546103LLU; // 99999998n1''''''''''''''' | |
86685 | + state.addr = 18446744073709546088LLU; // 99999998nm''''''''''''''' | |
86375 | 86686 | break; |
86376 | 86687 | } |
86377 | - case 18446744073709546103LLU: // 99999998n1''''''''''''''' | |
86688 | + case 18446744073709546088LLU: // 99999998nm''''''''''''''' | |
86378 | 86689 | { |
86379 | - state.addr = *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709546102LLU : 18446744073709546101LLU; | |
86690 | + state.addr = *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709546087LLU : 18446744073709546086LLU; | |
86380 | 86691 | break; |
86381 | 86692 | } |
86382 | - case 18446744073709546102LLU: // 99999998n0''''''''''''''' | |
86693 | + case 18446744073709546087LLU: // 99999998nl''''''''''''''' | |
86383 | 86694 | { |
86384 | 86695 | { |
86385 | 86696 | uint64_t arg = 0; |
@@ -86401,7 +86712,7 @@ | ||
86401 | 86712 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
86402 | 86713 | } |
86403 | 86714 | // ACCUMULATE ARGUMENTS - END |
86404 | - uint64_t return_to = 18446744073709546099LLU; | |
86715 | + uint64_t return_to = 18446744073709546084LLU; | |
86405 | 86716 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
86406 | 86717 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
86407 | 86718 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -86410,12 +86721,12 @@ | ||
86410 | 86721 | state.addr = 861504796319285248LLU; // typeu64___ |
86411 | 86722 | break; |
86412 | 86723 | } |
86413 | - case 18446744073709546099LLU: // 99999998nx''''''''''''''' | |
86724 | + case 18446744073709546084LLU: // 99999998ni''''''''''''''' | |
86414 | 86725 | { |
86415 | - state.addr = 18446744073709546100LLU; // 99999998ny''''''''''''''' | |
86726 | + state.addr = 18446744073709546085LLU; // 99999998nj''''''''''''''' | |
86416 | 86727 | break; |
86417 | 86728 | } |
86418 | - case 18446744073709546100LLU: // 99999998ny''''''''''''''' | |
86729 | + case 18446744073709546085LLU: // 99999998nj''''''''''''''' | |
86419 | 86730 | { |
86420 | 86731 | // ACCUMULATE ARGUMENTS - BEGIN |
86421 | 86732 | { |
@@ -86423,7 +86734,7 @@ | ||
86423 | 86734 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
86424 | 86735 | } |
86425 | 86736 | // ACCUMULATE ARGUMENTS - END |
86426 | - uint64_t return_to = 18446744073709546097LLU; | |
86737 | + uint64_t return_to = 18446744073709546082LLU; | |
86427 | 86738 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
86428 | 86739 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
86429 | 86740 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -86432,12 +86743,12 @@ | ||
86432 | 86743 | state.addr = 839519719621918720LLU; // skipws____ |
86433 | 86744 | break; |
86434 | 86745 | } |
86435 | - case 18446744073709546097LLU: // 99999998nv''''''''''''''' | |
86746 | + case 18446744073709546082LLU: // 99999998ng''''''''''''''' | |
86436 | 86747 | { |
86437 | - state.addr = 18446744073709546098LLU; // 99999998nw''''''''''''''' | |
86748 | + state.addr = 18446744073709546083LLU; // 99999998nh''''''''''''''' | |
86438 | 86749 | break; |
86439 | 86750 | } |
86440 | - case 18446744073709546098LLU: // 99999998nw''''''''''''''' | |
86751 | + case 18446744073709546083LLU: // 99999998nh''''''''''''''' | |
86441 | 86752 | { |
86442 | 86753 | matchid("(", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 18LLU, 7LLU))); |
86443 | 86754 | fprintf(stdout, "%s", "\n putc((char)"); |
@@ -86452,7 +86763,7 @@ | ||
86452 | 86763 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
86453 | 86764 | } |
86454 | 86765 | // ACCUMULATE ARGUMENTS - END |
86455 | - uint64_t return_to = 18446744073709546094LLU; | |
86766 | + uint64_t return_to = 18446744073709546079LLU; | |
86456 | 86767 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
86457 | 86768 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
86458 | 86769 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -86461,24 +86772,24 @@ | ||
86461 | 86772 | state.addr = 839519719621918720LLU; // skipws____ |
86462 | 86773 | break; |
86463 | 86774 | } |
86464 | - case 18446744073709546094LLU: // 99999998ns''''''''''''''' | |
86775 | + case 18446744073709546079LLU: // 99999998nd''''''''''''''' | |
86465 | 86776 | { |
86466 | - state.addr = 18446744073709546095LLU; // 99999998nt''''''''''''''' | |
86777 | + state.addr = 18446744073709546080LLU; // 99999998ne''''''''''''''' | |
86467 | 86778 | break; |
86468 | 86779 | } |
86469 | - case 18446744073709546095LLU: // 99999998nt''''''''''''''' | |
86780 | + case 18446744073709546080LLU: // 99999998ne''''''''''''''' | |
86470 | 86781 | { |
86471 | 86782 | |
86472 | - state.addr = 18446744073709546093LLU; // 99999998nr''''''''''''''' | |
86783 | + state.addr = 18446744073709546078LLU; // 99999998nc''''''''''''''' | |
86473 | 86784 | break; |
86474 | 86785 | } |
86475 | - case 18446744073709546093LLU: // 99999998nr''''''''''''''' | |
86786 | + case 18446744073709546078LLU: // 99999998nc''''''''''''''' | |
86476 | 86787 | { |
86477 | 86788 | *LOCAL_ACCESS(heap.data, 19LLU, 15LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 7LLU))); |
86478 | - state.addr = 18446744073709546092LLU; // 99999998nq''''''''''''''' | |
86789 | + state.addr = 18446744073709546077LLU; // 99999998nb''''''''''''''' | |
86479 | 86790 | break; |
86480 | 86791 | } |
86481 | - case 18446744073709546092LLU: // 99999998nq''''''''''''''' | |
86792 | + case 18446744073709546077LLU: // 99999998nb''''''''''''''' | |
86482 | 86793 | { |
86483 | 86794 | // ACCUMULATE ARGUMENTS - BEGIN |
86484 | 86795 | { |
@@ -86498,7 +86809,7 @@ | ||
86498 | 86809 | LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
86499 | 86810 | } |
86500 | 86811 | // ACCUMULATE ARGUMENTS - END |
86501 | - uint64_t return_to = 18446744073709546090LLU; | |
86812 | + uint64_t return_to = 18446744073709546075LLU; | |
86502 | 86813 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
86503 | 86814 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
86504 | 86815 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -86507,12 +86818,12 @@ | ||
86507 | 86818 | state.addr = 517555565473470767LLU; // assertinit |
86508 | 86819 | break; |
86509 | 86820 | } |
86510 | - case 18446744073709546090LLU: // 99999998no''''''''''''''' | |
86821 | + case 18446744073709546075LLU: // 99999998n$''''''''''''''' | |
86511 | 86822 | { |
86512 | - state.addr = 18446744073709546091LLU; // 99999998np''''''''''''''' | |
86823 | + state.addr = 18446744073709546076LLU; // 99999998na''''''''''''''' | |
86513 | 86824 | break; |
86514 | 86825 | } |
86515 | - case 18446744073709546091LLU: // 99999998np''''''''''''''' | |
86826 | + case 18446744073709546076LLU: // 99999998na''''''''''''''' | |
86516 | 86827 | { |
86517 | 86828 | { |
86518 | 86829 | uint64_t arg = 0; |
@@ -86591,7 +86902,7 @@ | ||
86591 | 86902 | LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
86592 | 86903 | } |
86593 | 86904 | // ACCUMULATE ARGUMENTS - END |
86594 | - uint64_t return_to = 18446744073709546088LLU; | |
86905 | + uint64_t return_to = 18446744073709546073LLU; | |
86595 | 86906 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)); |
86596 | 86907 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
86597 | 86908 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -86600,12 +86911,12 @@ | ||
86600 | 86911 | state.addr = 787472342492567585LLU; // procvarref |
86601 | 86912 | break; |
86602 | 86913 | } |
86603 | - case 18446744073709546088LLU: // 99999998nm''''''''''''''' | |
86914 | + case 18446744073709546073LLU: // 99999998nY''''''''''''''' | |
86604 | 86915 | { |
86605 | - state.addr = 18446744073709546089LLU; // 99999998nn''''''''''''''' | |
86916 | + state.addr = 18446744073709546074LLU; // 99999998nZ''''''''''''''' | |
86606 | 86917 | break; |
86607 | 86918 | } |
86608 | - case 18446744073709546089LLU: // 99999998nn''''''''''''''' | |
86919 | + case 18446744073709546074LLU: // 99999998nZ''''''''''''''' | |
86609 | 86920 | { |
86610 | 86921 | // variable u64 initialize goes out of scope |
86611 | 86922 | // emitted destructur for type u64 |
@@ -86616,10 +86927,10 @@ | ||
86616 | 86927 | // variable u64 idx_______ goes out of scope |
86617 | 86928 | // emitted destructur for type u64 |
86618 | 86929 | (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference idx_______ at 20 |
86619 | - state.addr = 18446744073709546096LLU; // 99999998nu''''''''''''''' | |
86930 | + state.addr = 18446744073709546081LLU; // 99999998nf''''''''''''''' | |
86620 | 86931 | break; |
86621 | 86932 | } |
86622 | - case 18446744073709546096LLU: // 99999998nu''''''''''''''' | |
86933 | + case 18446744073709546081LLU: // 99999998nf''''''''''''''' | |
86623 | 86934 | { |
86624 | 86935 | fprintf(stdout, "%s", ", stderr);"); |
86625 | 86936 | // ACCUMULATE ARGUMENTS - BEGIN |
@@ -86628,7 +86939,7 @@ | ||
86628 | 86939 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
86629 | 86940 | } |
86630 | 86941 | // ACCUMULATE ARGUMENTS - END |
86631 | - uint64_t return_to = 18446744073709546086LLU; | |
86942 | + uint64_t return_to = 18446744073709546071LLU; | |
86632 | 86943 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
86633 | 86944 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
86634 | 86945 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -86637,12 +86948,12 @@ | ||
86637 | 86948 | state.addr = 839519719621918720LLU; // skipws____ |
86638 | 86949 | break; |
86639 | 86950 | } |
86640 | - case 18446744073709546086LLU: // 99999998nk''''''''''''''' | |
86951 | + case 18446744073709546071LLU: // 99999998nW''''''''''''''' | |
86641 | 86952 | { |
86642 | - state.addr = 18446744073709546087LLU; // 99999998nl''''''''''''''' | |
86953 | + state.addr = 18446744073709546072LLU; // 99999998nX''''''''''''''' | |
86643 | 86954 | break; |
86644 | 86955 | } |
86645 | - case 18446744073709546087LLU: // 99999998nl''''''''''''''' | |
86956 | + case 18446744073709546072LLU: // 99999998nX''''''''''''''' | |
86646 | 86957 | { |
86647 | 86958 | ungetc((int)/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 7LLU)), stdin); |
86648 | 86959 | if(')' != (char)getchar()) |
@@ -86660,7 +86971,7 @@ | ||
86660 | 86971 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
86661 | 86972 | } |
86662 | 86973 | // ACCUMULATE ARGUMENTS - END |
86663 | - uint64_t return_to = 18446744073709546084LLU; | |
86974 | + uint64_t return_to = 18446744073709546069LLU; | |
86664 | 86975 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
86665 | 86976 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
86666 | 86977 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -86669,12 +86980,12 @@ | ||
86669 | 86980 | state.addr = 517555565476695680LLU; // assertu64_ |
86670 | 86981 | break; |
86671 | 86982 | } |
86672 | - case 18446744073709546084LLU: // 99999998ni''''''''''''''' | |
86983 | + case 18446744073709546069LLU: // 99999998nU''''''''''''''' | |
86673 | 86984 | { |
86674 | - state.addr = 18446744073709546085LLU; // 99999998nj''''''''''''''' | |
86985 | + state.addr = 18446744073709546070LLU; // 99999998nV''''''''''''''' | |
86675 | 86986 | break; |
86676 | 86987 | } |
86677 | - case 18446744073709546085LLU: // 99999998nj''''''''''''''' | |
86988 | + case 18446744073709546070LLU: // 99999998nV''''''''''''''' | |
86678 | 86989 | { |
86679 | 86990 | // variable u64 mutable___ goes out of scope |
86680 | 86991 | // emitted destructur for type u64 |
@@ -86687,7 +86998,7 @@ | ||
86687 | 86998 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
86688 | 86999 | } |
86689 | 87000 | // ACCUMULATE ARGUMENTS - END |
86690 | - uint64_t return_to = 18446744073709546083LLU; | |
87001 | + uint64_t return_to = 18446744073709546068LLU; | |
86691 | 87002 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
86692 | 87003 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
86693 | 87004 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -86696,7 +87007,7 @@ | ||
86696 | 87007 | state.addr = 18446744073709551534LLU; // 999999998s''''''''''''''' |
86697 | 87008 | break; |
86698 | 87009 | } |
86699 | - case 18446744073709546083LLU: // 99999998nh''''''''''''''' | |
87010 | + case 18446744073709546068LLU: // 99999998nT''''''''''''''' | |
86700 | 87011 | { |
86701 | 87012 | (void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type______ at 18 |
86702 | 87013 | // variable u64 INDIRECT__ goes out of scope |
@@ -86707,34 +87018,34 @@ | ||
86707 | 87018 | (void)LOCAL_POP_MOVE(&heap, 16LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id________ at 16 |
86708 | 87019 | heap.availilable_size_for_dynamic_objects += 0LLU; |
86709 | 87020 | heap.availilable_size_for_dynamic_objects += 0LLU; |
86710 | - state.addr = 18446744073709546082LLU; // 99999998ng''''''''''''''' | |
87021 | + state.addr = 18446744073709546067LLU; // 99999998nS''''''''''''''' | |
86711 | 87022 | break; |
86712 | 87023 | } |
86713 | - case 18446744073709546101LLU: // 99999998nz''''''''''''''' | |
87024 | + case 18446744073709546086LLU: // 99999998nk''''''''''''''' | |
86714 | 87025 | { |
86715 | 87026 | |
86716 | - state.addr = 18446744073709546081LLU; // 99999998nf''''''''''''''' | |
87027 | + state.addr = 18446744073709546066LLU; // 99999998nR''''''''''''''' | |
86717 | 87028 | break; |
86718 | 87029 | } |
86719 | - case 18446744073709546081LLU: // 99999998nf''''''''''''''' | |
87030 | + case 18446744073709546066LLU: // 99999998nR''''''''''''''' | |
86720 | 87031 | { |
86721 | 87032 | *LOCAL_ACCESS(heap.data, 15LLU, 14LLU) = 787446708011125568; |
86722 | 87033 | |
86723 | - state.addr = 18446744073709546080LLU; // 99999998ne''''''''''''''' | |
87034 | + state.addr = 18446744073709546065LLU; // 99999998nQ''''''''''''''' | |
86724 | 87035 | break; |
86725 | 87036 | } |
86726 | - case 18446744073709546080LLU: // 99999998ne''''''''''''''' | |
87037 | + case 18446744073709546065LLU: // 99999998nQ''''''''''''''' | |
86727 | 87038 | { |
86728 | 87039 | *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) = /*sym_______*/*LOCAL_ACCESS(heap.data, 15LLU, 14LLU) == /*callee_id_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 6LLU)); |
86729 | - state.addr = 18446744073709546079LLU; // 99999998nd''''''''''''''' | |
87040 | + state.addr = 18446744073709546064LLU; // 99999998nP''''''''''''''' | |
86730 | 87041 | break; |
86731 | 87042 | } |
86732 | - case 18446744073709546079LLU: // 99999998nd''''''''''''''' | |
87043 | + case 18446744073709546064LLU: // 99999998nP''''''''''''''' | |
86733 | 87044 | { |
86734 | - state.addr = *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709546078LLU : 18446744073709546077LLU; | |
87045 | + state.addr = *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709546063LLU : 18446744073709546062LLU; | |
86735 | 87046 | break; |
86736 | 87047 | } |
86737 | - case 18446744073709546078LLU: // 99999998nc''''''''''''''' | |
87048 | + case 18446744073709546063LLU: // 99999998nO''''''''''''''' | |
86738 | 87049 | { |
86739 | 87050 | { |
86740 | 87051 | uint64_t arg = 0; |
@@ -86756,7 +87067,7 @@ | ||
86756 | 87067 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
86757 | 87068 | } |
86758 | 87069 | // ACCUMULATE ARGUMENTS - END |
86759 | - uint64_t return_to = 18446744073709546075LLU; | |
87070 | + uint64_t return_to = 18446744073709546060LLU; | |
86760 | 87071 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
86761 | 87072 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
86762 | 87073 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -86765,12 +87076,12 @@ | ||
86765 | 87076 | state.addr = 861504796319285248LLU; // typeu64___ |
86766 | 87077 | break; |
86767 | 87078 | } |
86768 | - case 18446744073709546075LLU: // 99999998n$''''''''''''''' | |
87079 | + case 18446744073709546060LLU: // 99999998nL''''''''''''''' | |
86769 | 87080 | { |
86770 | - state.addr = 18446744073709546076LLU; // 99999998na''''''''''''''' | |
87081 | + state.addr = 18446744073709546061LLU; // 99999998nM''''''''''''''' | |
86771 | 87082 | break; |
86772 | 87083 | } |
86773 | - case 18446744073709546076LLU: // 99999998na''''''''''''''' | |
87084 | + case 18446744073709546061LLU: // 99999998nM''''''''''''''' | |
86774 | 87085 | { |
86775 | 87086 | // ACCUMULATE ARGUMENTS - BEGIN |
86776 | 87087 | { |
@@ -86778,7 +87089,7 @@ | ||
86778 | 87089 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
86779 | 87090 | } |
86780 | 87091 | // ACCUMULATE ARGUMENTS - END |
86781 | - uint64_t return_to = 18446744073709546073LLU; | |
87092 | + uint64_t return_to = 18446744073709546058LLU; | |
86782 | 87093 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
86783 | 87094 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
86784 | 87095 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -86787,12 +87098,12 @@ | ||
86787 | 87098 | state.addr = 839519719621918720LLU; // skipws____ |
86788 | 87099 | break; |
86789 | 87100 | } |
86790 | - case 18446744073709546073LLU: // 99999998nY''''''''''''''' | |
87101 | + case 18446744073709546058LLU: // 99999998nJ''''''''''''''' | |
86791 | 87102 | { |
86792 | - state.addr = 18446744073709546074LLU; // 99999998nZ''''''''''''''' | |
87103 | + state.addr = 18446744073709546059LLU; // 99999998nK''''''''''''''' | |
86793 | 87104 | break; |
86794 | 87105 | } |
86795 | - case 18446744073709546074LLU: // 99999998nZ''''''''''''''' | |
87106 | + case 18446744073709546059LLU: // 99999998nK''''''''''''''' | |
86796 | 87107 | { |
86797 | 87108 | matchid("(", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 18LLU, 7LLU))); |
86798 | 87109 | fprintf(stdout, "%s", "\n putc((char)"); |
@@ -86807,7 +87118,7 @@ | ||
86807 | 87118 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
86808 | 87119 | } |
86809 | 87120 | // ACCUMULATE ARGUMENTS - END |
86810 | - uint64_t return_to = 18446744073709546070LLU; | |
87121 | + uint64_t return_to = 18446744073709546055LLU; | |
86811 | 87122 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
86812 | 87123 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
86813 | 87124 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -86816,24 +87127,24 @@ | ||
86816 | 87127 | state.addr = 839519719621918720LLU; // skipws____ |
86817 | 87128 | break; |
86818 | 87129 | } |
86819 | - case 18446744073709546070LLU: // 99999998nV''''''''''''''' | |
87130 | + case 18446744073709546055LLU: // 99999998nG''''''''''''''' | |
86820 | 87131 | { |
86821 | - state.addr = 18446744073709546071LLU; // 99999998nW''''''''''''''' | |
87132 | + state.addr = 18446744073709546056LLU; // 99999998nH''''''''''''''' | |
86822 | 87133 | break; |
86823 | 87134 | } |
86824 | - case 18446744073709546071LLU: // 99999998nW''''''''''''''' | |
87135 | + case 18446744073709546056LLU: // 99999998nH''''''''''''''' | |
86825 | 87136 | { |
86826 | 87137 | |
86827 | - state.addr = 18446744073709546069LLU; // 99999998nU''''''''''''''' | |
87138 | + state.addr = 18446744073709546054LLU; // 99999998nF''''''''''''''' | |
86828 | 87139 | break; |
86829 | 87140 | } |
86830 | - case 18446744073709546069LLU: // 99999998nU''''''''''''''' | |
87141 | + case 18446744073709546054LLU: // 99999998nF''''''''''''''' | |
86831 | 87142 | { |
86832 | 87143 | *LOCAL_ACCESS(heap.data, 19LLU, 15LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 7LLU))); |
86833 | - state.addr = 18446744073709546068LLU; // 99999998nT''''''''''''''' | |
87144 | + state.addr = 18446744073709546053LLU; // 99999998nE''''''''''''''' | |
86834 | 87145 | break; |
86835 | 87146 | } |
86836 | - case 18446744073709546068LLU: // 99999998nT''''''''''''''' | |
87147 | + case 18446744073709546053LLU: // 99999998nE''''''''''''''' | |
86837 | 87148 | { |
86838 | 87149 | // ACCUMULATE ARGUMENTS - BEGIN |
86839 | 87150 | { |
@@ -86853,7 +87164,7 @@ | ||
86853 | 87164 | LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
86854 | 87165 | } |
86855 | 87166 | // ACCUMULATE ARGUMENTS - END |
86856 | - uint64_t return_to = 18446744073709546066LLU; | |
87167 | + uint64_t return_to = 18446744073709546051LLU; | |
86857 | 87168 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
86858 | 87169 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
86859 | 87170 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -86862,12 +87173,12 @@ | ||
86862 | 87173 | state.addr = 517555565473470767LLU; // assertinit |
86863 | 87174 | break; |
86864 | 87175 | } |
86865 | - case 18446744073709546066LLU: // 99999998nR''''''''''''''' | |
87176 | + case 18446744073709546051LLU: // 99999998nC''''''''''''''' | |
86866 | 87177 | { |
86867 | - state.addr = 18446744073709546067LLU; // 99999998nS''''''''''''''' | |
87178 | + state.addr = 18446744073709546052LLU; // 99999998nD''''''''''''''' | |
86868 | 87179 | break; |
86869 | 87180 | } |
86870 | - case 18446744073709546067LLU: // 99999998nS''''''''''''''' | |
87181 | + case 18446744073709546052LLU: // 99999998nD''''''''''''''' | |
86871 | 87182 | { |
86872 | 87183 | { |
86873 | 87184 | uint64_t arg = 0; |
@@ -86946,7 +87257,7 @@ | ||
86946 | 87257 | LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
86947 | 87258 | } |
86948 | 87259 | // ACCUMULATE ARGUMENTS - END |
86949 | - uint64_t return_to = 18446744073709546064LLU; | |
87260 | + uint64_t return_to = 18446744073709546049LLU; | |
86950 | 87261 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)); |
86951 | 87262 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
86952 | 87263 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -86955,12 +87266,12 @@ | ||
86955 | 87266 | state.addr = 787472342492567585LLU; // procvarref |
86956 | 87267 | break; |
86957 | 87268 | } |
86958 | - case 18446744073709546064LLU: // 99999998nP''''''''''''''' | |
87269 | + case 18446744073709546049LLU: // 99999998nA''''''''''''''' | |
86959 | 87270 | { |
86960 | - state.addr = 18446744073709546065LLU; // 99999998nQ''''''''''''''' | |
87271 | + state.addr = 18446744073709546050LLU; // 99999998nB''''''''''''''' | |
86961 | 87272 | break; |
86962 | 87273 | } |
86963 | - case 18446744073709546065LLU: // 99999998nQ''''''''''''''' | |
87274 | + case 18446744073709546050LLU: // 99999998nB''''''''''''''' | |
86964 | 87275 | { |
86965 | 87276 | // variable u64 initialize goes out of scope |
86966 | 87277 | // emitted destructur for type u64 |
@@ -86971,10 +87282,10 @@ | ||
86971 | 87282 | // variable u64 idx_______ goes out of scope |
86972 | 87283 | // emitted destructur for type u64 |
86973 | 87284 | (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference idx_______ at 20 |
86974 | - state.addr = 18446744073709546072LLU; // 99999998nX''''''''''''''' | |
87285 | + state.addr = 18446744073709546057LLU; // 99999998nI''''''''''''''' | |
86975 | 87286 | break; |
86976 | 87287 | } |
86977 | - case 18446744073709546072LLU: // 99999998nX''''''''''''''' | |
87288 | + case 18446744073709546057LLU: // 99999998nI''''''''''''''' | |
86978 | 87289 | { |
86979 | 87290 | fprintf(stdout, "%s", ", stdout);"); |
86980 | 87291 | // ACCUMULATE ARGUMENTS - BEGIN |
@@ -86983,7 +87294,7 @@ | ||
86983 | 87294 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
86984 | 87295 | } |
86985 | 87296 | // ACCUMULATE ARGUMENTS - END |
86986 | - uint64_t return_to = 18446744073709546062LLU; | |
87297 | + uint64_t return_to = 18446744073709546047LLU; | |
86987 | 87298 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
86988 | 87299 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
86989 | 87300 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -86992,12 +87303,12 @@ | ||
86992 | 87303 | state.addr = 839519719621918720LLU; // skipws____ |
86993 | 87304 | break; |
86994 | 87305 | } |
86995 | - case 18446744073709546062LLU: // 99999998nN''''''''''''''' | |
87306 | + case 18446744073709546047LLU: // 99999998m9''''''''''''''' | |
86996 | 87307 | { |
86997 | - state.addr = 18446744073709546063LLU; // 99999998nO''''''''''''''' | |
87308 | + state.addr = 18446744073709546048LLU; // 99999998n_''''''''''''''' | |
86998 | 87309 | break; |
86999 | 87310 | } |
87000 | - case 18446744073709546063LLU: // 99999998nO''''''''''''''' | |
87311 | + case 18446744073709546048LLU: // 99999998n_''''''''''''''' | |
87001 | 87312 | { |
87002 | 87313 | ungetc((int)/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 7LLU)), stdin); |
87003 | 87314 | if(')' != (char)getchar()) |
@@ -87015,7 +87326,7 @@ | ||
87015 | 87326 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
87016 | 87327 | } |
87017 | 87328 | // ACCUMULATE ARGUMENTS - END |
87018 | - uint64_t return_to = 18446744073709546060LLU; | |
87329 | + uint64_t return_to = 18446744073709546045LLU; | |
87019 | 87330 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
87020 | 87331 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
87021 | 87332 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -87024,12 +87335,12 @@ | ||
87024 | 87335 | state.addr = 517555565476695680LLU; // assertu64_ |
87025 | 87336 | break; |
87026 | 87337 | } |
87027 | - case 18446744073709546060LLU: // 99999998nL''''''''''''''' | |
87338 | + case 18446744073709546045LLU: // 99999998m7''''''''''''''' | |
87028 | 87339 | { |
87029 | - state.addr = 18446744073709546061LLU; // 99999998nM''''''''''''''' | |
87340 | + state.addr = 18446744073709546046LLU; // 99999998m8''''''''''''''' | |
87030 | 87341 | break; |
87031 | 87342 | } |
87032 | - case 18446744073709546061LLU: // 99999998nM''''''''''''''' | |
87343 | + case 18446744073709546046LLU: // 99999998m8''''''''''''''' | |
87033 | 87344 | { |
87034 | 87345 | // variable u64 mutable___ goes out of scope |
87035 | 87346 | // emitted destructur for type u64 |
@@ -87042,7 +87353,7 @@ | ||
87042 | 87353 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
87043 | 87354 | } |
87044 | 87355 | // ACCUMULATE ARGUMENTS - END |
87045 | - uint64_t return_to = 18446744073709546059LLU; | |
87356 | + uint64_t return_to = 18446744073709546044LLU; | |
87046 | 87357 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
87047 | 87358 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
87048 | 87359 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -87051,7 +87362,7 @@ | ||
87051 | 87362 | state.addr = 18446744073709551534LLU; // 999999998s''''''''''''''' |
87052 | 87363 | break; |
87053 | 87364 | } |
87054 | - case 18446744073709546059LLU: // 99999998nK''''''''''''''' | |
87365 | + case 18446744073709546044LLU: // 99999998m6''''''''''''''' | |
87055 | 87366 | { |
87056 | 87367 | (void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type______ at 18 |
87057 | 87368 | // variable u64 INDIRECT__ goes out of scope |
@@ -87062,34 +87373,34 @@ | ||
87062 | 87373 | (void)LOCAL_POP_MOVE(&heap, 16LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id________ at 16 |
87063 | 87374 | heap.availilable_size_for_dynamic_objects += 0LLU; |
87064 | 87375 | heap.availilable_size_for_dynamic_objects += 0LLU; |
87065 | - state.addr = 18446744073709546058LLU; // 99999998nJ''''''''''''''' | |
87376 | + state.addr = 18446744073709546043LLU; // 99999998m5''''''''''''''' | |
87066 | 87377 | break; |
87067 | 87378 | } |
87068 | - case 18446744073709546077LLU: // 99999998nb''''''''''''''' | |
87379 | + case 18446744073709546062LLU: // 99999998nN''''''''''''''' | |
87069 | 87380 | { |
87070 | 87381 | |
87071 | - state.addr = 18446744073709546057LLU; // 99999998nI''''''''''''''' | |
87382 | + state.addr = 18446744073709546042LLU; // 99999998m4''''''''''''''' | |
87072 | 87383 | break; |
87073 | 87384 | } |
87074 | - case 18446744073709546057LLU: // 99999998nI''''''''''''''' | |
87385 | + case 18446744073709546042LLU: // 99999998m4''''''''''''''' | |
87075 | 87386 | { |
87076 | 87387 | *LOCAL_ACCESS(heap.data, 15LLU, 14LLU) = 787446708110622720; |
87077 | 87388 | |
87078 | - state.addr = 18446744073709546056LLU; // 99999998nH''''''''''''''' | |
87389 | + state.addr = 18446744073709546041LLU; // 99999998m3''''''''''''''' | |
87079 | 87390 | break; |
87080 | 87391 | } |
87081 | - case 18446744073709546056LLU: // 99999998nH''''''''''''''' | |
87392 | + case 18446744073709546041LLU: // 99999998m3''''''''''''''' | |
87082 | 87393 | { |
87083 | 87394 | *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) = /*sym_______*/*LOCAL_ACCESS(heap.data, 15LLU, 14LLU) == /*callee_id_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 6LLU)); |
87084 | - state.addr = 18446744073709546055LLU; // 99999998nG''''''''''''''' | |
87395 | + state.addr = 18446744073709546040LLU; // 99999998m2''''''''''''''' | |
87085 | 87396 | break; |
87086 | 87397 | } |
87087 | - case 18446744073709546055LLU: // 99999998nG''''''''''''''' | |
87398 | + case 18446744073709546040LLU: // 99999998m2''''''''''''''' | |
87088 | 87399 | { |
87089 | - state.addr = *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709546054LLU : 18446744073709546053LLU; | |
87400 | + state.addr = *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709546039LLU : 18446744073709546038LLU; | |
87090 | 87401 | break; |
87091 | 87402 | } |
87092 | - case 18446744073709546054LLU: // 99999998nF''''''''''''''' | |
87403 | + case 18446744073709546039LLU: // 99999998m1''''''''''''''' | |
87093 | 87404 | { |
87094 | 87405 | { |
87095 | 87406 | uint64_t arg = 0; |
@@ -87111,7 +87422,7 @@ | ||
87111 | 87422 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
87112 | 87423 | } |
87113 | 87424 | // ACCUMULATE ARGUMENTS - END |
87114 | - uint64_t return_to = 18446744073709546051LLU; | |
87425 | + uint64_t return_to = 18446744073709546036LLU; | |
87115 | 87426 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
87116 | 87427 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
87117 | 87428 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -87120,12 +87431,12 @@ | ||
87120 | 87431 | state.addr = 861504796319285248LLU; // typeu64___ |
87121 | 87432 | break; |
87122 | 87433 | } |
87123 | - case 18446744073709546051LLU: // 99999998nC''''''''''''''' | |
87434 | + case 18446744073709546036LLU: // 99999998my''''''''''''''' | |
87124 | 87435 | { |
87125 | - state.addr = 18446744073709546052LLU; // 99999998nD''''''''''''''' | |
87436 | + state.addr = 18446744073709546037LLU; // 99999998mz''''''''''''''' | |
87126 | 87437 | break; |
87127 | 87438 | } |
87128 | - case 18446744073709546052LLU: // 99999998nD''''''''''''''' | |
87439 | + case 18446744073709546037LLU: // 99999998mz''''''''''''''' | |
87129 | 87440 | { |
87130 | 87441 | // ACCUMULATE ARGUMENTS - BEGIN |
87131 | 87442 | { |
@@ -87133,7 +87444,7 @@ | ||
87133 | 87444 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
87134 | 87445 | } |
87135 | 87446 | // ACCUMULATE ARGUMENTS - END |
87136 | - uint64_t return_to = 18446744073709546049LLU; | |
87447 | + uint64_t return_to = 18446744073709546034LLU; | |
87137 | 87448 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
87138 | 87449 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
87139 | 87450 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -87142,12 +87453,12 @@ | ||
87142 | 87453 | state.addr = 839519719621918720LLU; // skipws____ |
87143 | 87454 | break; |
87144 | 87455 | } |
87145 | - case 18446744073709546049LLU: // 99999998nA''''''''''''''' | |
87456 | + case 18446744073709546034LLU: // 99999998mw''''''''''''''' | |
87146 | 87457 | { |
87147 | - state.addr = 18446744073709546050LLU; // 99999998nB''''''''''''''' | |
87458 | + state.addr = 18446744073709546035LLU; // 99999998mx''''''''''''''' | |
87148 | 87459 | break; |
87149 | 87460 | } |
87150 | - case 18446744073709546050LLU: // 99999998nB''''''''''''''' | |
87461 | + case 18446744073709546035LLU: // 99999998mx''''''''''''''' | |
87151 | 87462 | { |
87152 | 87463 | matchid("(", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 18LLU, 7LLU))); |
87153 | 87464 | fprintf(stdout, "%s", "\n printid(stdout, "); |
@@ -87162,7 +87473,7 @@ | ||
87162 | 87473 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
87163 | 87474 | } |
87164 | 87475 | // ACCUMULATE ARGUMENTS - END |
87165 | - uint64_t return_to = 18446744073709546046LLU; | |
87476 | + uint64_t return_to = 18446744073709546031LLU; | |
87166 | 87477 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
87167 | 87478 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
87168 | 87479 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -87171,24 +87482,24 @@ | ||
87171 | 87482 | state.addr = 839519719621918720LLU; // skipws____ |
87172 | 87483 | break; |
87173 | 87484 | } |
87174 | - case 18446744073709546046LLU: // 99999998m8''''''''''''''' | |
87485 | + case 18446744073709546031LLU: // 99999998mt''''''''''''''' | |
87175 | 87486 | { |
87176 | - state.addr = 18446744073709546047LLU; // 99999998m9''''''''''''''' | |
87487 | + state.addr = 18446744073709546032LLU; // 99999998mu''''''''''''''' | |
87177 | 87488 | break; |
87178 | 87489 | } |
87179 | - case 18446744073709546047LLU: // 99999998m9''''''''''''''' | |
87490 | + case 18446744073709546032LLU: // 99999998mu''''''''''''''' | |
87180 | 87491 | { |
87181 | 87492 | |
87182 | - state.addr = 18446744073709546045LLU; // 99999998m7''''''''''''''' | |
87493 | + state.addr = 18446744073709546030LLU; // 99999998ms''''''''''''''' | |
87183 | 87494 | break; |
87184 | 87495 | } |
87185 | - case 18446744073709546045LLU: // 99999998m7''''''''''''''' | |
87496 | + case 18446744073709546030LLU: // 99999998ms''''''''''''''' | |
87186 | 87497 | { |
87187 | 87498 | *LOCAL_ACCESS(heap.data, 19LLU, 15LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 7LLU))); |
87188 | - state.addr = 18446744073709546044LLU; // 99999998m6''''''''''''''' | |
87499 | + state.addr = 18446744073709546029LLU; // 99999998mr''''''''''''''' | |
87189 | 87500 | break; |
87190 | 87501 | } |
87191 | - case 18446744073709546044LLU: // 99999998m6''''''''''''''' | |
87502 | + case 18446744073709546029LLU: // 99999998mr''''''''''''''' | |
87192 | 87503 | { |
87193 | 87504 | // ACCUMULATE ARGUMENTS - BEGIN |
87194 | 87505 | { |
@@ -87208,7 +87519,7 @@ | ||
87208 | 87519 | LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
87209 | 87520 | } |
87210 | 87521 | // ACCUMULATE ARGUMENTS - END |
87211 | - uint64_t return_to = 18446744073709546042LLU; | |
87522 | + uint64_t return_to = 18446744073709546027LLU; | |
87212 | 87523 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
87213 | 87524 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
87214 | 87525 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -87217,12 +87528,12 @@ | ||
87217 | 87528 | state.addr = 517555565473470767LLU; // assertinit |
87218 | 87529 | break; |
87219 | 87530 | } |
87220 | - case 18446744073709546042LLU: // 99999998m4''''''''''''''' | |
87531 | + case 18446744073709546027LLU: // 99999998mp''''''''''''''' | |
87221 | 87532 | { |
87222 | - state.addr = 18446744073709546043LLU; // 99999998m5''''''''''''''' | |
87533 | + state.addr = 18446744073709546028LLU; // 99999998mq''''''''''''''' | |
87223 | 87534 | break; |
87224 | 87535 | } |
87225 | - case 18446744073709546043LLU: // 99999998m5''''''''''''''' | |
87536 | + case 18446744073709546028LLU: // 99999998mq''''''''''''''' | |
87226 | 87537 | { |
87227 | 87538 | { |
87228 | 87539 | uint64_t arg = 0; |
@@ -87301,7 +87612,7 @@ | ||
87301 | 87612 | LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
87302 | 87613 | } |
87303 | 87614 | // ACCUMULATE ARGUMENTS - END |
87304 | - uint64_t return_to = 18446744073709546040LLU; | |
87615 | + uint64_t return_to = 18446744073709546025LLU; | |
87305 | 87616 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)); |
87306 | 87617 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
87307 | 87618 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -87310,12 +87621,12 @@ | ||
87310 | 87621 | state.addr = 787472342492567585LLU; // procvarref |
87311 | 87622 | break; |
87312 | 87623 | } |
87313 | - case 18446744073709546040LLU: // 99999998m2''''''''''''''' | |
87624 | + case 18446744073709546025LLU: // 99999998mn''''''''''''''' | |
87314 | 87625 | { |
87315 | - state.addr = 18446744073709546041LLU; // 99999998m3''''''''''''''' | |
87626 | + state.addr = 18446744073709546026LLU; // 99999998mo''''''''''''''' | |
87316 | 87627 | break; |
87317 | 87628 | } |
87318 | - case 18446744073709546041LLU: // 99999998m3''''''''''''''' | |
87629 | + case 18446744073709546026LLU: // 99999998mo''''''''''''''' | |
87319 | 87630 | { |
87320 | 87631 | // variable u64 initialize goes out of scope |
87321 | 87632 | // emitted destructur for type u64 |
@@ -87326,10 +87637,10 @@ | ||
87326 | 87637 | // variable u64 idx_______ goes out of scope |
87327 | 87638 | // emitted destructur for type u64 |
87328 | 87639 | (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference idx_______ at 20 |
87329 | - state.addr = 18446744073709546048LLU; // 99999998n_''''''''''''''' | |
87640 | + state.addr = 18446744073709546033LLU; // 99999998mv''''''''''''''' | |
87330 | 87641 | break; |
87331 | 87642 | } |
87332 | - case 18446744073709546048LLU: // 99999998n_''''''''''''''' | |
87643 | + case 18446744073709546033LLU: // 99999998mv''''''''''''''' | |
87333 | 87644 | { |
87334 | 87645 | fprintf(stdout, "%s", ");"); |
87335 | 87646 | // ACCUMULATE ARGUMENTS - BEGIN |
@@ -87338,7 +87649,7 @@ | ||
87338 | 87649 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
87339 | 87650 | } |
87340 | 87651 | // ACCUMULATE ARGUMENTS - END |
87341 | - uint64_t return_to = 18446744073709546038LLU; | |
87652 | + uint64_t return_to = 18446744073709546023LLU; | |
87342 | 87653 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
87343 | 87654 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
87344 | 87655 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -87347,12 +87658,12 @@ | ||
87347 | 87658 | state.addr = 839519719621918720LLU; // skipws____ |
87348 | 87659 | break; |
87349 | 87660 | } |
87350 | - case 18446744073709546038LLU: // 99999998m0''''''''''''''' | |
87661 | + case 18446744073709546023LLU: // 99999998ml''''''''''''''' | |
87351 | 87662 | { |
87352 | - state.addr = 18446744073709546039LLU; // 99999998m1''''''''''''''' | |
87663 | + state.addr = 18446744073709546024LLU; // 99999998mm''''''''''''''' | |
87353 | 87664 | break; |
87354 | 87665 | } |
87355 | - case 18446744073709546039LLU: // 99999998m1''''''''''''''' | |
87666 | + case 18446744073709546024LLU: // 99999998mm''''''''''''''' | |
87356 | 87667 | { |
87357 | 87668 | ungetc((int)/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 7LLU)), stdin); |
87358 | 87669 | if(')' != (char)getchar()) |
@@ -87370,7 +87681,7 @@ | ||
87370 | 87681 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
87371 | 87682 | } |
87372 | 87683 | // ACCUMULATE ARGUMENTS - END |
87373 | - uint64_t return_to = 18446744073709546036LLU; | |
87684 | + uint64_t return_to = 18446744073709546021LLU; | |
87374 | 87685 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
87375 | 87686 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
87376 | 87687 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -87379,12 +87690,12 @@ | ||
87379 | 87690 | state.addr = 517555565476695680LLU; // assertu64_ |
87380 | 87691 | break; |
87381 | 87692 | } |
87382 | - case 18446744073709546036LLU: // 99999998my''''''''''''''' | |
87693 | + case 18446744073709546021LLU: // 99999998mj''''''''''''''' | |
87383 | 87694 | { |
87384 | - state.addr = 18446744073709546037LLU; // 99999998mz''''''''''''''' | |
87695 | + state.addr = 18446744073709546022LLU; // 99999998mk''''''''''''''' | |
87385 | 87696 | break; |
87386 | 87697 | } |
87387 | - case 18446744073709546037LLU: // 99999998mz''''''''''''''' | |
87698 | + case 18446744073709546022LLU: // 99999998mk''''''''''''''' | |
87388 | 87699 | { |
87389 | 87700 | // variable u64 mutable___ goes out of scope |
87390 | 87701 | // emitted destructur for type u64 |
@@ -87397,7 +87708,7 @@ | ||
87397 | 87708 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
87398 | 87709 | } |
87399 | 87710 | // ACCUMULATE ARGUMENTS - END |
87400 | - uint64_t return_to = 18446744073709546035LLU; | |
87711 | + uint64_t return_to = 18446744073709546020LLU; | |
87401 | 87712 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
87402 | 87713 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
87403 | 87714 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -87406,7 +87717,7 @@ | ||
87406 | 87717 | state.addr = 18446744073709551534LLU; // 999999998s''''''''''''''' |
87407 | 87718 | break; |
87408 | 87719 | } |
87409 | - case 18446744073709546035LLU: // 99999998mx''''''''''''''' | |
87720 | + case 18446744073709546020LLU: // 99999998mi''''''''''''''' | |
87410 | 87721 | { |
87411 | 87722 | (void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type______ at 18 |
87412 | 87723 | // variable u64 INDIRECT__ goes out of scope |
@@ -87417,34 +87728,34 @@ | ||
87417 | 87728 | (void)LOCAL_POP_MOVE(&heap, 16LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id________ at 16 |
87418 | 87729 | heap.availilable_size_for_dynamic_objects += 0LLU; |
87419 | 87730 | heap.availilable_size_for_dynamic_objects += 0LLU; |
87420 | - state.addr = 18446744073709546034LLU; // 99999998mw''''''''''''''' | |
87731 | + state.addr = 18446744073709546019LLU; // 99999998mh''''''''''''''' | |
87421 | 87732 | break; |
87422 | 87733 | } |
87423 | - case 18446744073709546053LLU: // 99999998nE''''''''''''''' | |
87734 | + case 18446744073709546038LLU: // 99999998m0''''''''''''''' | |
87424 | 87735 | { |
87425 | 87736 | |
87426 | - state.addr = 18446744073709546033LLU; // 99999998mv''''''''''''''' | |
87737 | + state.addr = 18446744073709546018LLU; // 99999998mg''''''''''''''' | |
87427 | 87738 | break; |
87428 | 87739 | } |
87429 | - case 18446744073709546033LLU: // 99999998mv''''''''''''''' | |
87740 | + case 18446744073709546018LLU: // 99999998mg''''''''''''''' | |
87430 | 87741 | { |
87431 | 87742 | *LOCAL_ACCESS(heap.data, 15LLU, 14LLU) = 819847183515906048; |
87432 | 87743 | |
87433 | - state.addr = 18446744073709546032LLU; // 99999998mu''''''''''''''' | |
87744 | + state.addr = 18446744073709546017LLU; // 99999998mf''''''''''''''' | |
87434 | 87745 | break; |
87435 | 87746 | } |
87436 | - case 18446744073709546032LLU: // 99999998mu''''''''''''''' | |
87747 | + case 18446744073709546017LLU: // 99999998mf''''''''''''''' | |
87437 | 87748 | { |
87438 | 87749 | *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) = /*sym_______*/*LOCAL_ACCESS(heap.data, 15LLU, 14LLU) == /*callee_id_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 6LLU)); |
87439 | - state.addr = 18446744073709546031LLU; // 99999998mt''''''''''''''' | |
87750 | + state.addr = 18446744073709546016LLU; // 99999998me''''''''''''''' | |
87440 | 87751 | break; |
87441 | 87752 | } |
87442 | - case 18446744073709546031LLU: // 99999998mt''''''''''''''' | |
87753 | + case 18446744073709546016LLU: // 99999998me''''''''''''''' | |
87443 | 87754 | { |
87444 | - state.addr = *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709546030LLU : 18446744073709546029LLU; | |
87755 | + state.addr = *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709546015LLU : 18446744073709546014LLU; | |
87445 | 87756 | break; |
87446 | 87757 | } |
87447 | - case 18446744073709546030LLU: // 99999998ms''''''''''''''' | |
87758 | + case 18446744073709546015LLU: // 99999998md''''''''''''''' | |
87448 | 87759 | { |
87449 | 87760 | { |
87450 | 87761 | uint64_t arg = 0; |
@@ -87466,7 +87777,7 @@ | ||
87466 | 87777 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
87467 | 87778 | } |
87468 | 87779 | // ACCUMULATE ARGUMENTS - END |
87469 | - uint64_t return_to = 18446744073709546027LLU; | |
87780 | + uint64_t return_to = 18446744073709546012LLU; | |
87470 | 87781 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
87471 | 87782 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
87472 | 87783 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -87475,12 +87786,12 @@ | ||
87475 | 87786 | state.addr = 861504796319285248LLU; // typeu64___ |
87476 | 87787 | break; |
87477 | 87788 | } |
87478 | - case 18446744073709546027LLU: // 99999998mp''''''''''''''' | |
87789 | + case 18446744073709546012LLU: // 99999998ma''''''''''''''' | |
87479 | 87790 | { |
87480 | - state.addr = 18446744073709546028LLU; // 99999998mq''''''''''''''' | |
87791 | + state.addr = 18446744073709546013LLU; // 99999998mb''''''''''''''' | |
87481 | 87792 | break; |
87482 | 87793 | } |
87483 | - case 18446744073709546028LLU: // 99999998mq''''''''''''''' | |
87794 | + case 18446744073709546013LLU: // 99999998mb''''''''''''''' | |
87484 | 87795 | { |
87485 | 87796 | // ACCUMULATE ARGUMENTS - BEGIN |
87486 | 87797 | { |
@@ -87488,7 +87799,7 @@ | ||
87488 | 87799 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
87489 | 87800 | } |
87490 | 87801 | // ACCUMULATE ARGUMENTS - END |
87491 | - uint64_t return_to = 18446744073709546025LLU; | |
87802 | + uint64_t return_to = 18446744073709546010LLU; | |
87492 | 87803 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
87493 | 87804 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
87494 | 87805 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -87497,12 +87808,12 @@ | ||
87497 | 87808 | state.addr = 839519719621918720LLU; // skipws____ |
87498 | 87809 | break; |
87499 | 87810 | } |
87500 | - case 18446744073709546025LLU: // 99999998mn''''''''''''''' | |
87811 | + case 18446744073709546010LLU: // 99999998mZ''''''''''''''' | |
87501 | 87812 | { |
87502 | - state.addr = 18446744073709546026LLU; // 99999998mo''''''''''''''' | |
87813 | + state.addr = 18446744073709546011LLU; // 99999998m$''''''''''''''' | |
87503 | 87814 | break; |
87504 | 87815 | } |
87505 | - case 18446744073709546026LLU: // 99999998mo''''''''''''''' | |
87816 | + case 18446744073709546011LLU: // 99999998m$''''''''''''''' | |
87506 | 87817 | { |
87507 | 87818 | matchid("(", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 18LLU, 7LLU))); |
87508 | 87819 | fprintf(stdout, "%s", "\n printid(stderr, "); |
@@ -87517,7 +87828,7 @@ | ||
87517 | 87828 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
87518 | 87829 | } |
87519 | 87830 | // ACCUMULATE ARGUMENTS - END |
87520 | - uint64_t return_to = 18446744073709546022LLU; | |
87831 | + uint64_t return_to = 18446744073709546007LLU; | |
87521 | 87832 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
87522 | 87833 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
87523 | 87834 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -87526,24 +87837,24 @@ | ||
87526 | 87837 | state.addr = 839519719621918720LLU; // skipws____ |
87527 | 87838 | break; |
87528 | 87839 | } |
87529 | - case 18446744073709546022LLU: // 99999998mk''''''''''''''' | |
87840 | + case 18446744073709546007LLU: // 99999998mW''''''''''''''' | |
87530 | 87841 | { |
87531 | - state.addr = 18446744073709546023LLU; // 99999998ml''''''''''''''' | |
87842 | + state.addr = 18446744073709546008LLU; // 99999998mX''''''''''''''' | |
87532 | 87843 | break; |
87533 | 87844 | } |
87534 | - case 18446744073709546023LLU: // 99999998ml''''''''''''''' | |
87845 | + case 18446744073709546008LLU: // 99999998mX''''''''''''''' | |
87535 | 87846 | { |
87536 | 87847 | |
87537 | - state.addr = 18446744073709546021LLU; // 99999998mj''''''''''''''' | |
87848 | + state.addr = 18446744073709546006LLU; // 99999998mV''''''''''''''' | |
87538 | 87849 | break; |
87539 | 87850 | } |
87540 | - case 18446744073709546021LLU: // 99999998mj''''''''''''''' | |
87851 | + case 18446744073709546006LLU: // 99999998mV''''''''''''''' | |
87541 | 87852 | { |
87542 | 87853 | *LOCAL_ACCESS(heap.data, 19LLU, 15LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 7LLU))); |
87543 | - state.addr = 18446744073709546020LLU; // 99999998mi''''''''''''''' | |
87854 | + state.addr = 18446744073709546005LLU; // 99999998mU''''''''''''''' | |
87544 | 87855 | break; |
87545 | 87856 | } |
87546 | - case 18446744073709546020LLU: // 99999998mi''''''''''''''' | |
87857 | + case 18446744073709546005LLU: // 99999998mU''''''''''''''' | |
87547 | 87858 | { |
87548 | 87859 | // ACCUMULATE ARGUMENTS - BEGIN |
87549 | 87860 | { |
@@ -87563,7 +87874,7 @@ | ||
87563 | 87874 | LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
87564 | 87875 | } |
87565 | 87876 | // ACCUMULATE ARGUMENTS - END |
87566 | - uint64_t return_to = 18446744073709546018LLU; | |
87877 | + uint64_t return_to = 18446744073709546003LLU; | |
87567 | 87878 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
87568 | 87879 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
87569 | 87880 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -87572,12 +87883,12 @@ | ||
87572 | 87883 | state.addr = 517555565473470767LLU; // assertinit |
87573 | 87884 | break; |
87574 | 87885 | } |
87575 | - case 18446744073709546018LLU: // 99999998mg''''''''''''''' | |
87886 | + case 18446744073709546003LLU: // 99999998mS''''''''''''''' | |
87576 | 87887 | { |
87577 | - state.addr = 18446744073709546019LLU; // 99999998mh''''''''''''''' | |
87888 | + state.addr = 18446744073709546004LLU; // 99999998mT''''''''''''''' | |
87578 | 87889 | break; |
87579 | 87890 | } |
87580 | - case 18446744073709546019LLU: // 99999998mh''''''''''''''' | |
87891 | + case 18446744073709546004LLU: // 99999998mT''''''''''''''' | |
87581 | 87892 | { |
87582 | 87893 | { |
87583 | 87894 | uint64_t arg = 0; |
@@ -87656,7 +87967,7 @@ | ||
87656 | 87967 | LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
87657 | 87968 | } |
87658 | 87969 | // ACCUMULATE ARGUMENTS - END |
87659 | - uint64_t return_to = 18446744073709546016LLU; | |
87970 | + uint64_t return_to = 18446744073709546001LLU; | |
87660 | 87971 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)); |
87661 | 87972 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
87662 | 87973 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -87665,12 +87976,12 @@ | ||
87665 | 87976 | state.addr = 787472342492567585LLU; // procvarref |
87666 | 87977 | break; |
87667 | 87978 | } |
87668 | - case 18446744073709546016LLU: // 99999998me''''''''''''''' | |
87979 | + case 18446744073709546001LLU: // 99999998mQ''''''''''''''' | |
87669 | 87980 | { |
87670 | - state.addr = 18446744073709546017LLU; // 99999998mf''''''''''''''' | |
87981 | + state.addr = 18446744073709546002LLU; // 99999998mR''''''''''''''' | |
87671 | 87982 | break; |
87672 | 87983 | } |
87673 | - case 18446744073709546017LLU: // 99999998mf''''''''''''''' | |
87984 | + case 18446744073709546002LLU: // 99999998mR''''''''''''''' | |
87674 | 87985 | { |
87675 | 87986 | // variable u64 initialize goes out of scope |
87676 | 87987 | // emitted destructur for type u64 |
@@ -87681,10 +87992,10 @@ | ||
87681 | 87992 | // variable u64 idx_______ goes out of scope |
87682 | 87993 | // emitted destructur for type u64 |
87683 | 87994 | (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference idx_______ at 20 |
87684 | - state.addr = 18446744073709546024LLU; // 99999998mm''''''''''''''' | |
87995 | + state.addr = 18446744073709546009LLU; // 99999998mY''''''''''''''' | |
87685 | 87996 | break; |
87686 | 87997 | } |
87687 | - case 18446744073709546024LLU: // 99999998mm''''''''''''''' | |
87998 | + case 18446744073709546009LLU: // 99999998mY''''''''''''''' | |
87688 | 87999 | { |
87689 | 88000 | fprintf(stdout, "%s", ");"); |
87690 | 88001 | // ACCUMULATE ARGUMENTS - BEGIN |
@@ -87693,7 +88004,7 @@ | ||
87693 | 88004 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
87694 | 88005 | } |
87695 | 88006 | // ACCUMULATE ARGUMENTS - END |
87696 | - uint64_t return_to = 18446744073709546014LLU; | |
88007 | + uint64_t return_to = 18446744073709545999LLU; | |
87697 | 88008 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
87698 | 88009 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
87699 | 88010 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -87702,12 +88013,12 @@ | ||
87702 | 88013 | state.addr = 839519719621918720LLU; // skipws____ |
87703 | 88014 | break; |
87704 | 88015 | } |
87705 | - case 18446744073709546014LLU: // 99999998mc''''''''''''''' | |
88016 | + case 18446744073709545999LLU: // 99999998mO''''''''''''''' | |
87706 | 88017 | { |
87707 | - state.addr = 18446744073709546015LLU; // 99999998md''''''''''''''' | |
88018 | + state.addr = 18446744073709546000LLU; // 99999998mP''''''''''''''' | |
87708 | 88019 | break; |
87709 | 88020 | } |
87710 | - case 18446744073709546015LLU: // 99999998md''''''''''''''' | |
88021 | + case 18446744073709546000LLU: // 99999998mP''''''''''''''' | |
87711 | 88022 | { |
87712 | 88023 | ungetc((int)/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 7LLU)), stdin); |
87713 | 88024 | if(')' != (char)getchar()) |
@@ -87725,7 +88036,7 @@ | ||
87725 | 88036 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
87726 | 88037 | } |
87727 | 88038 | // ACCUMULATE ARGUMENTS - END |
87728 | - uint64_t return_to = 18446744073709546012LLU; | |
88039 | + uint64_t return_to = 18446744073709545997LLU; | |
87729 | 88040 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
87730 | 88041 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
87731 | 88042 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -87734,12 +88045,12 @@ | ||
87734 | 88045 | state.addr = 517555565476695680LLU; // assertu64_ |
87735 | 88046 | break; |
87736 | 88047 | } |
87737 | - case 18446744073709546012LLU: // 99999998ma''''''''''''''' | |
88048 | + case 18446744073709545997LLU: // 99999998mM''''''''''''''' | |
87738 | 88049 | { |
87739 | - state.addr = 18446744073709546013LLU; // 99999998mb''''''''''''''' | |
88050 | + state.addr = 18446744073709545998LLU; // 99999998mN''''''''''''''' | |
87740 | 88051 | break; |
87741 | 88052 | } |
87742 | - case 18446744073709546013LLU: // 99999998mb''''''''''''''' | |
88053 | + case 18446744073709545998LLU: // 99999998mN''''''''''''''' | |
87743 | 88054 | { |
87744 | 88055 | // variable u64 mutable___ goes out of scope |
87745 | 88056 | // emitted destructur for type u64 |
@@ -87752,7 +88063,7 @@ | ||
87752 | 88063 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
87753 | 88064 | } |
87754 | 88065 | // ACCUMULATE ARGUMENTS - END |
87755 | - uint64_t return_to = 18446744073709546011LLU; | |
88066 | + uint64_t return_to = 18446744073709545996LLU; | |
87756 | 88067 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
87757 | 88068 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
87758 | 88069 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -87761,7 +88072,7 @@ | ||
87761 | 88072 | state.addr = 18446744073709551534LLU; // 999999998s''''''''''''''' |
87762 | 88073 | break; |
87763 | 88074 | } |
87764 | - case 18446744073709546011LLU: // 99999998m$''''''''''''''' | |
88075 | + case 18446744073709545996LLU: // 99999998mL''''''''''''''' | |
87765 | 88076 | { |
87766 | 88077 | (void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type______ at 18 |
87767 | 88078 | // variable u64 INDIRECT__ goes out of scope |
@@ -87772,34 +88083,34 @@ | ||
87772 | 88083 | (void)LOCAL_POP_MOVE(&heap, 16LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id________ at 16 |
87773 | 88084 | heap.availilable_size_for_dynamic_objects += 0LLU; |
87774 | 88085 | heap.availilable_size_for_dynamic_objects += 0LLU; |
87775 | - state.addr = 18446744073709546010LLU; // 99999998mZ''''''''''''''' | |
88086 | + state.addr = 18446744073709545995LLU; // 99999998mK''''''''''''''' | |
87776 | 88087 | break; |
87777 | 88088 | } |
87778 | - case 18446744073709546029LLU: // 99999998mr''''''''''''''' | |
88089 | + case 18446744073709546014LLU: // 99999998mc''''''''''''''' | |
87779 | 88090 | { |
87780 | 88091 | |
87781 | - state.addr = 18446744073709546009LLU; // 99999998mY''''''''''''''' | |
88092 | + state.addr = 18446744073709545994LLU; // 99999998mJ''''''''''''''' | |
87782 | 88093 | break; |
87783 | 88094 | } |
87784 | - case 18446744073709546009LLU: // 99999998mY''''''''''''''' | |
88095 | + case 18446744073709545994LLU: // 99999998mJ''''''''''''''' | |
87785 | 88096 | { |
87786 | 88097 | *LOCAL_ACCESS(heap.data, 15LLU, 14LLU) = 660190761781821440; |
87787 | 88098 | |
87788 | - state.addr = 18446744073709546008LLU; // 99999998mX''''''''''''''' | |
88099 | + state.addr = 18446744073709545993LLU; // 99999998mI''''''''''''''' | |
87789 | 88100 | break; |
87790 | 88101 | } |
87791 | - case 18446744073709546008LLU: // 99999998mX''''''''''''''' | |
88102 | + case 18446744073709545993LLU: // 99999998mI''''''''''''''' | |
87792 | 88103 | { |
87793 | 88104 | *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) = /*sym_______*/*LOCAL_ACCESS(heap.data, 15LLU, 14LLU) == /*callee_id_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 6LLU)); |
87794 | - state.addr = 18446744073709546007LLU; // 99999998mW''''''''''''''' | |
88105 | + state.addr = 18446744073709545992LLU; // 99999998mH''''''''''''''' | |
87795 | 88106 | break; |
87796 | 88107 | } |
87797 | - case 18446744073709546007LLU: // 99999998mW''''''''''''''' | |
88108 | + case 18446744073709545992LLU: // 99999998mH''''''''''''''' | |
87798 | 88109 | { |
87799 | - state.addr = *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709546006LLU : 18446744073709546005LLU; | |
88110 | + state.addr = *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709545991LLU : 18446744073709545990LLU; | |
87800 | 88111 | break; |
87801 | 88112 | } |
87802 | - case 18446744073709546006LLU: // 99999998mV''''''''''''''' | |
88113 | + case 18446744073709545991LLU: // 99999998mG''''''''''''''' | |
87803 | 88114 | { |
87804 | 88115 | { |
87805 | 88116 | uint64_t arg = 0; |
@@ -87821,7 +88132,7 @@ | ||
87821 | 88132 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
87822 | 88133 | } |
87823 | 88134 | // ACCUMULATE ARGUMENTS - END |
87824 | - uint64_t return_to = 18446744073709546003LLU; | |
88135 | + uint64_t return_to = 18446744073709545988LLU; | |
87825 | 88136 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
87826 | 88137 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
87827 | 88138 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -87830,12 +88141,12 @@ | ||
87830 | 88141 | state.addr = 861504796319285248LLU; // typeu64___ |
87831 | 88142 | break; |
87832 | 88143 | } |
87833 | - case 18446744073709546003LLU: // 99999998mS''''''''''''''' | |
88144 | + case 18446744073709545988LLU: // 99999998mD''''''''''''''' | |
87834 | 88145 | { |
87835 | - state.addr = 18446744073709546004LLU; // 99999998mT''''''''''''''' | |
88146 | + state.addr = 18446744073709545989LLU; // 99999998mE''''''''''''''' | |
87836 | 88147 | break; |
87837 | 88148 | } |
87838 | - case 18446744073709546004LLU: // 99999998mT''''''''''''''' | |
88149 | + case 18446744073709545989LLU: // 99999998mE''''''''''''''' | |
87839 | 88150 | { |
87840 | 88151 | // ACCUMULATE ARGUMENTS - BEGIN |
87841 | 88152 | { |
@@ -87843,7 +88154,7 @@ | ||
87843 | 88154 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
87844 | 88155 | } |
87845 | 88156 | // ACCUMULATE ARGUMENTS - END |
87846 | - uint64_t return_to = 18446744073709546001LLU; | |
88157 | + uint64_t return_to = 18446744073709545986LLU; | |
87847 | 88158 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
87848 | 88159 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
87849 | 88160 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -87852,12 +88163,12 @@ | ||
87852 | 88163 | state.addr = 839519719621918720LLU; // skipws____ |
87853 | 88164 | break; |
87854 | 88165 | } |
87855 | - case 18446744073709546001LLU: // 99999998mQ''''''''''''''' | |
88166 | + case 18446744073709545986LLU: // 99999998mB''''''''''''''' | |
87856 | 88167 | { |
87857 | - state.addr = 18446744073709546002LLU; // 99999998mR''''''''''''''' | |
88168 | + state.addr = 18446744073709545987LLU; // 99999998mC''''''''''''''' | |
87858 | 88169 | break; |
87859 | 88170 | } |
87860 | - case 18446744073709546002LLU: // 99999998mR''''''''''''''' | |
88171 | + case 18446744073709545987LLU: // 99999998mC''''''''''''''' | |
87861 | 88172 | { |
87862 | 88173 | matchid("(", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 18LLU, 7LLU))); |
87863 | 88174 | fprintf(stdout, "%s", "\n ++"); |
@@ -87872,7 +88183,7 @@ | ||
87872 | 88183 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
87873 | 88184 | } |
87874 | 88185 | // ACCUMULATE ARGUMENTS - END |
87875 | - uint64_t return_to = 18446744073709545998LLU; | |
88186 | + uint64_t return_to = 18446744073709545983LLU; | |
87876 | 88187 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
87877 | 88188 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
87878 | 88189 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -87881,24 +88192,24 @@ | ||
87881 | 88192 | state.addr = 839519719621918720LLU; // skipws____ |
87882 | 88193 | break; |
87883 | 88194 | } |
87884 | - case 18446744073709545998LLU: // 99999998mN''''''''''''''' | |
88195 | + case 18446744073709545983LLU: // 99999998l9''''''''''''''' | |
87885 | 88196 | { |
87886 | - state.addr = 18446744073709545999LLU; // 99999998mO''''''''''''''' | |
88197 | + state.addr = 18446744073709545984LLU; // 99999998m_''''''''''''''' | |
87887 | 88198 | break; |
87888 | 88199 | } |
87889 | - case 18446744073709545999LLU: // 99999998mO''''''''''''''' | |
88200 | + case 18446744073709545984LLU: // 99999998m_''''''''''''''' | |
87890 | 88201 | { |
87891 | 88202 | |
87892 | - state.addr = 18446744073709545997LLU; // 99999998mM''''''''''''''' | |
88203 | + state.addr = 18446744073709545982LLU; // 99999998l8''''''''''''''' | |
87893 | 88204 | break; |
87894 | 88205 | } |
87895 | - case 18446744073709545997LLU: // 99999998mM''''''''''''''' | |
88206 | + case 18446744073709545982LLU: // 99999998l8''''''''''''''' | |
87896 | 88207 | { |
87897 | 88208 | *LOCAL_ACCESS(heap.data, 19LLU, 15LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 7LLU))); |
87898 | - state.addr = 18446744073709545996LLU; // 99999998mL''''''''''''''' | |
88209 | + state.addr = 18446744073709545981LLU; // 99999998l7''''''''''''''' | |
87899 | 88210 | break; |
87900 | 88211 | } |
87901 | - case 18446744073709545996LLU: // 99999998mL''''''''''''''' | |
88212 | + case 18446744073709545981LLU: // 99999998l7''''''''''''''' | |
87902 | 88213 | { |
87903 | 88214 | // ACCUMULATE ARGUMENTS - BEGIN |
87904 | 88215 | { |
@@ -87918,7 +88229,7 @@ | ||
87918 | 88229 | LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
87919 | 88230 | } |
87920 | 88231 | // ACCUMULATE ARGUMENTS - END |
87921 | - uint64_t return_to = 18446744073709545994LLU; | |
88232 | + uint64_t return_to = 18446744073709545979LLU; | |
87922 | 88233 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
87923 | 88234 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
87924 | 88235 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -87927,12 +88238,12 @@ | ||
87927 | 88238 | state.addr = 517555565473470767LLU; // assertinit |
87928 | 88239 | break; |
87929 | 88240 | } |
87930 | - case 18446744073709545994LLU: // 99999998mJ''''''''''''''' | |
88241 | + case 18446744073709545979LLU: // 99999998l5''''''''''''''' | |
87931 | 88242 | { |
87932 | - state.addr = 18446744073709545995LLU; // 99999998mK''''''''''''''' | |
88243 | + state.addr = 18446744073709545980LLU; // 99999998l6''''''''''''''' | |
87933 | 88244 | break; |
87934 | 88245 | } |
87935 | - case 18446744073709545995LLU: // 99999998mK''''''''''''''' | |
88246 | + case 18446744073709545980LLU: // 99999998l6''''''''''''''' | |
87936 | 88247 | { |
87937 | 88248 | { |
87938 | 88249 | uint64_t arg = 0; |
@@ -88011,7 +88322,7 @@ | ||
88011 | 88322 | LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
88012 | 88323 | } |
88013 | 88324 | // ACCUMULATE ARGUMENTS - END |
88014 | - uint64_t return_to = 18446744073709545992LLU; | |
88325 | + uint64_t return_to = 18446744073709545977LLU; | |
88015 | 88326 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)); |
88016 | 88327 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
88017 | 88328 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -88020,12 +88331,12 @@ | ||
88020 | 88331 | state.addr = 787472342492567585LLU; // procvarref |
88021 | 88332 | break; |
88022 | 88333 | } |
88023 | - case 18446744073709545992LLU: // 99999998mH''''''''''''''' | |
88334 | + case 18446744073709545977LLU: // 99999998l3''''''''''''''' | |
88024 | 88335 | { |
88025 | - state.addr = 18446744073709545993LLU; // 99999998mI''''''''''''''' | |
88336 | + state.addr = 18446744073709545978LLU; // 99999998l4''''''''''''''' | |
88026 | 88337 | break; |
88027 | 88338 | } |
88028 | - case 18446744073709545993LLU: // 99999998mI''''''''''''''' | |
88339 | + case 18446744073709545978LLU: // 99999998l4''''''''''''''' | |
88029 | 88340 | { |
88030 | 88341 | // variable u64 initialize goes out of scope |
88031 | 88342 | // emitted destructur for type u64 |
@@ -88036,10 +88347,10 @@ | ||
88036 | 88347 | // variable u64 idx_______ goes out of scope |
88037 | 88348 | // emitted destructur for type u64 |
88038 | 88349 | (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference idx_______ at 20 |
88039 | - state.addr = 18446744073709546000LLU; // 99999998mP''''''''''''''' | |
88350 | + state.addr = 18446744073709545985LLU; // 99999998mA''''''''''''''' | |
88040 | 88351 | break; |
88041 | 88352 | } |
88042 | - case 18446744073709546000LLU: // 99999998mP''''''''''''''' | |
88353 | + case 18446744073709545985LLU: // 99999998mA''''''''''''''' | |
88043 | 88354 | { |
88044 | 88355 | fprintf(stdout, "%s", ";"); |
88045 | 88356 | // ACCUMULATE ARGUMENTS - BEGIN |
@@ -88048,7 +88359,7 @@ | ||
88048 | 88359 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
88049 | 88360 | } |
88050 | 88361 | // ACCUMULATE ARGUMENTS - END |
88051 | - uint64_t return_to = 18446744073709545990LLU; | |
88362 | + uint64_t return_to = 18446744073709545975LLU; | |
88052 | 88363 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
88053 | 88364 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
88054 | 88365 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -88057,12 +88368,12 @@ | ||
88057 | 88368 | state.addr = 839519719621918720LLU; // skipws____ |
88058 | 88369 | break; |
88059 | 88370 | } |
88060 | - case 18446744073709545990LLU: // 99999998mF''''''''''''''' | |
88371 | + case 18446744073709545975LLU: // 99999998l1''''''''''''''' | |
88061 | 88372 | { |
88062 | - state.addr = 18446744073709545991LLU; // 99999998mG''''''''''''''' | |
88373 | + state.addr = 18446744073709545976LLU; // 99999998l2''''''''''''''' | |
88063 | 88374 | break; |
88064 | 88375 | } |
88065 | - case 18446744073709545991LLU: // 99999998mG''''''''''''''' | |
88376 | + case 18446744073709545976LLU: // 99999998l2''''''''''''''' | |
88066 | 88377 | { |
88067 | 88378 | ungetc((int)/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 7LLU)), stdin); |
88068 | 88379 | if(')' != (char)getchar()) |
@@ -88080,7 +88391,7 @@ | ||
88080 | 88391 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
88081 | 88392 | } |
88082 | 88393 | // ACCUMULATE ARGUMENTS - END |
88083 | - uint64_t return_to = 18446744073709545988LLU; | |
88394 | + uint64_t return_to = 18446744073709545973LLU; | |
88084 | 88395 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
88085 | 88396 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
88086 | 88397 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -88089,12 +88400,12 @@ | ||
88089 | 88400 | state.addr = 517555565476695680LLU; // assertu64_ |
88090 | 88401 | break; |
88091 | 88402 | } |
88092 | - case 18446744073709545988LLU: // 99999998mD''''''''''''''' | |
88403 | + case 18446744073709545973LLU: // 99999998lz''''''''''''''' | |
88093 | 88404 | { |
88094 | - state.addr = 18446744073709545989LLU; // 99999998mE''''''''''''''' | |
88405 | + state.addr = 18446744073709545974LLU; // 99999998l0''''''''''''''' | |
88095 | 88406 | break; |
88096 | 88407 | } |
88097 | - case 18446744073709545989LLU: // 99999998mE''''''''''''''' | |
88408 | + case 18446744073709545974LLU: // 99999998l0''''''''''''''' | |
88098 | 88409 | { |
88099 | 88410 | { |
88100 | 88411 | uint64_t arg = 0; |
@@ -88123,7 +88434,7 @@ | ||
88123 | 88434 | LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
88124 | 88435 | } |
88125 | 88436 | // ACCUMULATE ARGUMENTS - END |
88126 | - uint64_t return_to = 18446744073709545985LLU; | |
88437 | + uint64_t return_to = 18446744073709545970LLU; | |
88127 | 88438 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)); |
88128 | 88439 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
88129 | 88440 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -88132,20 +88443,20 @@ | ||
88132 | 88443 | state.addr = 734295421765213120LLU; // mutassert_ |
88133 | 88444 | break; |
88134 | 88445 | } |
88135 | - case 18446744073709545985LLU: // 99999998mA''''''''''''''' | |
88446 | + case 18446744073709545970LLU: // 99999998lw''''''''''''''' | |
88136 | 88447 | { |
88137 | - state.addr = 18446744073709545986LLU; // 99999998mB''''''''''''''' | |
88448 | + state.addr = 18446744073709545971LLU; // 99999998lx''''''''''''''' | |
88138 | 88449 | break; |
88139 | 88450 | } |
88140 | - case 18446744073709545986LLU: // 99999998mB''''''''''''''' | |
88451 | + case 18446744073709545971LLU: // 99999998lx''''''''''''''' | |
88141 | 88452 | { |
88142 | 88453 | // variable u64 parnr_____ goes out of scope |
88143 | 88454 | // emitted destructur for type u64 |
88144 | 88455 | (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference parnr_____ at 20 |
88145 | - state.addr = 18446744073709545987LLU; // 99999998mC''''''''''''''' | |
88456 | + state.addr = 18446744073709545972LLU; // 99999998ly''''''''''''''' | |
88146 | 88457 | break; |
88147 | 88458 | } |
88148 | - case 18446744073709545987LLU: // 99999998mC''''''''''''''' | |
88459 | + case 18446744073709545972LLU: // 99999998ly''''''''''''''' | |
88149 | 88460 | { |
88150 | 88461 | // variable u64 mutable___ goes out of scope |
88151 | 88462 | // emitted destructur for type u64 |
@@ -88158,7 +88469,7 @@ | ||
88158 | 88469 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
88159 | 88470 | } |
88160 | 88471 | // ACCUMULATE ARGUMENTS - END |
88161 | - uint64_t return_to = 18446744073709545984LLU; | |
88472 | + uint64_t return_to = 18446744073709545969LLU; | |
88162 | 88473 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
88163 | 88474 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
88164 | 88475 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -88167,7 +88478,7 @@ | ||
88167 | 88478 | state.addr = 18446744073709551534LLU; // 999999998s''''''''''''''' |
88168 | 88479 | break; |
88169 | 88480 | } |
88170 | - case 18446744073709545984LLU: // 99999998m_''''''''''''''' | |
88481 | + case 18446744073709545969LLU: // 99999998lv''''''''''''''' | |
88171 | 88482 | { |
88172 | 88483 | (void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type______ at 18 |
88173 | 88484 | // variable u64 INDIRECT__ goes out of scope |
@@ -88178,34 +88489,34 @@ | ||
88178 | 88489 | (void)LOCAL_POP_MOVE(&heap, 16LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id________ at 16 |
88179 | 88490 | heap.availilable_size_for_dynamic_objects += 0LLU; |
88180 | 88491 | heap.availilable_size_for_dynamic_objects += 0LLU; |
88181 | - state.addr = 18446744073709545983LLU; // 99999998l9''''''''''''''' | |
88492 | + state.addr = 18446744073709545968LLU; // 99999998lu''''''''''''''' | |
88182 | 88493 | break; |
88183 | 88494 | } |
88184 | - case 18446744073709546005LLU: // 99999998mU''''''''''''''' | |
88495 | + case 18446744073709545990LLU: // 99999998mF''''''''''''''' | |
88185 | 88496 | { |
88186 | 88497 | |
88187 | - state.addr = 18446744073709545982LLU; // 99999998l8''''''''''''''' | |
88498 | + state.addr = 18446744073709545967LLU; // 99999998lt''''''''''''''' | |
88188 | 88499 | break; |
88189 | 88500 | } |
88190 | - case 18446744073709545982LLU: // 99999998l8''''''''''''''' | |
88501 | + case 18446744073709545967LLU: // 99999998lt''''''''''''''' | |
88191 | 88502 | { |
88192 | 88503 | *LOCAL_ACCESS(heap.data, 15LLU, 14LLU) = 567585494444015616; |
88193 | 88504 | |
88194 | - state.addr = 18446744073709545981LLU; // 99999998l7''''''''''''''' | |
88505 | + state.addr = 18446744073709545966LLU; // 99999998ls''''''''''''''' | |
88195 | 88506 | break; |
88196 | 88507 | } |
88197 | - case 18446744073709545981LLU: // 99999998l7''''''''''''''' | |
88508 | + case 18446744073709545966LLU: // 99999998ls''''''''''''''' | |
88198 | 88509 | { |
88199 | 88510 | *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) = /*sym_______*/*LOCAL_ACCESS(heap.data, 15LLU, 14LLU) == /*callee_id_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 6LLU)); |
88200 | - state.addr = 18446744073709545980LLU; // 99999998l6''''''''''''''' | |
88511 | + state.addr = 18446744073709545965LLU; // 99999998lr''''''''''''''' | |
88201 | 88512 | break; |
88202 | 88513 | } |
88203 | - case 18446744073709545980LLU: // 99999998l6''''''''''''''' | |
88514 | + case 18446744073709545965LLU: // 99999998lr''''''''''''''' | |
88204 | 88515 | { |
88205 | - state.addr = *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709545979LLU : 18446744073709545978LLU; | |
88516 | + state.addr = *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 15LLU, 0LLU)) ? 18446744073709545964LLU : 18446744073709545963LLU; | |
88206 | 88517 | break; |
88207 | 88518 | } |
88208 | - case 18446744073709545979LLU: // 99999998l5''''''''''''''' | |
88519 | + case 18446744073709545964LLU: // 99999998lq''''''''''''''' | |
88209 | 88520 | { |
88210 | 88521 | { |
88211 | 88522 | uint64_t arg = 0; |
@@ -88227,7 +88538,7 @@ | ||
88227 | 88538 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
88228 | 88539 | } |
88229 | 88540 | // ACCUMULATE ARGUMENTS - END |
88230 | - uint64_t return_to = 18446744073709545976LLU; | |
88541 | + uint64_t return_to = 18446744073709545961LLU; | |
88231 | 88542 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
88232 | 88543 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
88233 | 88544 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -88236,12 +88547,12 @@ | ||
88236 | 88547 | state.addr = 861504796319285248LLU; // typeu64___ |
88237 | 88548 | break; |
88238 | 88549 | } |
88239 | - case 18446744073709545976LLU: // 99999998l2''''''''''''''' | |
88550 | + case 18446744073709545961LLU: // 99999998ln''''''''''''''' | |
88240 | 88551 | { |
88241 | - state.addr = 18446744073709545977LLU; // 99999998l3''''''''''''''' | |
88552 | + state.addr = 18446744073709545962LLU; // 99999998lo''''''''''''''' | |
88242 | 88553 | break; |
88243 | 88554 | } |
88244 | - case 18446744073709545977LLU: // 99999998l3''''''''''''''' | |
88555 | + case 18446744073709545962LLU: // 99999998lo''''''''''''''' | |
88245 | 88556 | { |
88246 | 88557 | // ACCUMULATE ARGUMENTS - BEGIN |
88247 | 88558 | { |
@@ -88249,7 +88560,7 @@ | ||
88249 | 88560 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
88250 | 88561 | } |
88251 | 88562 | // ACCUMULATE ARGUMENTS - END |
88252 | - uint64_t return_to = 18446744073709545974LLU; | |
88563 | + uint64_t return_to = 18446744073709545959LLU; | |
88253 | 88564 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
88254 | 88565 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
88255 | 88566 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -88258,12 +88569,12 @@ | ||
88258 | 88569 | state.addr = 839519719621918720LLU; // skipws____ |
88259 | 88570 | break; |
88260 | 88571 | } |
88261 | - case 18446744073709545974LLU: // 99999998l0''''''''''''''' | |
88572 | + case 18446744073709545959LLU: // 99999998ll''''''''''''''' | |
88262 | 88573 | { |
88263 | - state.addr = 18446744073709545975LLU; // 99999998l1''''''''''''''' | |
88574 | + state.addr = 18446744073709545960LLU; // 99999998lm''''''''''''''' | |
88264 | 88575 | break; |
88265 | 88576 | } |
88266 | - case 18446744073709545975LLU: // 99999998l1''''''''''''''' | |
88577 | + case 18446744073709545960LLU: // 99999998lm''''''''''''''' | |
88267 | 88578 | { |
88268 | 88579 | matchid("(", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 18LLU, 7LLU))); |
88269 | 88580 | fprintf(stdout, "%s", "\n --"); |
@@ -88278,7 +88589,7 @@ | ||
88278 | 88589 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
88279 | 88590 | } |
88280 | 88591 | // ACCUMULATE ARGUMENTS - END |
88281 | - uint64_t return_to = 18446744073709545971LLU; | |
88592 | + uint64_t return_to = 18446744073709545956LLU; | |
88282 | 88593 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
88283 | 88594 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
88284 | 88595 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -88287,24 +88598,24 @@ | ||
88287 | 88598 | state.addr = 839519719621918720LLU; // skipws____ |
88288 | 88599 | break; |
88289 | 88600 | } |
88290 | - case 18446744073709545971LLU: // 99999998lx''''''''''''''' | |
88601 | + case 18446744073709545956LLU: // 99999998li''''''''''''''' | |
88291 | 88602 | { |
88292 | - state.addr = 18446744073709545972LLU; // 99999998ly''''''''''''''' | |
88603 | + state.addr = 18446744073709545957LLU; // 99999998lj''''''''''''''' | |
88293 | 88604 | break; |
88294 | 88605 | } |
88295 | - case 18446744073709545972LLU: // 99999998ly''''''''''''''' | |
88606 | + case 18446744073709545957LLU: // 99999998lj''''''''''''''' | |
88296 | 88607 | { |
88297 | 88608 | |
88298 | - state.addr = 18446744073709545970LLU; // 99999998lw''''''''''''''' | |
88609 | + state.addr = 18446744073709545955LLU; // 99999998lh''''''''''''''' | |
88299 | 88610 | break; |
88300 | 88611 | } |
88301 | - case 18446744073709545970LLU: // 99999998lw''''''''''''''' | |
88612 | + case 18446744073709545955LLU: // 99999998lh''''''''''''''' | |
88302 | 88613 | { |
88303 | 88614 | *LOCAL_ACCESS(heap.data, 19LLU, 15LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 7LLU))); |
88304 | - state.addr = 18446744073709545969LLU; // 99999998lv''''''''''''''' | |
88615 | + state.addr = 18446744073709545954LLU; // 99999998lg''''''''''''''' | |
88305 | 88616 | break; |
88306 | 88617 | } |
88307 | - case 18446744073709545969LLU: // 99999998lv''''''''''''''' | |
88618 | + case 18446744073709545954LLU: // 99999998lg''''''''''''''' | |
88308 | 88619 | { |
88309 | 88620 | // ACCUMULATE ARGUMENTS - BEGIN |
88310 | 88621 | { |
@@ -88324,7 +88635,7 @@ | ||
88324 | 88635 | LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
88325 | 88636 | } |
88326 | 88637 | // ACCUMULATE ARGUMENTS - END |
88327 | - uint64_t return_to = 18446744073709545967LLU; | |
88638 | + uint64_t return_to = 18446744073709545952LLU; | |
88328 | 88639 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
88329 | 88640 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
88330 | 88641 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -88333,12 +88644,12 @@ | ||
88333 | 88644 | state.addr = 517555565473470767LLU; // assertinit |
88334 | 88645 | break; |
88335 | 88646 | } |
88336 | - case 18446744073709545967LLU: // 99999998lt''''''''''''''' | |
88647 | + case 18446744073709545952LLU: // 99999998le''''''''''''''' | |
88337 | 88648 | { |
88338 | - state.addr = 18446744073709545968LLU; // 99999998lu''''''''''''''' | |
88649 | + state.addr = 18446744073709545953LLU; // 99999998lf''''''''''''''' | |
88339 | 88650 | break; |
88340 | 88651 | } |
88341 | - case 18446744073709545968LLU: // 99999998lu''''''''''''''' | |
88652 | + case 18446744073709545953LLU: // 99999998lf''''''''''''''' | |
88342 | 88653 | { |
88343 | 88654 | { |
88344 | 88655 | uint64_t arg = 0; |
@@ -88417,7 +88728,7 @@ | ||
88417 | 88728 | LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
88418 | 88729 | } |
88419 | 88730 | // ACCUMULATE ARGUMENTS - END |
88420 | - uint64_t return_to = 18446744073709545965LLU; | |
88731 | + uint64_t return_to = 18446744073709545950LLU; | |
88421 | 88732 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)); |
88422 | 88733 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
88423 | 88734 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -88426,12 +88737,12 @@ | ||
88426 | 88737 | state.addr = 787472342492567585LLU; // procvarref |
88427 | 88738 | break; |
88428 | 88739 | } |
88429 | - case 18446744073709545965LLU: // 99999998lr''''''''''''''' | |
88740 | + case 18446744073709545950LLU: // 99999998lc''''''''''''''' | |
88430 | 88741 | { |
88431 | - state.addr = 18446744073709545966LLU; // 99999998ls''''''''''''''' | |
88742 | + state.addr = 18446744073709545951LLU; // 99999998ld''''''''''''''' | |
88432 | 88743 | break; |
88433 | 88744 | } |
88434 | - case 18446744073709545966LLU: // 99999998ls''''''''''''''' | |
88745 | + case 18446744073709545951LLU: // 99999998ld''''''''''''''' | |
88435 | 88746 | { |
88436 | 88747 | // variable u64 initialize goes out of scope |
88437 | 88748 | // emitted destructur for type u64 |
@@ -88442,10 +88753,10 @@ | ||
88442 | 88753 | // variable u64 idx_______ goes out of scope |
88443 | 88754 | // emitted destructur for type u64 |
88444 | 88755 | (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference idx_______ at 20 |
88445 | - state.addr = 18446744073709545973LLU; // 99999998lz''''''''''''''' | |
88756 | + state.addr = 18446744073709545958LLU; // 99999998lk''''''''''''''' | |
88446 | 88757 | break; |
88447 | 88758 | } |
88448 | - case 18446744073709545973LLU: // 99999998lz''''''''''''''' | |
88759 | + case 18446744073709545958LLU: // 99999998lk''''''''''''''' | |
88449 | 88760 | { |
88450 | 88761 | fprintf(stdout, "%s", ";"); |
88451 | 88762 | // ACCUMULATE ARGUMENTS - BEGIN |
@@ -88454,7 +88765,7 @@ | ||
88454 | 88765 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
88455 | 88766 | } |
88456 | 88767 | // ACCUMULATE ARGUMENTS - END |
88457 | - uint64_t return_to = 18446744073709545963LLU; | |
88768 | + uint64_t return_to = 18446744073709545948LLU; | |
88458 | 88769 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
88459 | 88770 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
88460 | 88771 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -88463,12 +88774,12 @@ | ||
88463 | 88774 | state.addr = 839519719621918720LLU; // skipws____ |
88464 | 88775 | break; |
88465 | 88776 | } |
88466 | - case 18446744073709545963LLU: // 99999998lp''''''''''''''' | |
88777 | + case 18446744073709545948LLU: // 99999998la''''''''''''''' | |
88467 | 88778 | { |
88468 | - state.addr = 18446744073709545964LLU; // 99999998lq''''''''''''''' | |
88779 | + state.addr = 18446744073709545949LLU; // 99999998lb''''''''''''''' | |
88469 | 88780 | break; |
88470 | 88781 | } |
88471 | - case 18446744073709545964LLU: // 99999998lq''''''''''''''' | |
88782 | + case 18446744073709545949LLU: // 99999998lb''''''''''''''' | |
88472 | 88783 | { |
88473 | 88784 | ungetc((int)/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 7LLU)), stdin); |
88474 | 88785 | if(')' != (char)getchar()) |
@@ -88486,7 +88797,7 @@ | ||
88486 | 88797 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
88487 | 88798 | } |
88488 | 88799 | // ACCUMULATE ARGUMENTS - END |
88489 | - uint64_t return_to = 18446744073709545961LLU; | |
88800 | + uint64_t return_to = 18446744073709545946LLU; | |
88490 | 88801 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
88491 | 88802 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
88492 | 88803 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -88495,12 +88806,12 @@ | ||
88495 | 88806 | state.addr = 517555565476695680LLU; // assertu64_ |
88496 | 88807 | break; |
88497 | 88808 | } |
88498 | - case 18446744073709545961LLU: // 99999998ln''''''''''''''' | |
88809 | + case 18446744073709545946LLU: // 99999998lZ''''''''''''''' | |
88499 | 88810 | { |
88500 | - state.addr = 18446744073709545962LLU; // 99999998lo''''''''''''''' | |
88811 | + state.addr = 18446744073709545947LLU; // 99999998l$''''''''''''''' | |
88501 | 88812 | break; |
88502 | 88813 | } |
88503 | - case 18446744073709545962LLU: // 99999998lo''''''''''''''' | |
88814 | + case 18446744073709545947LLU: // 99999998l$''''''''''''''' | |
88504 | 88815 | { |
88505 | 88816 | { |
88506 | 88817 | uint64_t arg = 0; |
@@ -88529,7 +88840,7 @@ | ||
88529 | 88840 | LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
88530 | 88841 | } |
88531 | 88842 | // ACCUMULATE ARGUMENTS - END |
88532 | - uint64_t return_to = 18446744073709545958LLU; | |
88843 | + uint64_t return_to = 18446744073709545943LLU; | |
88533 | 88844 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)); |
88534 | 88845 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
88535 | 88846 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -88538,20 +88849,20 @@ | ||
88538 | 88849 | state.addr = 734295421765213120LLU; // mutassert_ |
88539 | 88850 | break; |
88540 | 88851 | } |
88541 | - case 18446744073709545958LLU: // 99999998lk''''''''''''''' | |
88852 | + case 18446744073709545943LLU: // 99999998lW''''''''''''''' | |
88542 | 88853 | { |
88543 | - state.addr = 18446744073709545959LLU; // 99999998ll''''''''''''''' | |
88854 | + state.addr = 18446744073709545944LLU; // 99999998lX''''''''''''''' | |
88544 | 88855 | break; |
88545 | 88856 | } |
88546 | - case 18446744073709545959LLU: // 99999998ll''''''''''''''' | |
88857 | + case 18446744073709545944LLU: // 99999998lX''''''''''''''' | |
88547 | 88858 | { |
88548 | 88859 | // variable u64 parnr_____ goes out of scope |
88549 | 88860 | // emitted destructur for type u64 |
88550 | 88861 | (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference parnr_____ at 20 |
88551 | - state.addr = 18446744073709545960LLU; // 99999998lm''''''''''''''' | |
88862 | + state.addr = 18446744073709545945LLU; // 99999998lY''''''''''''''' | |
88552 | 88863 | break; |
88553 | 88864 | } |
88554 | - case 18446744073709545960LLU: // 99999998lm''''''''''''''' | |
88865 | + case 18446744073709545945LLU: // 99999998lY''''''''''''''' | |
88555 | 88866 | { |
88556 | 88867 | // variable u64 mutable___ goes out of scope |
88557 | 88868 | // emitted destructur for type u64 |
@@ -88564,7 +88875,7 @@ | ||
88564 | 88875 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
88565 | 88876 | } |
88566 | 88877 | // ACCUMULATE ARGUMENTS - END |
88567 | - uint64_t return_to = 18446744073709545957LLU; | |
88878 | + uint64_t return_to = 18446744073709545942LLU; | |
88568 | 88879 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
88569 | 88880 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
88570 | 88881 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -88573,7 +88884,7 @@ | ||
88573 | 88884 | state.addr = 18446744073709551534LLU; // 999999998s''''''''''''''' |
88574 | 88885 | break; |
88575 | 88886 | } |
88576 | - case 18446744073709545957LLU: // 99999998lj''''''''''''''' | |
88887 | + case 18446744073709545942LLU: // 99999998lV''''''''''''''' | |
88577 | 88888 | { |
88578 | 88889 | (void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type______ at 18 |
88579 | 88890 | // variable u64 INDIRECT__ goes out of scope |
@@ -88584,40 +88895,40 @@ | ||
88584 | 88895 | (void)LOCAL_POP_MOVE(&heap, 16LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id________ at 16 |
88585 | 88896 | heap.availilable_size_for_dynamic_objects += 0LLU; |
88586 | 88897 | heap.availilable_size_for_dynamic_objects += 0LLU; |
88587 | - state.addr = 18446744073709545956LLU; // 99999998li''''''''''''''' | |
88898 | + state.addr = 18446744073709545941LLU; // 99999998lU''''''''''''''' | |
88588 | 88899 | break; |
88589 | 88900 | } |
88590 | - case 18446744073709545978LLU: // 99999998l4''''''''''''''' | |
88901 | + case 18446744073709545963LLU: // 99999998lp''''''''''''''' | |
88591 | 88902 | { |
88592 | - state.addr = 18446744073709545956LLU; // 99999998li''''''''''''''' | |
88903 | + state.addr = 18446744073709545941LLU; // 99999998lU''''''''''''''' | |
88593 | 88904 | break; |
88594 | 88905 | } |
88595 | - case 18446744073709545956LLU: // 99999998li''''''''''''''' | |
88906 | + case 18446744073709545941LLU: // 99999998lU''''''''''''''' | |
88596 | 88907 | { |
88597 | - state.addr = 18446744073709545983LLU; // 99999998l9''''''''''''''' | |
88908 | + state.addr = 18446744073709545968LLU; // 99999998lu''''''''''''''' | |
88598 | 88909 | break; |
88599 | 88910 | } |
88600 | - case 18446744073709545983LLU: // 99999998l9''''''''''''''' | |
88911 | + case 18446744073709545968LLU: // 99999998lu''''''''''''''' | |
88601 | 88912 | { |
88602 | - state.addr = 18446744073709546010LLU; // 99999998mZ''''''''''''''' | |
88913 | + state.addr = 18446744073709545995LLU; // 99999998mK''''''''''''''' | |
88603 | 88914 | break; |
88604 | 88915 | } |
88605 | - case 18446744073709546010LLU: // 99999998mZ''''''''''''''' | |
88916 | + case 18446744073709545995LLU: // 99999998mK''''''''''''''' | |
88606 | 88917 | { |
88607 | - state.addr = 18446744073709546034LLU; // 99999998mw''''''''''''''' | |
88918 | + state.addr = 18446744073709546019LLU; // 99999998mh''''''''''''''' | |
88608 | 88919 | break; |
88609 | 88920 | } |
88610 | - case 18446744073709546034LLU: // 99999998mw''''''''''''''' | |
88921 | + case 18446744073709546019LLU: // 99999998mh''''''''''''''' | |
88611 | 88922 | { |
88612 | - state.addr = 18446744073709546058LLU; // 99999998nJ''''''''''''''' | |
88923 | + state.addr = 18446744073709546043LLU; // 99999998m5''''''''''''''' | |
88613 | 88924 | break; |
88614 | 88925 | } |
88615 | - case 18446744073709546058LLU: // 99999998nJ''''''''''''''' | |
88926 | + case 18446744073709546043LLU: // 99999998m5''''''''''''''' | |
88616 | 88927 | { |
88617 | - state.addr = 18446744073709546082LLU; // 99999998ng''''''''''''''' | |
88928 | + state.addr = 18446744073709546067LLU; // 99999998nS''''''''''''''' | |
88618 | 88929 | break; |
88619 | 88930 | } |
88620 | - case 18446744073709546082LLU: // 99999998ng''''''''''''''' | |
88931 | + case 18446744073709546067LLU: // 99999998nS''''''''''''''' | |
88621 | 88932 | { |
88622 | 88933 | // variable u64 sym_______ goes out of scope |
88623 | 88934 | // emitted destructur for type u64 |
@@ -88742,28 +89053,28 @@ | ||
88742 | 89053 | } |
88743 | 89054 | *LOCAL_ACCESS(heap.data, 19LLU, 18LLU) = 0; |
88744 | 89055 | |
88745 | - state.addr = 18446744073709545955LLU; // 99999998lh''''''''''''''' | |
89056 | + state.addr = 18446744073709545940LLU; // 99999998lT''''''''''''''' | |
88746 | 89057 | break; |
88747 | 89058 | } |
88748 | - case 18446744073709545955LLU: // 99999998lh''''''''''''''' | |
89059 | + case 18446744073709545940LLU: // 99999998lT''''''''''''''' | |
88749 | 89060 | { |
88750 | 89061 | *LOCAL_ACCESS(heap.data, 19LLU, 18LLU) = 552467879098960576; |
88751 | 89062 | |
88752 | - state.addr = 18446744073709545954LLU; // 99999998lg''''''''''''''' | |
89063 | + state.addr = 18446744073709545939LLU; // 99999998lS''''''''''''''' | |
88753 | 89064 | break; |
88754 | 89065 | } |
88755 | - case 18446744073709545954LLU: // 99999998lg''''''''''''''' | |
89066 | + case 18446744073709545939LLU: // 99999998lS''''''''''''''' | |
88756 | 89067 | { |
88757 | 89068 | *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) = /*sym_______*/*LOCAL_ACCESS(heap.data, 19LLU, 18LLU) == /*callee_id_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 9LLU)); |
88758 | - state.addr = 18446744073709545953LLU; // 99999998lf''''''''''''''' | |
89069 | + state.addr = 18446744073709545938LLU; // 99999998lR''''''''''''''' | |
88759 | 89070 | break; |
88760 | 89071 | } |
88761 | - case 18446744073709545953LLU: // 99999998lf''''''''''''''' | |
89072 | + case 18446744073709545938LLU: // 99999998lR''''''''''''''' | |
88762 | 89073 | { |
88763 | - state.addr = *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) ? 18446744073709545952LLU : 18446744073709545951LLU; | |
89074 | + state.addr = *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) ? 18446744073709545937LLU : 18446744073709545936LLU; | |
88764 | 89075 | break; |
88765 | 89076 | } |
88766 | - case 18446744073709545952LLU: // 99999998le''''''''''''''' | |
89077 | + case 18446744073709545937LLU: // 99999998lQ''''''''''''''' | |
88767 | 89078 | { |
88768 | 89079 | // ACCUMULATE ARGUMENTS - BEGIN |
88769 | 89080 | { |
@@ -88771,7 +89082,7 @@ | ||
88771 | 89082 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
88772 | 89083 | } |
88773 | 89084 | // ACCUMULATE ARGUMENTS - END |
88774 | - uint64_t return_to = 18446744073709545949LLU; | |
89085 | + uint64_t return_to = 18446744073709545934LLU; | |
88775 | 89086 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
88776 | 89087 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
88777 | 89088 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -88780,12 +89091,12 @@ | ||
88780 | 89091 | state.addr = 839519719621918720LLU; // skipws____ |
88781 | 89092 | break; |
88782 | 89093 | } |
88783 | - case 18446744073709545949LLU: // 99999998lb''''''''''''''' | |
89094 | + case 18446744073709545934LLU: // 99999998lN''''''''''''''' | |
88784 | 89095 | { |
88785 | - state.addr = 18446744073709545950LLU; // 99999998lc''''''''''''''' | |
89096 | + state.addr = 18446744073709545935LLU; // 99999998lO''''''''''''''' | |
88786 | 89097 | break; |
88787 | 89098 | } |
88788 | - case 18446744073709545950LLU: // 99999998lc''''''''''''''' | |
89099 | + case 18446744073709545935LLU: // 99999998lO''''''''''''''' | |
88789 | 89100 | { |
88790 | 89101 | matchid("(", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 10LLU))); |
88791 | 89102 | // ACCUMULATE ARGUMENTS - BEGIN |
@@ -88794,7 +89105,7 @@ | ||
88794 | 89105 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
88795 | 89106 | } |
88796 | 89107 | // ACCUMULATE ARGUMENTS - END |
88797 | - uint64_t return_to = 18446744073709545947LLU; | |
89108 | + uint64_t return_to = 18446744073709545932LLU; | |
88798 | 89109 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
88799 | 89110 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
88800 | 89111 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -88803,45 +89114,45 @@ | ||
88803 | 89114 | state.addr = 839519719621918720LLU; // skipws____ |
88804 | 89115 | break; |
88805 | 89116 | } |
88806 | - case 18446744073709545947LLU: // 99999998l$''''''''''''''' | |
89117 | + case 18446744073709545932LLU: // 99999998lL''''''''''''''' | |
88807 | 89118 | { |
88808 | - state.addr = 18446744073709545948LLU; // 99999998la''''''''''''''' | |
89119 | + state.addr = 18446744073709545933LLU; // 99999998lM''''''''''''''' | |
88809 | 89120 | break; |
88810 | 89121 | } |
88811 | - case 18446744073709545948LLU: // 99999998la''''''''''''''' | |
89122 | + case 18446744073709545933LLU: // 99999998lM''''''''''''''' | |
88812 | 89123 | { |
88813 | 89124 | matchid(")", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 10LLU))); |
88814 | 89125 | fprintf(stdout, "%s", "fprintf(stderr, \"HEAPSIZE: %llu\\n\", (unsigned long long)countheap(&heap));\n"); |
88815 | 89126 | heap.availilable_size_for_dynamic_objects += 0LLU; |
88816 | 89127 | heap.availilable_size_for_dynamic_objects += 0LLU; |
88817 | - state.addr = 18446744073709545946LLU; // 99999998lZ''''''''''''''' | |
89128 | + state.addr = 18446744073709545931LLU; // 99999998lK''''''''''''''' | |
88818 | 89129 | break; |
88819 | 89130 | } |
88820 | - case 18446744073709545951LLU: // 99999998ld''''''''''''''' | |
89131 | + case 18446744073709545936LLU: // 99999998lP''''''''''''''' | |
88821 | 89132 | { |
88822 | 89133 | |
88823 | - state.addr = 18446744073709545945LLU; // 99999998lY''''''''''''''' | |
89134 | + state.addr = 18446744073709545930LLU; // 99999998lJ''''''''''''''' | |
88824 | 89135 | break; |
88825 | 89136 | } |
88826 | - case 18446744073709545945LLU: // 99999998lY''''''''''''''' | |
89137 | + case 18446744073709545930LLU: // 99999998lJ''''''''''''''' | |
88827 | 89138 | { |
88828 | 89139 | *LOCAL_ACCESS(heap.data, 19LLU, 18LLU) = 589327972884807680; |
88829 | 89140 | |
88830 | - state.addr = 18446744073709545944LLU; // 99999998lX''''''''''''''' | |
89141 | + state.addr = 18446744073709545929LLU; // 99999998lI''''''''''''''' | |
88831 | 89142 | break; |
88832 | 89143 | } |
88833 | - case 18446744073709545944LLU: // 99999998lX''''''''''''''' | |
89144 | + case 18446744073709545929LLU: // 99999998lI''''''''''''''' | |
88834 | 89145 | { |
88835 | 89146 | *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) = /*sym_______*/*LOCAL_ACCESS(heap.data, 19LLU, 18LLU) == /*callee_id_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 9LLU)); |
88836 | - state.addr = 18446744073709545943LLU; // 99999998lW''''''''''''''' | |
89147 | + state.addr = 18446744073709545928LLU; // 99999998lH''''''''''''''' | |
88837 | 89148 | break; |
88838 | 89149 | } |
88839 | - case 18446744073709545943LLU: // 99999998lW''''''''''''''' | |
89150 | + case 18446744073709545928LLU: // 99999998lH''''''''''''''' | |
88840 | 89151 | { |
88841 | - state.addr = *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) ? 18446744073709545942LLU : 18446744073709545941LLU; | |
89152 | + state.addr = *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) ? 18446744073709545927LLU : 18446744073709545926LLU; | |
88842 | 89153 | break; |
88843 | 89154 | } |
88844 | - case 18446744073709545942LLU: // 99999998lV''''''''''''''' | |
89155 | + case 18446744073709545927LLU: // 99999998lG''''''''''''''' | |
88845 | 89156 | { |
88846 | 89157 | // ACCUMULATE ARGUMENTS - BEGIN |
88847 | 89158 | { |
@@ -88857,7 +89168,7 @@ | ||
88857 | 89168 | LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
88858 | 89169 | } |
88859 | 89170 | // ACCUMULATE ARGUMENTS - END |
88860 | - uint64_t return_to = 18446744073709545939LLU; | |
89171 | + uint64_t return_to = 18446744073709545924LLU; | |
88861 | 89172 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)); |
88862 | 89173 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
88863 | 89174 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -88866,43 +89177,43 @@ | ||
88866 | 89177 | state.addr = 787472324524157760LLU; // procerror_ |
88867 | 89178 | break; |
88868 | 89179 | } |
88869 | - case 18446744073709545939LLU: // 99999998lS''''''''''''''' | |
89180 | + case 18446744073709545924LLU: // 99999998lD''''''''''''''' | |
88870 | 89181 | { |
88871 | - state.addr = 18446744073709545940LLU; // 99999998lT''''''''''''''' | |
89182 | + state.addr = 18446744073709545925LLU; // 99999998lE''''''''''''''' | |
88872 | 89183 | break; |
88873 | 89184 | } |
88874 | - case 18446744073709545940LLU: // 99999998lT''''''''''''''' | |
89185 | + case 18446744073709545925LLU: // 99999998lE''''''''''''''' | |
88875 | 89186 | { |
88876 | 89187 | heap.availilable_size_for_dynamic_objects += 0LLU; |
88877 | 89188 | heap.availilable_size_for_dynamic_objects += 0LLU; |
88878 | - state.addr = 18446744073709545938LLU; // 99999998lR''''''''''''''' | |
89189 | + state.addr = 18446744073709545923LLU; // 99999998lC''''''''''''''' | |
88879 | 89190 | break; |
88880 | 89191 | } |
88881 | - case 18446744073709545941LLU: // 99999998lU''''''''''''''' | |
89192 | + case 18446744073709545926LLU: // 99999998lF''''''''''''''' | |
88882 | 89193 | { |
88883 | 89194 | |
88884 | - state.addr = 18446744073709545937LLU; // 99999998lQ''''''''''''''' | |
89195 | + state.addr = 18446744073709545922LLU; // 99999998lB''''''''''''''' | |
88885 | 89196 | break; |
88886 | 89197 | } |
88887 | - case 18446744073709545937LLU: // 99999998lQ''''''''''''''' | |
89198 | + case 18446744073709545922LLU: // 99999998lB''''''''''''''' | |
88888 | 89199 | { |
88889 | 89200 | *LOCAL_ACCESS(heap.data, 19LLU, 18LLU) = 819847183506341888; |
88890 | 89201 | |
88891 | - state.addr = 18446744073709545936LLU; // 99999998lP''''''''''''''' | |
89202 | + state.addr = 18446744073709545921LLU; // 99999998lA''''''''''''''' | |
88892 | 89203 | break; |
88893 | 89204 | } |
88894 | - case 18446744073709545936LLU: // 99999998lP''''''''''''''' | |
89205 | + case 18446744073709545921LLU: // 99999998lA''''''''''''''' | |
88895 | 89206 | { |
88896 | 89207 | *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) = /*sym_______*/*LOCAL_ACCESS(heap.data, 19LLU, 18LLU) == /*callee_id_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 9LLU)); |
88897 | - state.addr = 18446744073709545935LLU; // 99999998lO''''''''''''''' | |
89208 | + state.addr = 18446744073709545920LLU; // 99999998l_''''''''''''''' | |
88898 | 89209 | break; |
88899 | 89210 | } |
88900 | - case 18446744073709545935LLU: // 99999998lO''''''''''''''' | |
89211 | + case 18446744073709545920LLU: // 99999998l_''''''''''''''' | |
88901 | 89212 | { |
88902 | - state.addr = *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) ? 18446744073709545934LLU : 18446744073709545933LLU; | |
89213 | + state.addr = *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) ? 18446744073709545919LLU : 18446744073709545918LLU; | |
88903 | 89214 | break; |
88904 | 89215 | } |
88905 | - case 18446744073709545934LLU: // 99999998lN''''''''''''''' | |
89216 | + case 18446744073709545919LLU: // 99999998k9''''''''''''''' | |
88906 | 89217 | { |
88907 | 89218 | // ACCUMULATE ARGUMENTS - BEGIN |
88908 | 89219 | { |
@@ -88938,7 +89249,7 @@ | ||
88938 | 89249 | LOCAL_PUSH_MOVE(&heap, 7LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
88939 | 89250 | } |
88940 | 89251 | // ACCUMULATE ARGUMENTS - END |
88941 | - uint64_t return_to = 18446744073709545931LLU; | |
89252 | + uint64_t return_to = 18446744073709545916LLU; | |
88942 | 89253 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 8LLU, 0/*address of closure-in-construction*/, 0)); |
88943 | 89254 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
88944 | 89255 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 8LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -88947,43 +89258,43 @@ | ||
88947 | 89258 | state.addr = 787472338264173423LLU; // procreport |
88948 | 89259 | break; |
88949 | 89260 | } |
88950 | - case 18446744073709545931LLU: // 99999998lK''''''''''''''' | |
89261 | + case 18446744073709545916LLU: // 99999998k6''''''''''''''' | |
88951 | 89262 | { |
88952 | - state.addr = 18446744073709545932LLU; // 99999998lL''''''''''''''' | |
89263 | + state.addr = 18446744073709545917LLU; // 99999998k7''''''''''''''' | |
88953 | 89264 | break; |
88954 | 89265 | } |
88955 | - case 18446744073709545932LLU: // 99999998lL''''''''''''''' | |
89266 | + case 18446744073709545917LLU: // 99999998k7''''''''''''''' | |
88956 | 89267 | { |
88957 | 89268 | heap.availilable_size_for_dynamic_objects += 0LLU; |
88958 | 89269 | heap.availilable_size_for_dynamic_objects += 0LLU; |
88959 | - state.addr = 18446744073709545930LLU; // 99999998lJ''''''''''''''' | |
89270 | + state.addr = 18446744073709545915LLU; // 99999998k5''''''''''''''' | |
88960 | 89271 | break; |
88961 | 89272 | } |
88962 | - case 18446744073709545933LLU: // 99999998lM''''''''''''''' | |
89273 | + case 18446744073709545918LLU: // 99999998k8''''''''''''''' | |
88963 | 89274 | { |
88964 | 89275 | |
88965 | - state.addr = 18446744073709545929LLU; // 99999998lI''''''''''''''' | |
89276 | + state.addr = 18446744073709545914LLU; // 99999998k4''''''''''''''' | |
88966 | 89277 | break; |
88967 | 89278 | } |
88968 | - case 18446744073709545929LLU: // 99999998lI''''''''''''''' | |
89279 | + case 18446744073709545914LLU: // 99999998k4''''''''''''''' | |
88969 | 89280 | { |
88970 | 89281 | *LOCAL_ACCESS(heap.data, 19LLU, 18LLU) = 787446707498516480; |
88971 | 89282 | |
88972 | - state.addr = 18446744073709545928LLU; // 99999998lH''''''''''''''' | |
89283 | + state.addr = 18446744073709545913LLU; // 99999998k3''''''''''''''' | |
88973 | 89284 | break; |
88974 | 89285 | } |
88975 | - case 18446744073709545928LLU: // 99999998lH''''''''''''''' | |
89286 | + case 18446744073709545913LLU: // 99999998k3''''''''''''''' | |
88976 | 89287 | { |
88977 | 89288 | *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) = /*sym_______*/*LOCAL_ACCESS(heap.data, 19LLU, 18LLU) == /*callee_id_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 9LLU)); |
88978 | - state.addr = 18446744073709545927LLU; // 99999998lG''''''''''''''' | |
89289 | + state.addr = 18446744073709545912LLU; // 99999998k2''''''''''''''' | |
88979 | 89290 | break; |
88980 | 89291 | } |
88981 | - case 18446744073709545927LLU: // 99999998lG''''''''''''''' | |
89292 | + case 18446744073709545912LLU: // 99999998k2''''''''''''''' | |
88982 | 89293 | { |
88983 | - state.addr = *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) ? 18446744073709545926LLU : 18446744073709545925LLU; | |
89294 | + state.addr = *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) ? 18446744073709545911LLU : 18446744073709545910LLU; | |
88984 | 89295 | break; |
88985 | 89296 | } |
88986 | - case 18446744073709545926LLU: // 99999998lF''''''''''''''' | |
89297 | + case 18446744073709545911LLU: // 99999998k1''''''''''''''' | |
88987 | 89298 | { |
88988 | 89299 | // ACCUMULATE ARGUMENTS - BEGIN |
88989 | 89300 | { |
@@ -89019,7 +89330,7 @@ | ||
89019 | 89330 | LOCAL_PUSH_MOVE(&heap, 7LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
89020 | 89331 | } |
89021 | 89332 | // ACCUMULATE ARGUMENTS - END |
89022 | - uint64_t return_to = 18446744073709545923LLU; | |
89333 | + uint64_t return_to = 18446744073709545908LLU; | |
89023 | 89334 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 8LLU, 0/*address of closure-in-construction*/, 0)); |
89024 | 89335 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
89025 | 89336 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 8LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -89028,43 +89339,43 @@ | ||
89028 | 89339 | state.addr = 787472336332954560LLU; // procprint_ |
89029 | 89340 | break; |
89030 | 89341 | } |
89031 | - case 18446744073709545923LLU: // 99999998lC''''''''''''''' | |
89342 | + case 18446744073709545908LLU: // 99999998ky''''''''''''''' | |
89032 | 89343 | { |
89033 | - state.addr = 18446744073709545924LLU; // 99999998lD''''''''''''''' | |
89344 | + state.addr = 18446744073709545909LLU; // 99999998kz''''''''''''''' | |
89034 | 89345 | break; |
89035 | 89346 | } |
89036 | - case 18446744073709545924LLU: // 99999998lD''''''''''''''' | |
89347 | + case 18446744073709545909LLU: // 99999998kz''''''''''''''' | |
89037 | 89348 | { |
89038 | 89349 | heap.availilable_size_for_dynamic_objects += 0LLU; |
89039 | 89350 | heap.availilable_size_for_dynamic_objects += 0LLU; |
89040 | - state.addr = 18446744073709545922LLU; // 99999998lB''''''''''''''' | |
89351 | + state.addr = 18446744073709545907LLU; // 99999998kx''''''''''''''' | |
89041 | 89352 | break; |
89042 | 89353 | } |
89043 | - case 18446744073709545925LLU: // 99999998lE''''''''''''''' | |
89354 | + case 18446744073709545910LLU: // 99999998k0''''''''''''''' | |
89044 | 89355 | { |
89045 | 89356 | |
89046 | - state.addr = 18446744073709545921LLU; // 99999998lA''''''''''''''' | |
89357 | + state.addr = 18446744073709545906LLU; // 99999998kw''''''''''''''' | |
89047 | 89358 | break; |
89048 | 89359 | } |
89049 | - case 18446744073709545921LLU: // 99999998lA''''''''''''''' | |
89360 | + case 18446744073709545906LLU: // 99999998kw''''''''''''''' | |
89050 | 89361 | { |
89051 | 89362 | *LOCAL_ACCESS(heap.data, 19LLU, 18LLU) = 728666047576934182; |
89052 | 89363 | |
89053 | - state.addr = 18446744073709545920LLU; // 99999998l_''''''''''''''' | |
89364 | + state.addr = 18446744073709545905LLU; // 99999998kv''''''''''''''' | |
89054 | 89365 | break; |
89055 | 89366 | } |
89056 | - case 18446744073709545920LLU: // 99999998l_''''''''''''''' | |
89367 | + case 18446744073709545905LLU: // 99999998kv''''''''''''''' | |
89057 | 89368 | { |
89058 | 89369 | *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) = /*sym_______*/*LOCAL_ACCESS(heap.data, 19LLU, 18LLU) == /*callee_id_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 9LLU)); |
89059 | - state.addr = 18446744073709545919LLU; // 99999998k9''''''''''''''' | |
89370 | + state.addr = 18446744073709545904LLU; // 99999998ku''''''''''''''' | |
89060 | 89371 | break; |
89061 | 89372 | } |
89062 | - case 18446744073709545919LLU: // 99999998k9''''''''''''''' | |
89373 | + case 18446744073709545904LLU: // 99999998ku''''''''''''''' | |
89063 | 89374 | { |
89064 | - state.addr = *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) ? 18446744073709545918LLU : 18446744073709545917LLU; | |
89375 | + state.addr = *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) ? 18446744073709545903LLU : 18446744073709545902LLU; | |
89065 | 89376 | break; |
89066 | 89377 | } |
89067 | - case 18446744073709545918LLU: // 99999998k8''''''''''''''' | |
89378 | + case 18446744073709545903LLU: // 99999998kt''''''''''''''' | |
89068 | 89379 | { |
89069 | 89380 | // ACCUMULATE ARGUMENTS - BEGIN |
89070 | 89381 | { |
@@ -89108,7 +89419,7 @@ | ||
89108 | 89419 | LOCAL_PUSH_MOVE(&heap, 9LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
89109 | 89420 | } |
89110 | 89421 | // ACCUMULATE ARGUMENTS - END |
89111 | - uint64_t return_to = 18446744073709545915LLU; | |
89422 | + uint64_t return_to = 18446744073709545900LLU; | |
89112 | 89423 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 10LLU, 0/*address of closure-in-construction*/, 0)); |
89113 | 89424 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
89114 | 89425 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 10LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -89117,43 +89428,43 @@ | ||
89117 | 89428 | state.addr = 787463406843976550LLU; // prmatchbrk |
89118 | 89429 | break; |
89119 | 89430 | } |
89120 | - case 18446744073709545915LLU: // 99999998k5''''''''''''''' | |
89431 | + case 18446744073709545900LLU: // 99999998kq''''''''''''''' | |
89121 | 89432 | { |
89122 | - state.addr = 18446744073709545916LLU; // 99999998k6''''''''''''''' | |
89433 | + state.addr = 18446744073709545901LLU; // 99999998kr''''''''''''''' | |
89123 | 89434 | break; |
89124 | 89435 | } |
89125 | - case 18446744073709545916LLU: // 99999998k6''''''''''''''' | |
89436 | + case 18446744073709545901LLU: // 99999998kr''''''''''''''' | |
89126 | 89437 | { |
89127 | 89438 | heap.availilable_size_for_dynamic_objects += 0LLU; |
89128 | 89439 | heap.availilable_size_for_dynamic_objects += 0LLU; |
89129 | - state.addr = 18446744073709545914LLU; // 99999998k4''''''''''''''' | |
89440 | + state.addr = 18446744073709545899LLU; // 99999998kp''''''''''''''' | |
89130 | 89441 | break; |
89131 | 89442 | } |
89132 | - case 18446744073709545917LLU: // 99999998k7''''''''''''''' | |
89443 | + case 18446744073709545902LLU: // 99999998ks''''''''''''''' | |
89133 | 89444 | { |
89134 | 89445 | |
89135 | - state.addr = 18446744073709545913LLU; // 99999998k3''''''''''''''' | |
89446 | + state.addr = 18446744073709545898LLU; // 99999998ko''''''''''''''' | |
89136 | 89447 | break; |
89137 | 89448 | } |
89138 | - case 18446744073709545913LLU: // 99999998k3''''''''''''''' | |
89449 | + case 18446744073709545898LLU: // 99999998ko''''''''''''''' | |
89139 | 89450 | { |
89140 | 89451 | *LOCAL_ACCESS(heap.data, 19LLU, 18LLU) = 728666047690571776; |
89141 | 89452 | |
89142 | - state.addr = 18446744073709545912LLU; // 99999998k2''''''''''''''' | |
89453 | + state.addr = 18446744073709545897LLU; // 99999998kn''''''''''''''' | |
89143 | 89454 | break; |
89144 | 89455 | } |
89145 | - case 18446744073709545912LLU: // 99999998k2''''''''''''''' | |
89456 | + case 18446744073709545897LLU: // 99999998kn''''''''''''''' | |
89146 | 89457 | { |
89147 | 89458 | *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) = /*sym_______*/*LOCAL_ACCESS(heap.data, 19LLU, 18LLU) == /*callee_id_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 9LLU)); |
89148 | - state.addr = 18446744073709545911LLU; // 99999998k1''''''''''''''' | |
89459 | + state.addr = 18446744073709545896LLU; // 99999998km''''''''''''''' | |
89149 | 89460 | break; |
89150 | 89461 | } |
89151 | - case 18446744073709545911LLU: // 99999998k1''''''''''''''' | |
89462 | + case 18446744073709545896LLU: // 99999998km''''''''''''''' | |
89152 | 89463 | { |
89153 | - state.addr = *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) ? 18446744073709545910LLU : 18446744073709545909LLU; | |
89464 | + state.addr = *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) ? 18446744073709545895LLU : 18446744073709545894LLU; | |
89154 | 89465 | break; |
89155 | 89466 | } |
89156 | - case 18446744073709545910LLU: // 99999998k0''''''''''''''' | |
89467 | + case 18446744073709545895LLU: // 99999998kl''''''''''''''' | |
89157 | 89468 | { |
89158 | 89469 | // ACCUMULATE ARGUMENTS - BEGIN |
89159 | 89470 | { |
@@ -89197,7 +89508,7 @@ | ||
89197 | 89508 | LOCAL_PUSH_MOVE(&heap, 9LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
89198 | 89509 | } |
89199 | 89510 | // ACCUMULATE ARGUMENTS - END |
89200 | - uint64_t return_to = 18446744073709545907LLU; | |
89511 | + uint64_t return_to = 18446744073709545892LLU; | |
89201 | 89512 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 10LLU, 0/*address of closure-in-construction*/, 0)); |
89202 | 89513 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
89203 | 89514 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 10LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -89206,43 +89517,43 @@ | ||
89206 | 89517 | state.addr = 787463406844004288LLU; // prmatchid_ |
89207 | 89518 | break; |
89208 | 89519 | } |
89209 | - case 18446744073709545907LLU: // 99999998kx''''''''''''''' | |
89520 | + case 18446744073709545892LLU: // 99999998ki''''''''''''''' | |
89210 | 89521 | { |
89211 | - state.addr = 18446744073709545908LLU; // 99999998ky''''''''''''''' | |
89522 | + state.addr = 18446744073709545893LLU; // 99999998kj''''''''''''''' | |
89212 | 89523 | break; |
89213 | 89524 | } |
89214 | - case 18446744073709545908LLU: // 99999998ky''''''''''''''' | |
89525 | + case 18446744073709545893LLU: // 99999998kj''''''''''''''' | |
89215 | 89526 | { |
89216 | 89527 | heap.availilable_size_for_dynamic_objects += 0LLU; |
89217 | 89528 | heap.availilable_size_for_dynamic_objects += 0LLU; |
89218 | - state.addr = 18446744073709545906LLU; // 99999998kw''''''''''''''' | |
89529 | + state.addr = 18446744073709545891LLU; // 99999998kh''''''''''''''' | |
89219 | 89530 | break; |
89220 | 89531 | } |
89221 | - case 18446744073709545909LLU: // 99999998kz''''''''''''''' | |
89532 | + case 18446744073709545894LLU: // 99999998kk''''''''''''''' | |
89222 | 89533 | { |
89223 | 89534 | |
89224 | - state.addr = 18446744073709545905LLU; // 99999998kv''''''''''''''' | |
89535 | + state.addr = 18446744073709545890LLU; // 99999998kg''''''''''''''' | |
89225 | 89536 | break; |
89226 | 89537 | } |
89227 | - case 18446744073709545905LLU: // 99999998kv''''''''''''''' | |
89538 | + case 18446744073709545890LLU: // 99999998kg''''''''''''''' | |
89228 | 89539 | { |
89229 | 89540 | *LOCAL_ACCESS(heap.data, 19LLU, 18LLU) = 787472324541022208; |
89230 | 89541 | |
89231 | - state.addr = 18446744073709545904LLU; // 99999998ku''''''''''''''' | |
89542 | + state.addr = 18446744073709545889LLU; // 99999998kf''''''''''''''' | |
89232 | 89543 | break; |
89233 | 89544 | } |
89234 | - case 18446744073709545904LLU: // 99999998ku''''''''''''''' | |
89545 | + case 18446744073709545889LLU: // 99999998kf''''''''''''''' | |
89235 | 89546 | { |
89236 | 89547 | *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) = /*sym_______*/*LOCAL_ACCESS(heap.data, 19LLU, 18LLU) == /*callee_id_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 9LLU)); |
89237 | - state.addr = 18446744073709545903LLU; // 99999998kt''''''''''''''' | |
89548 | + state.addr = 18446744073709545888LLU; // 99999998ke''''''''''''''' | |
89238 | 89549 | break; |
89239 | 89550 | } |
89240 | - case 18446744073709545903LLU: // 99999998kt''''''''''''''' | |
89551 | + case 18446744073709545888LLU: // 99999998ke''''''''''''''' | |
89241 | 89552 | { |
89242 | - state.addr = *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) ? 18446744073709545902LLU : 18446744073709545901LLU; | |
89553 | + state.addr = *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) ? 18446744073709545887LLU : 18446744073709545886LLU; | |
89243 | 89554 | break; |
89244 | 89555 | } |
89245 | - case 18446744073709545902LLU: // 99999998ks''''''''''''''' | |
89556 | + case 18446744073709545887LLU: // 99999998kd''''''''''''''' | |
89246 | 89557 | { |
89247 | 89558 | // ACCUMULATE ARGUMENTS - BEGIN |
89248 | 89559 | { |
@@ -89294,7 +89605,7 @@ | ||
89294 | 89605 | LOCAL_PUSH_MOVE(&heap, 11LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
89295 | 89606 | } |
89296 | 89607 | // ACCUMULATE ARGUMENTS - END |
89297 | - uint64_t return_to = 18446744073709545899LLU; | |
89608 | + uint64_t return_to = 18446744073709545884LLU; | |
89298 | 89609 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 12LLU, 0/*address of closure-in-construction*/, 0)); |
89299 | 89610 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
89300 | 89611 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 12LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -89303,43 +89614,43 @@ | ||
89303 | 89614 | state.addr = 787420455223561134LLU; // prcprocess |
89304 | 89615 | break; |
89305 | 89616 | } |
89306 | - case 18446744073709545899LLU: // 99999998kp''''''''''''''' | |
89617 | + case 18446744073709545884LLU: // 99999998ka''''''''''''''' | |
89307 | 89618 | { |
89308 | - state.addr = 18446744073709545900LLU; // 99999998kq''''''''''''''' | |
89619 | + state.addr = 18446744073709545885LLU; // 99999998kb''''''''''''''' | |
89309 | 89620 | break; |
89310 | 89621 | } |
89311 | - case 18446744073709545900LLU: // 99999998kq''''''''''''''' | |
89622 | + case 18446744073709545885LLU: // 99999998kb''''''''''''''' | |
89312 | 89623 | { |
89313 | 89624 | heap.availilable_size_for_dynamic_objects += 0LLU; |
89314 | 89625 | heap.availilable_size_for_dynamic_objects += 0LLU; |
89315 | - state.addr = 18446744073709545898LLU; // 99999998ko''''''''''''''' | |
89626 | + state.addr = 18446744073709545883LLU; // 99999998k$''''''''''''''' | |
89316 | 89627 | break; |
89317 | 89628 | } |
89318 | - case 18446744073709545901LLU: // 99999998kr''''''''''''''' | |
89629 | + case 18446744073709545886LLU: // 99999998kc''''''''''''''' | |
89319 | 89630 | { |
89320 | 89631 | |
89321 | - state.addr = 18446744073709545897LLU; // 99999998kn''''''''''''''' | |
89632 | + state.addr = 18446744073709545882LLU; // 99999998kZ''''''''''''''' | |
89322 | 89633 | break; |
89323 | 89634 | } |
89324 | - case 18446744073709545897LLU: // 99999998kn''''''''''''''' | |
89635 | + case 18446744073709545882LLU: // 99999998kZ''''''''''''''' | |
89325 | 89636 | { |
89326 | 89637 | *LOCAL_ACCESS(heap.data, 19LLU, 18LLU) = 606497241528270848; |
89327 | 89638 | |
89328 | - state.addr = 18446744073709545896LLU; // 99999998km''''''''''''''' | |
89639 | + state.addr = 18446744073709545881LLU; // 99999998kY''''''''''''''' | |
89329 | 89640 | break; |
89330 | 89641 | } |
89331 | - case 18446744073709545896LLU: // 99999998km''''''''''''''' | |
89642 | + case 18446744073709545881LLU: // 99999998kY''''''''''''''' | |
89332 | 89643 | { |
89333 | 89644 | *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) = /*sym_______*/*LOCAL_ACCESS(heap.data, 19LLU, 18LLU) == /*callee_id_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 9LLU)); |
89334 | - state.addr = 18446744073709545895LLU; // 99999998kl''''''''''''''' | |
89645 | + state.addr = 18446744073709545880LLU; // 99999998kX''''''''''''''' | |
89335 | 89646 | break; |
89336 | 89647 | } |
89337 | - case 18446744073709545895LLU: // 99999998kl''''''''''''''' | |
89648 | + case 18446744073709545880LLU: // 99999998kX''''''''''''''' | |
89338 | 89649 | { |
89339 | - state.addr = *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) ? 18446744073709545894LLU : 18446744073709545893LLU; | |
89650 | + state.addr = *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) ? 18446744073709545879LLU : 18446744073709545878LLU; | |
89340 | 89651 | break; |
89341 | 89652 | } |
89342 | - case 18446744073709545894LLU: // 99999998kk''''''''''''''' | |
89653 | + case 18446744073709545879LLU: // 99999998kW''''''''''''''' | |
89343 | 89654 | { |
89344 | 89655 | // ACCUMULATE ARGUMENTS - BEGIN |
89345 | 89656 | { |
@@ -89391,7 +89702,7 @@ | ||
89391 | 89702 | LOCAL_PUSH_MOVE(&heap, 11LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
89392 | 89703 | } |
89393 | 89704 | // ACCUMULATE ARGUMENTS - END |
89394 | - uint64_t return_to = 18446744073709545891LLU; | |
89705 | + uint64_t return_to = 18446744073709545876LLU; | |
89395 | 89706 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 12LLU, 0/*address of closure-in-construction*/, 0)); |
89396 | 89707 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
89397 | 89708 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 12LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -89400,43 +89711,43 @@ | ||
89400 | 89711 | state.addr = 787419764858406819LLU; // prcforeach |
89401 | 89712 | break; |
89402 | 89713 | } |
89403 | - case 18446744073709545891LLU: // 99999998kh''''''''''''''' | |
89714 | + case 18446744073709545876LLU: // 99999998kT''''''''''''''' | |
89404 | 89715 | { |
89405 | - state.addr = 18446744073709545892LLU; // 99999998ki''''''''''''''' | |
89716 | + state.addr = 18446744073709545877LLU; // 99999998kU''''''''''''''' | |
89406 | 89717 | break; |
89407 | 89718 | } |
89408 | - case 18446744073709545892LLU: // 99999998ki''''''''''''''' | |
89719 | + case 18446744073709545877LLU: // 99999998kU''''''''''''''' | |
89409 | 89720 | { |
89410 | 89721 | heap.availilable_size_for_dynamic_objects += 0LLU; |
89411 | 89722 | heap.availilable_size_for_dynamic_objects += 0LLU; |
89412 | - state.addr = 18446744073709545890LLU; // 99999998kg''''''''''''''' | |
89723 | + state.addr = 18446744073709545875LLU; // 99999998kS''''''''''''''' | |
89413 | 89724 | break; |
89414 | 89725 | } |
89415 | - case 18446744073709545893LLU: // 99999998kj''''''''''''''' | |
89726 | + case 18446744073709545878LLU: // 99999998kV''''''''''''''' | |
89416 | 89727 | { |
89417 | 89728 | |
89418 | - state.addr = 18446744073709545889LLU; // 99999998kf''''''''''''''' | |
89729 | + state.addr = 18446744073709545874LLU; // 99999998kR''''''''''''''' | |
89419 | 89730 | break; |
89420 | 89731 | } |
89421 | - case 18446744073709545889LLU: // 99999998kf''''''''''''''' | |
89732 | + case 18446744073709545874LLU: // 99999998kR''''''''''''''' | |
89422 | 89733 | { |
89423 | 89734 | *LOCAL_ACCESS(heap.data, 19LLU, 18LLU) = 552467879034563136; |
89424 | 89735 | |
89425 | - state.addr = 18446744073709545888LLU; // 99999998ke''''''''''''''' | |
89736 | + state.addr = 18446744073709545873LLU; // 99999998kQ''''''''''''''' | |
89426 | 89737 | break; |
89427 | 89738 | } |
89428 | - case 18446744073709545888LLU: // 99999998ke''''''''''''''' | |
89739 | + case 18446744073709545873LLU: // 99999998kQ''''''''''''''' | |
89429 | 89740 | { |
89430 | 89741 | *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) = /*sym_______*/*LOCAL_ACCESS(heap.data, 19LLU, 18LLU) == /*callee_id_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 9LLU)); |
89431 | - state.addr = 18446744073709545887LLU; // 99999998kd''''''''''''''' | |
89742 | + state.addr = 18446744073709545872LLU; // 99999998kP''''''''''''''' | |
89432 | 89743 | break; |
89433 | 89744 | } |
89434 | - case 18446744073709545887LLU: // 99999998kd''''''''''''''' | |
89745 | + case 18446744073709545872LLU: // 99999998kP''''''''''''''' | |
89435 | 89746 | { |
89436 | - state.addr = *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) ? 18446744073709545886LLU : 18446744073709545885LLU; | |
89747 | + state.addr = *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) ? 18446744073709545871LLU : 18446744073709545870LLU; | |
89437 | 89748 | break; |
89438 | 89749 | } |
89439 | - case 18446744073709545886LLU: // 99999998kc''''''''''''''' | |
89750 | + case 18446744073709545871LLU: // 99999998kO''''''''''''''' | |
89440 | 89751 | { |
89441 | 89752 | { |
89442 | 89753 | uint64_t arg = 0; |
@@ -89489,7 +89800,7 @@ | ||
89489 | 89800 | LOCAL_PUSH_MOVE(&heap, 10LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
89490 | 89801 | } |
89491 | 89802 | // ACCUMULATE ARGUMENTS - END |
89492 | - uint64_t return_to = 18446744073709545883LLU; | |
89803 | + uint64_t return_to = 18446744073709545868LLU; | |
89493 | 89804 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 11LLU, 0/*address of closure-in-construction*/, 0)); |
89494 | 89805 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
89495 | 89806 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 11LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -89498,12 +89809,12 @@ | ||
89498 | 89809 | state.addr = 783251446517640361LLU; // pcountdown |
89499 | 89810 | break; |
89500 | 89811 | } |
89501 | - case 18446744073709545883LLU: // 99999998k$''''''''''''''' | |
89812 | + case 18446744073709545868LLU: // 99999998kL''''''''''''''' | |
89502 | 89813 | { |
89503 | - state.addr = 18446744073709545884LLU; // 99999998ka''''''''''''''' | |
89814 | + state.addr = 18446744073709545869LLU; // 99999998kM''''''''''''''' | |
89504 | 89815 | break; |
89505 | 89816 | } |
89506 | - case 18446744073709545884LLU: // 99999998ka''''''''''''''' | |
89817 | + case 18446744073709545869LLU: // 99999998kM''''''''''''''' | |
89507 | 89818 | { |
89508 | 89819 | // variable u64 callee_id_ goes out of scope |
89509 | 89820 | // emitted destructur for type u64 |
@@ -89510,34 +89821,34 @@ | ||
89510 | 89821 | (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference callee_id_ at 20 |
89511 | 89822 | heap.availilable_size_for_dynamic_objects += 0LLU; |
89512 | 89823 | heap.availilable_size_for_dynamic_objects += 0LLU; |
89513 | - state.addr = 18446744073709545882LLU; // 99999998kZ''''''''''''''' | |
89824 | + state.addr = 18446744073709545867LLU; // 99999998kK''''''''''''''' | |
89514 | 89825 | break; |
89515 | 89826 | } |
89516 | - case 18446744073709545885LLU: // 99999998kb''''''''''''''' | |
89827 | + case 18446744073709545870LLU: // 99999998kN''''''''''''''' | |
89517 | 89828 | { |
89518 | 89829 | |
89519 | - state.addr = 18446744073709545881LLU; // 99999998kY''''''''''''''' | |
89830 | + state.addr = 18446744073709545866LLU; // 99999998kJ''''''''''''''' | |
89520 | 89831 | break; |
89521 | 89832 | } |
89522 | - case 18446744073709545881LLU: // 99999998kY''''''''''''''' | |
89833 | + case 18446744073709545866LLU: // 99999998kJ''''''''''''''' | |
89523 | 89834 | { |
89524 | 89835 | *LOCAL_ACCESS(heap.data, 19LLU, 18LLU) = 768306405604851712; |
89525 | 89836 | |
89526 | - state.addr = 18446744073709545880LLU; // 99999998kX''''''''''''''' | |
89837 | + state.addr = 18446744073709545865LLU; // 99999998kI''''''''''''''' | |
89527 | 89838 | break; |
89528 | 89839 | } |
89529 | - case 18446744073709545880LLU: // 99999998kX''''''''''''''' | |
89840 | + case 18446744073709545865LLU: // 99999998kI''''''''''''''' | |
89530 | 89841 | { |
89531 | 89842 | *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) = /*sym_______*/*LOCAL_ACCESS(heap.data, 19LLU, 18LLU) == /*callee_id_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 9LLU)); |
89532 | - state.addr = 18446744073709545879LLU; // 99999998kW''''''''''''''' | |
89843 | + state.addr = 18446744073709545864LLU; // 99999998kH''''''''''''''' | |
89533 | 89844 | break; |
89534 | 89845 | } |
89535 | - case 18446744073709545879LLU: // 99999998kW''''''''''''''' | |
89846 | + case 18446744073709545864LLU: // 99999998kH''''''''''''''' | |
89536 | 89847 | { |
89537 | - state.addr = *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) ? 18446744073709545878LLU : 18446744073709545877LLU; | |
89848 | + state.addr = *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) ? 18446744073709545863LLU : 18446744073709545862LLU; | |
89538 | 89849 | break; |
89539 | 89850 | } |
89540 | - case 18446744073709545878LLU: // 99999998kV''''''''''''''' | |
89851 | + case 18446744073709545863LLU: // 99999998kG''''''''''''''' | |
89541 | 89852 | { |
89542 | 89853 | // ACCUMULATE ARGUMENTS - BEGIN |
89543 | 89854 | { |
@@ -89585,7 +89896,7 @@ | ||
89585 | 89896 | LOCAL_PUSH_MOVE(&heap, 10LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
89586 | 89897 | } |
89587 | 89898 | // ACCUMULATE ARGUMENTS - END |
89588 | - uint64_t return_to = 18446744073709545875LLU; | |
89899 | + uint64_t return_to = 18446744073709545860LLU; | |
89589 | 89900 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 11LLU, 0/*address of closure-in-construction*/, 0)); |
89590 | 89901 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
89591 | 89902 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 11LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -89594,43 +89905,43 @@ | ||
89594 | 89905 | state.addr = 787420382111382575LLU; // prconinput |
89595 | 89906 | break; |
89596 | 89907 | } |
89597 | - case 18446744073709545875LLU: // 99999998kS''''''''''''''' | |
89908 | + case 18446744073709545860LLU: // 99999998kD''''''''''''''' | |
89598 | 89909 | { |
89599 | - state.addr = 18446744073709545876LLU; // 99999998kT''''''''''''''' | |
89910 | + state.addr = 18446744073709545861LLU; // 99999998kE''''''''''''''' | |
89600 | 89911 | break; |
89601 | 89912 | } |
89602 | - case 18446744073709545876LLU: // 99999998kT''''''''''''''' | |
89913 | + case 18446744073709545861LLU: // 99999998kE''''''''''''''' | |
89603 | 89914 | { |
89604 | 89915 | heap.availilable_size_for_dynamic_objects += 0LLU; |
89605 | 89916 | heap.availilable_size_for_dynamic_objects += 0LLU; |
89606 | - state.addr = 18446744073709545874LLU; // 99999998kR''''''''''''''' | |
89917 | + state.addr = 18446744073709545859LLU; // 99999998kC''''''''''''''' | |
89607 | 89918 | break; |
89608 | 89919 | } |
89609 | - case 18446744073709545877LLU: // 99999998kU''''''''''''''' | |
89920 | + case 18446744073709545862LLU: // 99999998kF''''''''''''''' | |
89610 | 89921 | { |
89611 | 89922 | |
89612 | - state.addr = 18446744073709545873LLU; // 99999998kQ''''''''''''''' | |
89923 | + state.addr = 18446744073709545858LLU; // 99999998kB''''''''''''''' | |
89613 | 89924 | break; |
89614 | 89925 | } |
89615 | - case 18446744073709545873LLU: // 99999998kQ''''''''''''''' | |
89926 | + case 18446744073709545858LLU: // 99999998kB''''''''''''''' | |
89616 | 89927 | { |
89617 | 89928 | *LOCAL_ACCESS(heap.data, 19LLU, 18LLU) = 910732593752702976; |
89618 | 89929 | |
89619 | - state.addr = 18446744073709545872LLU; // 99999998kP''''''''''''''' | |
89930 | + state.addr = 18446744073709545857LLU; // 99999998kA''''''''''''''' | |
89620 | 89931 | break; |
89621 | 89932 | } |
89622 | - case 18446744073709545872LLU: // 99999998kP''''''''''''''' | |
89933 | + case 18446744073709545857LLU: // 99999998kA''''''''''''''' | |
89623 | 89934 | { |
89624 | 89935 | *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) = /*sym_______*/*LOCAL_ACCESS(heap.data, 19LLU, 18LLU) == /*callee_id_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 9LLU)); |
89625 | - state.addr = 18446744073709545871LLU; // 99999998kO''''''''''''''' | |
89936 | + state.addr = 18446744073709545856LLU; // 99999998k_''''''''''''''' | |
89626 | 89937 | break; |
89627 | 89938 | } |
89628 | - case 18446744073709545871LLU: // 99999998kO''''''''''''''' | |
89939 | + case 18446744073709545856LLU: // 99999998k_''''''''''''''' | |
89629 | 89940 | { |
89630 | - state.addr = *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) ? 18446744073709545870LLU : 18446744073709545869LLU; | |
89941 | + state.addr = *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) ? 18446744073709545855LLU : 18446744073709545854LLU; | |
89631 | 89942 | break; |
89632 | 89943 | } |
89633 | - case 18446744073709545870LLU: // 99999998kN''''''''''''''' | |
89944 | + case 18446744073709545855LLU: // 99999998j9''''''''''''''' | |
89634 | 89945 | { |
89635 | 89946 | // ACCUMULATE ARGUMENTS - BEGIN |
89636 | 89947 | { |
@@ -89682,7 +89993,7 @@ | ||
89682 | 89993 | LOCAL_PUSH_MOVE(&heap, 11LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
89683 | 89994 | } |
89684 | 89995 | // ACCUMULATE ARGUMENTS - END |
89685 | - uint64_t return_to = 18446744073709545867LLU; | |
89996 | + uint64_t return_to = 18446744073709545852LLU; | |
89686 | 89997 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 12LLU, 0/*address of closure-in-construction*/, 0)); |
89687 | 89998 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
89688 | 89999 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 12LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -89691,43 +90002,43 @@ | ||
89691 | 90002 | state.addr = 787472343681366016LLU; // procwhile_ |
89692 | 90003 | break; |
89693 | 90004 | } |
89694 | - case 18446744073709545867LLU: // 99999998kK''''''''''''''' | |
90005 | + case 18446744073709545852LLU: // 99999998j6''''''''''''''' | |
89695 | 90006 | { |
89696 | - state.addr = 18446744073709545868LLU; // 99999998kL''''''''''''''' | |
90007 | + state.addr = 18446744073709545853LLU; // 99999998j7''''''''''''''' | |
89697 | 90008 | break; |
89698 | 90009 | } |
89699 | - case 18446744073709545868LLU: // 99999998kL''''''''''''''' | |
90010 | + case 18446744073709545853LLU: // 99999998j7''''''''''''''' | |
89700 | 90011 | { |
89701 | 90012 | heap.availilable_size_for_dynamic_objects += 0LLU; |
89702 | 90013 | heap.availilable_size_for_dynamic_objects += 0LLU; |
89703 | - state.addr = 18446744073709545866LLU; // 99999998kJ''''''''''''''' | |
90014 | + state.addr = 18446744073709545851LLU; // 99999998j5''''''''''''''' | |
89704 | 90015 | break; |
89705 | 90016 | } |
89706 | - case 18446744073709545869LLU: // 99999998kM''''''''''''''' | |
90017 | + case 18446744073709545854LLU: // 99999998j8''''''''''''''' | |
89707 | 90018 | { |
89708 | 90019 | |
89709 | - state.addr = 18446744073709545865LLU; // 99999998kI''''''''''''''' | |
90020 | + state.addr = 18446744073709545850LLU; // 99999998j4''''''''''''''' | |
89710 | 90021 | break; |
89711 | 90022 | } |
89712 | - case 18446744073709545865LLU: // 99999998kI''''''''''''''' | |
90023 | + case 18446744073709545850LLU: // 99999998j4''''''''''''''' | |
89713 | 90024 | { |
89714 | 90025 | *LOCAL_ACCESS(heap.data, 19LLU, 18LLU) = 910715104645873664; |
89715 | 90026 | |
89716 | - state.addr = 18446744073709545864LLU; // 99999998kH''''''''''''''' | |
90027 | + state.addr = 18446744073709545849LLU; // 99999998j3''''''''''''''' | |
89717 | 90028 | break; |
89718 | 90029 | } |
89719 | - case 18446744073709545864LLU: // 99999998kH''''''''''''''' | |
90030 | + case 18446744073709545849LLU: // 99999998j3''''''''''''''' | |
89720 | 90031 | { |
89721 | 90032 | *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) = /*sym_______*/*LOCAL_ACCESS(heap.data, 19LLU, 18LLU) == /*callee_id_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 9LLU)); |
89722 | - state.addr = 18446744073709545863LLU; // 99999998kG''''''''''''''' | |
90033 | + state.addr = 18446744073709545848LLU; // 99999998j2''''''''''''''' | |
89723 | 90034 | break; |
89724 | 90035 | } |
89725 | - case 18446744073709545863LLU: // 99999998kG''''''''''''''' | |
90036 | + case 18446744073709545848LLU: // 99999998j2''''''''''''''' | |
89726 | 90037 | { |
89727 | - state.addr = *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) ? 18446744073709545862LLU : 18446744073709545861LLU; | |
90038 | + state.addr = *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) ? 18446744073709545847LLU : 18446744073709545846LLU; | |
89728 | 90039 | break; |
89729 | 90040 | } |
89730 | - case 18446744073709545862LLU: // 99999998kF''''''''''''''' | |
90041 | + case 18446744073709545847LLU: // 99999998j1''''''''''''''' | |
89731 | 90042 | { |
89732 | 90043 | // ACCUMULATE ARGUMENTS - BEGIN |
89733 | 90044 | { |
@@ -89795,7 +90106,7 @@ | ||
89795 | 90106 | LOCAL_PUSH_MOVE(&heap, 15LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
89796 | 90107 | } |
89797 | 90108 | // ACCUMULATE ARGUMENTS - END |
89798 | - uint64_t return_to = 18446744073709545859LLU; | |
90109 | + uint64_t return_to = 18446744073709545844LLU; | |
89799 | 90110 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 16LLU, 0/*address of closure-in-construction*/, 0)); |
89800 | 90111 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
89801 | 90112 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 16LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -89804,43 +90115,43 @@ | ||
89804 | 90115 | state.addr = 787472343680323584LLU; // procwhen__ |
89805 | 90116 | break; |
89806 | 90117 | } |
89807 | - case 18446744073709545859LLU: // 99999998kC''''''''''''''' | |
90118 | + case 18446744073709545844LLU: // 99999998jy''''''''''''''' | |
89808 | 90119 | { |
89809 | - state.addr = 18446744073709545860LLU; // 99999998kD''''''''''''''' | |
90120 | + state.addr = 18446744073709545845LLU; // 99999998jz''''''''''''''' | |
89810 | 90121 | break; |
89811 | 90122 | } |
89812 | - case 18446744073709545860LLU: // 99999998kD''''''''''''''' | |
90123 | + case 18446744073709545845LLU: // 99999998jz''''''''''''''' | |
89813 | 90124 | { |
89814 | 90125 | heap.availilable_size_for_dynamic_objects += 0LLU; |
89815 | 90126 | heap.availilable_size_for_dynamic_objects += 0LLU; |
89816 | - state.addr = 18446744073709545858LLU; // 99999998kB''''''''''''''' | |
90127 | + state.addr = 18446744073709545843LLU; // 99999998jx''''''''''''''' | |
89817 | 90128 | break; |
89818 | 90129 | } |
89819 | - case 18446744073709545861LLU: // 99999998kE''''''''''''''' | |
90130 | + case 18446744073709545846LLU: // 99999998j0''''''''''''''' | |
89820 | 90131 | { |
89821 | 90132 | |
89822 | - state.addr = 18446744073709545857LLU; // 99999998kA''''''''''''''' | |
90133 | + state.addr = 18446744073709545842LLU; // 99999998jw''''''''''''''' | |
89823 | 90134 | break; |
89824 | 90135 | } |
89825 | - case 18446744073709545857LLU: // 99999998kA''''''''''''''' | |
90136 | + case 18446744073709545842LLU: // 99999998jw''''''''''''''' | |
89826 | 90137 | { |
89827 | 90138 | *LOCAL_ACCESS(heap.data, 19LLU, 18LLU) = 657807020572803072; |
89828 | 90139 | |
89829 | - state.addr = 18446744073709545856LLU; // 99999998k_''''''''''''''' | |
90140 | + state.addr = 18446744073709545841LLU; // 99999998jv''''''''''''''' | |
89830 | 90141 | break; |
89831 | 90142 | } |
89832 | - case 18446744073709545856LLU: // 99999998k_''''''''''''''' | |
90143 | + case 18446744073709545841LLU: // 99999998jv''''''''''''''' | |
89833 | 90144 | { |
89834 | 90145 | *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) = /*sym_______*/*LOCAL_ACCESS(heap.data, 19LLU, 18LLU) == /*callee_id_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 9LLU)); |
89835 | - state.addr = 18446744073709545855LLU; // 99999998j9''''''''''''''' | |
90146 | + state.addr = 18446744073709545840LLU; // 99999998ju''''''''''''''' | |
89836 | 90147 | break; |
89837 | 90148 | } |
89838 | - case 18446744073709545855LLU: // 99999998j9''''''''''''''' | |
90149 | + case 18446744073709545840LLU: // 99999998ju''''''''''''''' | |
89839 | 90150 | { |
89840 | - state.addr = *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) ? 18446744073709545854LLU : 18446744073709545853LLU; | |
90151 | + state.addr = *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) ? 18446744073709545839LLU : 18446744073709545838LLU; | |
89841 | 90152 | break; |
89842 | 90153 | } |
89843 | - case 18446744073709545854LLU: // 99999998j8''''''''''''''' | |
90154 | + case 18446744073709545839LLU: // 99999998jt''''''''''''''' | |
89844 | 90155 | { |
89845 | 90156 | // ACCUMULATE ARGUMENTS - BEGIN |
89846 | 90157 | { |
@@ -89908,7 +90219,7 @@ | ||
89908 | 90219 | LOCAL_PUSH_MOVE(&heap, 15LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
89909 | 90220 | } |
89910 | 90221 | // ACCUMULATE ARGUMENTS - END |
89911 | - uint64_t return_to = 18446744073709545851LLU; | |
90222 | + uint64_t return_to = 18446744073709545836LLU; | |
89912 | 90223 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 16LLU, 0/*address of closure-in-construction*/, 0)); |
89913 | 90224 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
89914 | 90225 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 16LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -89917,43 +90228,43 @@ | ||
89917 | 90228 | state.addr = 787472328605827072LLU; // procif____ |
89918 | 90229 | break; |
89919 | 90230 | } |
89920 | - case 18446744073709545851LLU: // 99999998j5''''''''''''''' | |
90231 | + case 18446744073709545836LLU: // 99999998jq''''''''''''''' | |
89921 | 90232 | { |
89922 | - state.addr = 18446744073709545852LLU; // 99999998j6''''''''''''''' | |
90233 | + state.addr = 18446744073709545837LLU; // 99999998jr''''''''''''''' | |
89923 | 90234 | break; |
89924 | 90235 | } |
89925 | - case 18446744073709545852LLU: // 99999998j6''''''''''''''' | |
90236 | + case 18446744073709545837LLU: // 99999998jr''''''''''''''' | |
89926 | 90237 | { |
89927 | 90238 | heap.availilable_size_for_dynamic_objects += 0LLU; |
89928 | 90239 | heap.availilable_size_for_dynamic_objects += 0LLU; |
89929 | - state.addr = 18446744073709545850LLU; // 99999998j4''''''''''''''' | |
90240 | + state.addr = 18446744073709545835LLU; // 99999998jp''''''''''''''' | |
89930 | 90241 | break; |
89931 | 90242 | } |
89932 | - case 18446744073709545853LLU: // 99999998j7''''''''''''''' | |
90243 | + case 18446744073709545838LLU: // 99999998js''''''''''''''' | |
89933 | 90244 | { |
89934 | 90245 | |
89935 | - state.addr = 18446744073709545849LLU; // 99999998j3''''''''''''''' | |
90246 | + state.addr = 18446744073709545834LLU; // 99999998jo''''''''''''''' | |
89936 | 90247 | break; |
89937 | 90248 | } |
89938 | - case 18446744073709545849LLU: // 99999998j3''''''''''''''' | |
90249 | + case 18446744073709545834LLU: // 99999998jo''''''''''''''' | |
89939 | 90250 | { |
89940 | 90251 | *LOCAL_ACCESS(heap.data, 19LLU, 18LLU) = 512981598149279744; |
89941 | 90252 | |
89942 | - state.addr = 18446744073709545848LLU; // 99999998j2''''''''''''''' | |
90253 | + state.addr = 18446744073709545833LLU; // 99999998jn''''''''''''''' | |
89943 | 90254 | break; |
89944 | 90255 | } |
89945 | - case 18446744073709545848LLU: // 99999998j2''''''''''''''' | |
90256 | + case 18446744073709545833LLU: // 99999998jn''''''''''''''' | |
89946 | 90257 | { |
89947 | 90258 | *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) = /*sym_______*/*LOCAL_ACCESS(heap.data, 19LLU, 18LLU) == /*callee_id_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 9LLU)); |
89948 | - state.addr = 18446744073709545847LLU; // 99999998j1''''''''''''''' | |
90259 | + state.addr = 18446744073709545832LLU; // 99999998jm''''''''''''''' | |
89949 | 90260 | break; |
89950 | 90261 | } |
89951 | - case 18446744073709545847LLU: // 99999998j1''''''''''''''' | |
90262 | + case 18446744073709545832LLU: // 99999998jm''''''''''''''' | |
89952 | 90263 | { |
89953 | - state.addr = *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) ? 18446744073709545846LLU : 18446744073709545845LLU; | |
90264 | + state.addr = *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) ? 18446744073709545831LLU : 18446744073709545830LLU; | |
89954 | 90265 | break; |
89955 | 90266 | } |
89956 | - case 18446744073709545846LLU: // 99999998j0''''''''''''''' | |
90267 | + case 18446744073709545831LLU: // 99999998jl''''''''''''''' | |
89957 | 90268 | { |
89958 | 90269 | // ACCUMULATE ARGUMENTS - BEGIN |
89959 | 90270 | { |
@@ -90005,7 +90316,7 @@ | ||
90005 | 90316 | LOCAL_PUSH_MOVE(&heap, 11LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
90006 | 90317 | } |
90007 | 90318 | // ACCUMULATE ARGUMENTS - END |
90008 | - uint64_t return_to = 18446744073709545843LLU; | |
90319 | + uint64_t return_to = 18446744073709545828LLU; | |
90009 | 90320 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 12LLU, 0/*address of closure-in-construction*/, 0)); |
90010 | 90321 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
90011 | 90322 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 12LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -90014,43 +90325,43 @@ | ||
90014 | 90325 | state.addr = 787472319973559214LLU; // procaccess |
90015 | 90326 | break; |
90016 | 90327 | } |
90017 | - case 18446744073709545843LLU: // 99999998jx''''''''''''''' | |
90328 | + case 18446744073709545828LLU: // 99999998ji''''''''''''''' | |
90018 | 90329 | { |
90019 | - state.addr = 18446744073709545844LLU; // 99999998jy''''''''''''''' | |
90330 | + state.addr = 18446744073709545829LLU; // 99999998jj''''''''''''''' | |
90020 | 90331 | break; |
90021 | 90332 | } |
90022 | - case 18446744073709545844LLU: // 99999998jy''''''''''''''' | |
90333 | + case 18446744073709545829LLU: // 99999998jj''''''''''''''' | |
90023 | 90334 | { |
90024 | 90335 | heap.availilable_size_for_dynamic_objects += 0LLU; |
90025 | 90336 | heap.availilable_size_for_dynamic_objects += 0LLU; |
90026 | - state.addr = 18446744073709545842LLU; // 99999998jw''''''''''''''' | |
90337 | + state.addr = 18446744073709545827LLU; // 99999998jh''''''''''''''' | |
90027 | 90338 | break; |
90028 | 90339 | } |
90029 | - case 18446744073709545845LLU: // 99999998jz''''''''''''''' | |
90340 | + case 18446744073709545830LLU: // 99999998jk''''''''''''''' | |
90030 | 90341 | { |
90031 | 90342 | |
90032 | - state.addr = 18446744073709545841LLU; // 99999998jv''''''''''''''' | |
90343 | + state.addr = 18446744073709545826LLU; // 99999998jg''''''''''''''' | |
90033 | 90344 | break; |
90034 | 90345 | } |
90035 | - case 18446744073709545841LLU: // 99999998jv''''''''''''''' | |
90346 | + case 18446744073709545826LLU: // 99999998jg''''''''''''''' | |
90036 | 90347 | { |
90037 | 90348 | *LOCAL_ACCESS(heap.data, 19LLU, 18LLU) = 728666047090961088; |
90038 | 90349 | |
90039 | - state.addr = 18446744073709545840LLU; // 99999998ju''''''''''''''' | |
90350 | + state.addr = 18446744073709545825LLU; // 99999998jf''''''''''''''' | |
90040 | 90351 | break; |
90041 | 90352 | } |
90042 | - case 18446744073709545840LLU: // 99999998ju''''''''''''''' | |
90353 | + case 18446744073709545825LLU: // 99999998jf''''''''''''''' | |
90043 | 90354 | { |
90044 | 90355 | *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) = /*sym_______*/*LOCAL_ACCESS(heap.data, 19LLU, 18LLU) == /*callee_id_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 9LLU)); |
90045 | - state.addr = 18446744073709545839LLU; // 99999998jt''''''''''''''' | |
90356 | + state.addr = 18446744073709545824LLU; // 99999998je''''''''''''''' | |
90046 | 90357 | break; |
90047 | 90358 | } |
90048 | - case 18446744073709545839LLU: // 99999998jt''''''''''''''' | |
90359 | + case 18446744073709545824LLU: // 99999998je''''''''''''''' | |
90049 | 90360 | { |
90050 | - state.addr = *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) ? 18446744073709545838LLU : 18446744073709545837LLU; | |
90361 | + state.addr = *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) ? 18446744073709545823LLU : 18446744073709545822LLU; | |
90051 | 90362 | break; |
90052 | 90363 | } |
90053 | - case 18446744073709545838LLU: // 99999998js''''''''''''''' | |
90364 | + case 18446744073709545823LLU: // 99999998jd''''''''''''''' | |
90054 | 90365 | { |
90055 | 90366 | // ACCUMULATE ARGUMENTS - BEGIN |
90056 | 90367 | { |
@@ -90102,7 +90413,7 @@ | ||
90102 | 90413 | LOCAL_PUSH_MOVE(&heap, 11LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
90103 | 90414 | } |
90104 | 90415 | // ACCUMULATE ARGUMENTS - END |
90105 | - uint64_t return_to = 18446744073709545835LLU; | |
90416 | + uint64_t return_to = 18446744073709545820LLU; | |
90106 | 90417 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 12LLU, 0/*address of closure-in-construction*/, 0)); |
90107 | 90418 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
90108 | 90419 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 12LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -90111,43 +90422,43 @@ | ||
90111 | 90422 | state.addr = 787463406844050091LLU; // prmatchtop |
90112 | 90423 | break; |
90113 | 90424 | } |
90114 | - case 18446744073709545835LLU: // 99999998jp''''''''''''''' | |
90425 | + case 18446744073709545820LLU: // 99999998ja''''''''''''''' | |
90115 | 90426 | { |
90116 | - state.addr = 18446744073709545836LLU; // 99999998jq''''''''''''''' | |
90427 | + state.addr = 18446744073709545821LLU; // 99999998jb''''''''''''''' | |
90117 | 90428 | break; |
90118 | 90429 | } |
90119 | - case 18446744073709545836LLU: // 99999998jq''''''''''''''' | |
90430 | + case 18446744073709545821LLU: // 99999998jb''''''''''''''' | |
90120 | 90431 | { |
90121 | 90432 | heap.availilable_size_for_dynamic_objects += 0LLU; |
90122 | 90433 | heap.availilable_size_for_dynamic_objects += 0LLU; |
90123 | - state.addr = 18446744073709545834LLU; // 99999998jo''''''''''''''' | |
90434 | + state.addr = 18446744073709545819LLU; // 99999998j$''''''''''''''' | |
90124 | 90435 | break; |
90125 | 90436 | } |
90126 | - case 18446744073709545837LLU: // 99999998jr''''''''''''''' | |
90437 | + case 18446744073709545822LLU: // 99999998jc''''''''''''''' | |
90127 | 90438 | { |
90128 | 90439 | |
90129 | - state.addr = 18446744073709545833LLU; // 99999998jn''''''''''''''' | |
90440 | + state.addr = 18446744073709545818LLU; // 99999998jZ''''''''''''''' | |
90130 | 90441 | break; |
90131 | 90442 | } |
90132 | - case 18446744073709545833LLU: // 99999998jn''''''''''''''' | |
90443 | + case 18446744073709545818LLU: // 99999998jZ''''''''''''''' | |
90133 | 90444 | { |
90134 | 90445 | *LOCAL_ACCESS(heap.data, 19LLU, 18LLU) = 657999485095758119; |
90135 | 90446 | |
90136 | - state.addr = 18446744073709545832LLU; // 99999998jm''''''''''''''' | |
90447 | + state.addr = 18446744073709545817LLU; // 99999998jY''''''''''''''' | |
90137 | 90448 | break; |
90138 | 90449 | } |
90139 | - case 18446744073709545832LLU: // 99999998jm''''''''''''''' | |
90450 | + case 18446744073709545817LLU: // 99999998jY''''''''''''''' | |
90140 | 90451 | { |
90141 | 90452 | *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) = /*sym_______*/*LOCAL_ACCESS(heap.data, 19LLU, 18LLU) == /*callee_id_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 9LLU)); |
90142 | - state.addr = 18446744073709545831LLU; // 99999998jl''''''''''''''' | |
90453 | + state.addr = 18446744073709545816LLU; // 99999998jX''''''''''''''' | |
90143 | 90454 | break; |
90144 | 90455 | } |
90145 | - case 18446744073709545831LLU: // 99999998jl''''''''''''''' | |
90456 | + case 18446744073709545816LLU: // 99999998jX''''''''''''''' | |
90146 | 90457 | { |
90147 | - state.addr = *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) ? 18446744073709545830LLU : 18446744073709545829LLU; | |
90458 | + state.addr = *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) ? 18446744073709545815LLU : 18446744073709545814LLU; | |
90148 | 90459 | break; |
90149 | 90460 | } |
90150 | - case 18446744073709545830LLU: // 99999998jk''''''''''''''' | |
90461 | + case 18446744073709545815LLU: // 99999998jW''''''''''''''' | |
90151 | 90462 | { |
90152 | 90463 | // ACCUMULATE ARGUMENTS - BEGIN |
90153 | 90464 | { |
@@ -90215,7 +90526,7 @@ | ||
90215 | 90526 | LOCAL_PUSH_MOVE(&heap, 15LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
90216 | 90527 | } |
90217 | 90528 | // ACCUMULATE ARGUMENTS - END |
90218 | - uint64_t return_to = 18446744073709545827LLU; | |
90529 | + uint64_t return_to = 18446744073709545812LLU; | |
90219 | 90530 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 16LLU, 0/*address of closure-in-construction*/, 0)); |
90220 | 90531 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
90221 | 90532 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 16LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -90224,43 +90535,43 @@ | ||
90224 | 90535 | state.addr = 787420730272713635LLU; // prctrypush |
90225 | 90536 | break; |
90226 | 90537 | } |
90227 | - case 18446744073709545827LLU: // 99999998jh''''''''''''''' | |
90538 | + case 18446744073709545812LLU: // 99999998jT''''''''''''''' | |
90228 | 90539 | { |
90229 | - state.addr = 18446744073709545828LLU; // 99999998ji''''''''''''''' | |
90540 | + state.addr = 18446744073709545813LLU; // 99999998jU''''''''''''''' | |
90230 | 90541 | break; |
90231 | 90542 | } |
90232 | - case 18446744073709545828LLU: // 99999998ji''''''''''''''' | |
90543 | + case 18446744073709545813LLU: // 99999998jU''''''''''''''' | |
90233 | 90544 | { |
90234 | 90545 | heap.availilable_size_for_dynamic_objects += 0LLU; |
90235 | 90546 | heap.availilable_size_for_dynamic_objects += 0LLU; |
90236 | - state.addr = 18446744073709545826LLU; // 99999998jg''''''''''''''' | |
90547 | + state.addr = 18446744073709545811LLU; // 99999998jS''''''''''''''' | |
90237 | 90548 | break; |
90238 | 90549 | } |
90239 | - case 18446744073709545829LLU: // 99999998jj''''''''''''''' | |
90550 | + case 18446744073709545814LLU: // 99999998jV''''''''''''''' | |
90240 | 90551 | { |
90241 | 90552 | |
90242 | - state.addr = 18446744073709545825LLU; // 99999998jf''''''''''''''' | |
90553 | + state.addr = 18446744073709545810LLU; // 99999998jR''''''''''''''' | |
90243 | 90554 | break; |
90244 | 90555 | } |
90245 | - case 18446744073709545825LLU: // 99999998jf''''''''''''''' | |
90556 | + case 18446744073709545810LLU: // 99999998jR''''''''''''''' | |
90246 | 90557 | { |
90247 | 90558 | *LOCAL_ACCESS(heap.data, 19LLU, 18LLU) = 819872884582252544; |
90248 | 90559 | |
90249 | - state.addr = 18446744073709545824LLU; // 99999998je''''''''''''''' | |
90560 | + state.addr = 18446744073709545809LLU; // 99999998jQ''''''''''''''' | |
90250 | 90561 | break; |
90251 | 90562 | } |
90252 | - case 18446744073709545824LLU: // 99999998je''''''''''''''' | |
90563 | + case 18446744073709545809LLU: // 99999998jQ''''''''''''''' | |
90253 | 90564 | { |
90254 | 90565 | *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) = /*sym_______*/*LOCAL_ACCESS(heap.data, 19LLU, 18LLU) == /*callee_id_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 9LLU)); |
90255 | - state.addr = 18446744073709545823LLU; // 99999998jd''''''''''''''' | |
90566 | + state.addr = 18446744073709545808LLU; // 99999998jP''''''''''''''' | |
90256 | 90567 | break; |
90257 | 90568 | } |
90258 | - case 18446744073709545823LLU: // 99999998jd''''''''''''''' | |
90569 | + case 18446744073709545808LLU: // 99999998jP''''''''''''''' | |
90259 | 90570 | { |
90260 | - state.addr = *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) ? 18446744073709545822LLU : 18446744073709545821LLU; | |
90571 | + state.addr = *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) ? 18446744073709545807LLU : 18446744073709545806LLU; | |
90261 | 90572 | break; |
90262 | 90573 | } |
90263 | - case 18446744073709545822LLU: // 99999998jc''''''''''''''' | |
90574 | + case 18446744073709545807LLU: // 99999998jO''''''''''''''' | |
90264 | 90575 | { |
90265 | 90576 | // ACCUMULATE ARGUMENTS - BEGIN |
90266 | 90577 | { |
@@ -90300,7 +90611,7 @@ | ||
90300 | 90611 | LOCAL_PUSH_MOVE(&heap, 8LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
90301 | 90612 | } |
90302 | 90613 | // ACCUMULATE ARGUMENTS - END |
90303 | - uint64_t return_to = 18446744073709545819LLU; | |
90614 | + uint64_t return_to = 18446744073709545804LLU; | |
90304 | 90615 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 9LLU, 0/*address of closure-in-construction*/, 0)); |
90305 | 90616 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
90306 | 90617 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 9LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -90309,43 +90620,43 @@ | ||
90309 | 90620 | state.addr = 787472338265571328LLU; // procrev___ |
90310 | 90621 | break; |
90311 | 90622 | } |
90312 | - case 18446744073709545819LLU: // 99999998j$''''''''''''''' | |
90623 | + case 18446744073709545804LLU: // 99999998jL''''''''''''''' | |
90313 | 90624 | { |
90314 | - state.addr = 18446744073709545820LLU; // 99999998ja''''''''''''''' | |
90625 | + state.addr = 18446744073709545805LLU; // 99999998jM''''''''''''''' | |
90315 | 90626 | break; |
90316 | 90627 | } |
90317 | - case 18446744073709545820LLU: // 99999998ja''''''''''''''' | |
90628 | + case 18446744073709545805LLU: // 99999998jM''''''''''''''' | |
90318 | 90629 | { |
90319 | 90630 | heap.availilable_size_for_dynamic_objects += 0LLU; |
90320 | 90631 | heap.availilable_size_for_dynamic_objects += 0LLU; |
90321 | - state.addr = 18446744073709545818LLU; // 99999998jZ''''''''''''''' | |
90632 | + state.addr = 18446744073709545803LLU; // 99999998jK''''''''''''''' | |
90322 | 90633 | break; |
90323 | 90634 | } |
90324 | - case 18446744073709545821LLU: // 99999998jb''''''''''''''' | |
90635 | + case 18446744073709545806LLU: // 99999998jN''''''''''''''' | |
90325 | 90636 | { |
90326 | 90637 | |
90327 | - state.addr = 18446744073709545817LLU; // 99999998jY''''''''''''''' | |
90638 | + state.addr = 18446744073709545802LLU; // 99999998jJ''''''''''''''' | |
90328 | 90639 | break; |
90329 | 90640 | } |
90330 | - case 18446744073709545817LLU: // 99999998jY''''''''''''''' | |
90641 | + case 18446744073709545802LLU: // 99999998jJ''''''''''''''' | |
90331 | 90642 | { |
90332 | 90643 | *LOCAL_ACCESS(heap.data, 19LLU, 18LLU) = 839030726086098944; |
90333 | 90644 | |
90334 | - state.addr = 18446744073709545816LLU; // 99999998jX''''''''''''''' | |
90645 | + state.addr = 18446744073709545801LLU; // 99999998jI''''''''''''''' | |
90335 | 90646 | break; |
90336 | 90647 | } |
90337 | - case 18446744073709545816LLU: // 99999998jX''''''''''''''' | |
90648 | + case 18446744073709545801LLU: // 99999998jI''''''''''''''' | |
90338 | 90649 | { |
90339 | 90650 | *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) = /*sym_______*/*LOCAL_ACCESS(heap.data, 19LLU, 18LLU) == /*callee_id_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 9LLU)); |
90340 | - state.addr = 18446744073709545815LLU; // 99999998jW''''''''''''''' | |
90651 | + state.addr = 18446744073709545800LLU; // 99999998jH''''''''''''''' | |
90341 | 90652 | break; |
90342 | 90653 | } |
90343 | - case 18446744073709545815LLU: // 99999998jW''''''''''''''' | |
90654 | + case 18446744073709545800LLU: // 99999998jH''''''''''''''' | |
90344 | 90655 | { |
90345 | - state.addr = *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) ? 18446744073709545814LLU : 18446744073709545813LLU; | |
90656 | + state.addr = *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) ? 18446744073709545799LLU : 18446744073709545798LLU; | |
90346 | 90657 | break; |
90347 | 90658 | } |
90348 | - case 18446744073709545814LLU: // 99999998jV''''''''''''''' | |
90659 | + case 18446744073709545799LLU: // 99999998jG''''''''''''''' | |
90349 | 90660 | { |
90350 | 90661 | // ACCUMULATE ARGUMENTS - BEGIN |
90351 | 90662 | { |
@@ -90385,7 +90696,7 @@ | ||
90385 | 90696 | LOCAL_PUSH_MOVE(&heap, 8LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
90386 | 90697 | } |
90387 | 90698 | // ACCUMULATE ARGUMENTS - END |
90388 | - uint64_t return_to = 18446744073709545811LLU; | |
90699 | + uint64_t return_to = 18446744073709545796LLU; | |
90389 | 90700 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 9LLU, 0/*address of closure-in-construction*/, 0)); |
90390 | 90701 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
90391 | 90702 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 9LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -90394,43 +90705,43 @@ | ||
90394 | 90705 | state.addr = 787472339407601664LLU; // procsize__ |
90395 | 90706 | break; |
90396 | 90707 | } |
90397 | - case 18446744073709545811LLU: // 99999998jS''''''''''''''' | |
90708 | + case 18446744073709545796LLU: // 99999998jD''''''''''''''' | |
90398 | 90709 | { |
90399 | - state.addr = 18446744073709545812LLU; // 99999998jT''''''''''''''' | |
90710 | + state.addr = 18446744073709545797LLU; // 99999998jE''''''''''''''' | |
90400 | 90711 | break; |
90401 | 90712 | } |
90402 | - case 18446744073709545812LLU: // 99999998jT''''''''''''''' | |
90713 | + case 18446744073709545797LLU: // 99999998jE''''''''''''''' | |
90403 | 90714 | { |
90404 | 90715 | heap.availilable_size_for_dynamic_objects += 0LLU; |
90405 | 90716 | heap.availilable_size_for_dynamic_objects += 0LLU; |
90406 | - state.addr = 18446744073709545810LLU; // 99999998jR''''''''''''''' | |
90717 | + state.addr = 18446744073709545795LLU; // 99999998jC''''''''''''''' | |
90407 | 90718 | break; |
90408 | 90719 | } |
90409 | - case 18446744073709545813LLU: // 99999998jU''''''''''''''' | |
90720 | + case 18446744073709545798LLU: // 99999998jF''''''''''''''' | |
90410 | 90721 | { |
90411 | 90722 | |
90412 | - state.addr = 18446744073709545809LLU; // 99999998jQ''''''''''''''' | |
90723 | + state.addr = 18446744073709545794LLU; // 99999998jB''''''''''''''' | |
90413 | 90724 | break; |
90414 | 90725 | } |
90415 | - case 18446744073709545809LLU: // 99999998jQ''''''''''''''' | |
90726 | + case 18446744073709545794LLU: // 99999998jB''''''''''''''' | |
90416 | 90727 | { |
90417 | 90728 | *LOCAL_ACCESS(heap.data, 19LLU, 18LLU) = 842862180511514624; |
90418 | 90729 | |
90419 | - state.addr = 18446744073709545808LLU; // 99999998jP''''''''''''''' | |
90730 | + state.addr = 18446744073709545793LLU; // 99999998jA''''''''''''''' | |
90420 | 90731 | break; |
90421 | 90732 | } |
90422 | - case 18446744073709545808LLU: // 99999998jP''''''''''''''' | |
90733 | + case 18446744073709545793LLU: // 99999998jA''''''''''''''' | |
90423 | 90734 | { |
90424 | 90735 | *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) = /*sym_______*/*LOCAL_ACCESS(heap.data, 19LLU, 18LLU) == /*callee_id_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 9LLU)); |
90425 | - state.addr = 18446744073709545807LLU; // 99999998jO''''''''''''''' | |
90736 | + state.addr = 18446744073709545792LLU; // 99999998j_''''''''''''''' | |
90426 | 90737 | break; |
90427 | 90738 | } |
90428 | - case 18446744073709545807LLU: // 99999998jO''''''''''''''' | |
90739 | + case 18446744073709545792LLU: // 99999998j_''''''''''''''' | |
90429 | 90740 | { |
90430 | - state.addr = *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) ? 18446744073709545806LLU : 18446744073709545805LLU; | |
90741 | + state.addr = *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) ? 18446744073709545791LLU : 18446744073709545790LLU; | |
90431 | 90742 | break; |
90432 | 90743 | } |
90433 | - case 18446744073709545806LLU: // 99999998jN''''''''''''''' | |
90744 | + case 18446744073709545791LLU: // 99999998i9''''''''''''''' | |
90434 | 90745 | { |
90435 | 90746 | // ACCUMULATE ARGUMENTS - BEGIN |
90436 | 90747 | { |
@@ -90474,7 +90785,7 @@ | ||
90474 | 90785 | LOCAL_PUSH_MOVE(&heap, 9LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
90475 | 90786 | } |
90476 | 90787 | // ACCUMULATE ARGUMENTS - END |
90477 | - uint64_t return_to = 18446744073709545803LLU; | |
90788 | + uint64_t return_to = 18446744073709545788LLU; | |
90478 | 90789 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 10LLU, 0/*address of closure-in-construction*/, 0)); |
90479 | 90790 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
90480 | 90791 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 10LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -90483,43 +90794,43 @@ | ||
90483 | 90794 | state.addr = 787472339635974144LLU; // procswap__ |
90484 | 90795 | break; |
90485 | 90796 | } |
90486 | - case 18446744073709545803LLU: // 99999998jK''''''''''''''' | |
90797 | + case 18446744073709545788LLU: // 99999998i6''''''''''''''' | |
90487 | 90798 | { |
90488 | - state.addr = 18446744073709545804LLU; // 99999998jL''''''''''''''' | |
90799 | + state.addr = 18446744073709545789LLU; // 99999998i7''''''''''''''' | |
90489 | 90800 | break; |
90490 | 90801 | } |
90491 | - case 18446744073709545804LLU: // 99999998jL''''''''''''''' | |
90802 | + case 18446744073709545789LLU: // 99999998i7''''''''''''''' | |
90492 | 90803 | { |
90493 | 90804 | heap.availilable_size_for_dynamic_objects += 0LLU; |
90494 | 90805 | heap.availilable_size_for_dynamic_objects += 0LLU; |
90495 | - state.addr = 18446744073709545802LLU; // 99999998jJ''''''''''''''' | |
90806 | + state.addr = 18446744073709545787LLU; // 99999998i5''''''''''''''' | |
90496 | 90807 | break; |
90497 | 90808 | } |
90498 | - case 18446744073709545805LLU: // 99999998jM''''''''''''''' | |
90809 | + case 18446744073709545790LLU: // 99999998i8''''''''''''''' | |
90499 | 90810 | { |
90500 | 90811 | |
90501 | - state.addr = 18446744073709545801LLU; // 99999998jI''''''''''''''' | |
90812 | + state.addr = 18446744073709545786LLU; // 99999998i4''''''''''''''' | |
90502 | 90813 | break; |
90503 | 90814 | } |
90504 | - case 18446744073709545801LLU: // 99999998jI''''''''''''''' | |
90815 | + case 18446744073709545786LLU: // 99999998i4''''''''''''''' | |
90505 | 90816 | { |
90506 | 90817 | *LOCAL_ACCESS(heap.data, 19LLU, 18LLU) = 711775449310560256; |
90507 | 90818 | |
90508 | - state.addr = 18446744073709545800LLU; // 99999998jH''''''''''''''' | |
90819 | + state.addr = 18446744073709545785LLU; // 99999998i3''''''''''''''' | |
90509 | 90820 | break; |
90510 | 90821 | } |
90511 | - case 18446744073709545800LLU: // 99999998jH''''''''''''''' | |
90822 | + case 18446744073709545785LLU: // 99999998i3''''''''''''''' | |
90512 | 90823 | { |
90513 | 90824 | *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) = /*sym_______*/*LOCAL_ACCESS(heap.data, 19LLU, 18LLU) == /*callee_id_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 9LLU)); |
90514 | - state.addr = 18446744073709545799LLU; // 99999998jG''''''''''''''' | |
90825 | + state.addr = 18446744073709545784LLU; // 99999998i2''''''''''''''' | |
90515 | 90826 | break; |
90516 | 90827 | } |
90517 | - case 18446744073709545799LLU: // 99999998jG''''''''''''''' | |
90828 | + case 18446744073709545784LLU: // 99999998i2''''''''''''''' | |
90518 | 90829 | { |
90519 | - state.addr = *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) ? 18446744073709545798LLU : 18446744073709545797LLU; | |
90830 | + state.addr = *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 0LLU)) ? 18446744073709545783LLU : 18446744073709545782LLU; | |
90520 | 90831 | break; |
90521 | 90832 | } |
90522 | - case 18446744073709545798LLU: // 99999998jF''''''''''''''' | |
90833 | + case 18446744073709545783LLU: // 99999998i1''''''''''''''' | |
90523 | 90834 | { |
90524 | 90835 | // ACCUMULATE ARGUMENTS - BEGIN |
90525 | 90836 | { |
@@ -90587,7 +90898,7 @@ | ||
90587 | 90898 | LOCAL_PUSH_MOVE(&heap, 15LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
90588 | 90899 | } |
90589 | 90900 | // ACCUMULATE ARGUMENTS - END |
90590 | - uint64_t return_to = 18446744073709545795LLU; | |
90901 | + uint64_t return_to = 18446744073709545780LLU; | |
90591 | 90902 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 16LLU, 0/*address of closure-in-construction*/, 0)); |
90592 | 90903 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
90593 | 90904 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 16LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -90596,119 +90907,119 @@ | ||
90596 | 90907 | state.addr = 787472331822596096LLU; // proclet___ |
90597 | 90908 | break; |
90598 | 90909 | } |
90599 | - case 18446744073709545795LLU: // 99999998jC''''''''''''''' | |
90910 | + case 18446744073709545780LLU: // 99999998iy''''''''''''''' | |
90600 | 90911 | { |
90601 | - state.addr = 18446744073709545796LLU; // 99999998jD''''''''''''''' | |
90912 | + state.addr = 18446744073709545781LLU; // 99999998iz''''''''''''''' | |
90602 | 90913 | break; |
90603 | 90914 | } |
90604 | - case 18446744073709545796LLU: // 99999998jD''''''''''''''' | |
90915 | + case 18446744073709545781LLU: // 99999998iz''''''''''''''' | |
90605 | 90916 | { |
90606 | 90917 | heap.availilable_size_for_dynamic_objects += 0LLU; |
90607 | 90918 | heap.availilable_size_for_dynamic_objects += 0LLU; |
90608 | - state.addr = 18446744073709545794LLU; // 99999998jB''''''''''''''' | |
90919 | + state.addr = 18446744073709545779LLU; // 99999998ix''''''''''''''' | |
90609 | 90920 | break; |
90610 | 90921 | } |
90611 | - case 18446744073709545797LLU: // 99999998jE''''''''''''''' | |
90922 | + case 18446744073709545782LLU: // 99999998i0''''''''''''''' | |
90612 | 90923 | { |
90613 | - state.addr = 18446744073709545794LLU; // 99999998jB''''''''''''''' | |
90924 | + state.addr = 18446744073709545779LLU; // 99999998ix''''''''''''''' | |
90614 | 90925 | break; |
90615 | 90926 | } |
90616 | - case 18446744073709545794LLU: // 99999998jB''''''''''''''' | |
90927 | + case 18446744073709545779LLU: // 99999998ix''''''''''''''' | |
90617 | 90928 | { |
90618 | - state.addr = 18446744073709545802LLU; // 99999998jJ''''''''''''''' | |
90929 | + state.addr = 18446744073709545787LLU; // 99999998i5''''''''''''''' | |
90619 | 90930 | break; |
90620 | 90931 | } |
90621 | - case 18446744073709545802LLU: // 99999998jJ''''''''''''''' | |
90932 | + case 18446744073709545787LLU: // 99999998i5''''''''''''''' | |
90622 | 90933 | { |
90623 | - state.addr = 18446744073709545810LLU; // 99999998jR''''''''''''''' | |
90934 | + state.addr = 18446744073709545795LLU; // 99999998jC''''''''''''''' | |
90624 | 90935 | break; |
90625 | 90936 | } |
90626 | - case 18446744073709545810LLU: // 99999998jR''''''''''''''' | |
90937 | + case 18446744073709545795LLU: // 99999998jC''''''''''''''' | |
90627 | 90938 | { |
90628 | - state.addr = 18446744073709545818LLU; // 99999998jZ''''''''''''''' | |
90939 | + state.addr = 18446744073709545803LLU; // 99999998jK''''''''''''''' | |
90629 | 90940 | break; |
90630 | 90941 | } |
90631 | - case 18446744073709545818LLU: // 99999998jZ''''''''''''''' | |
90942 | + case 18446744073709545803LLU: // 99999998jK''''''''''''''' | |
90632 | 90943 | { |
90633 | - state.addr = 18446744073709545826LLU; // 99999998jg''''''''''''''' | |
90944 | + state.addr = 18446744073709545811LLU; // 99999998jS''''''''''''''' | |
90634 | 90945 | break; |
90635 | 90946 | } |
90636 | - case 18446744073709545826LLU: // 99999998jg''''''''''''''' | |
90947 | + case 18446744073709545811LLU: // 99999998jS''''''''''''''' | |
90637 | 90948 | { |
90638 | - state.addr = 18446744073709545834LLU; // 99999998jo''''''''''''''' | |
90949 | + state.addr = 18446744073709545819LLU; // 99999998j$''''''''''''''' | |
90639 | 90950 | break; |
90640 | 90951 | } |
90641 | - case 18446744073709545834LLU: // 99999998jo''''''''''''''' | |
90952 | + case 18446744073709545819LLU: // 99999998j$''''''''''''''' | |
90642 | 90953 | { |
90643 | - state.addr = 18446744073709545842LLU; // 99999998jw''''''''''''''' | |
90954 | + state.addr = 18446744073709545827LLU; // 99999998jh''''''''''''''' | |
90644 | 90955 | break; |
90645 | 90956 | } |
90646 | - case 18446744073709545842LLU: // 99999998jw''''''''''''''' | |
90957 | + case 18446744073709545827LLU: // 99999998jh''''''''''''''' | |
90647 | 90958 | { |
90648 | - state.addr = 18446744073709545850LLU; // 99999998j4''''''''''''''' | |
90959 | + state.addr = 18446744073709545835LLU; // 99999998jp''''''''''''''' | |
90649 | 90960 | break; |
90650 | 90961 | } |
90651 | - case 18446744073709545850LLU: // 99999998j4''''''''''''''' | |
90962 | + case 18446744073709545835LLU: // 99999998jp''''''''''''''' | |
90652 | 90963 | { |
90653 | - state.addr = 18446744073709545858LLU; // 99999998kB''''''''''''''' | |
90964 | + state.addr = 18446744073709545843LLU; // 99999998jx''''''''''''''' | |
90654 | 90965 | break; |
90655 | 90966 | } |
90656 | - case 18446744073709545858LLU: // 99999998kB''''''''''''''' | |
90967 | + case 18446744073709545843LLU: // 99999998jx''''''''''''''' | |
90657 | 90968 | { |
90658 | - state.addr = 18446744073709545866LLU; // 99999998kJ''''''''''''''' | |
90969 | + state.addr = 18446744073709545851LLU; // 99999998j5''''''''''''''' | |
90659 | 90970 | break; |
90660 | 90971 | } |
90661 | - case 18446744073709545866LLU: // 99999998kJ''''''''''''''' | |
90972 | + case 18446744073709545851LLU: // 99999998j5''''''''''''''' | |
90662 | 90973 | { |
90663 | - state.addr = 18446744073709545874LLU; // 99999998kR''''''''''''''' | |
90974 | + state.addr = 18446744073709545859LLU; // 99999998kC''''''''''''''' | |
90664 | 90975 | break; |
90665 | 90976 | } |
90666 | - case 18446744073709545874LLU: // 99999998kR''''''''''''''' | |
90977 | + case 18446744073709545859LLU: // 99999998kC''''''''''''''' | |
90667 | 90978 | { |
90668 | - state.addr = 18446744073709545882LLU; // 99999998kZ''''''''''''''' | |
90979 | + state.addr = 18446744073709545867LLU; // 99999998kK''''''''''''''' | |
90669 | 90980 | break; |
90670 | 90981 | } |
90671 | - case 18446744073709545882LLU: // 99999998kZ''''''''''''''' | |
90982 | + case 18446744073709545867LLU: // 99999998kK''''''''''''''' | |
90672 | 90983 | { |
90673 | - state.addr = 18446744073709545890LLU; // 99999998kg''''''''''''''' | |
90984 | + state.addr = 18446744073709545875LLU; // 99999998kS''''''''''''''' | |
90674 | 90985 | break; |
90675 | 90986 | } |
90676 | - case 18446744073709545890LLU: // 99999998kg''''''''''''''' | |
90987 | + case 18446744073709545875LLU: // 99999998kS''''''''''''''' | |
90677 | 90988 | { |
90678 | - state.addr = 18446744073709545898LLU; // 99999998ko''''''''''''''' | |
90989 | + state.addr = 18446744073709545883LLU; // 99999998k$''''''''''''''' | |
90679 | 90990 | break; |
90680 | 90991 | } |
90681 | - case 18446744073709545898LLU: // 99999998ko''''''''''''''' | |
90992 | + case 18446744073709545883LLU: // 99999998k$''''''''''''''' | |
90682 | 90993 | { |
90683 | - state.addr = 18446744073709545906LLU; // 99999998kw''''''''''''''' | |
90994 | + state.addr = 18446744073709545891LLU; // 99999998kh''''''''''''''' | |
90684 | 90995 | break; |
90685 | 90996 | } |
90686 | - case 18446744073709545906LLU: // 99999998kw''''''''''''''' | |
90997 | + case 18446744073709545891LLU: // 99999998kh''''''''''''''' | |
90687 | 90998 | { |
90688 | - state.addr = 18446744073709545914LLU; // 99999998k4''''''''''''''' | |
90999 | + state.addr = 18446744073709545899LLU; // 99999998kp''''''''''''''' | |
90689 | 91000 | break; |
90690 | 91001 | } |
90691 | - case 18446744073709545914LLU: // 99999998k4''''''''''''''' | |
91002 | + case 18446744073709545899LLU: // 99999998kp''''''''''''''' | |
90692 | 91003 | { |
90693 | - state.addr = 18446744073709545922LLU; // 99999998lB''''''''''''''' | |
91004 | + state.addr = 18446744073709545907LLU; // 99999998kx''''''''''''''' | |
90694 | 91005 | break; |
90695 | 91006 | } |
90696 | - case 18446744073709545922LLU: // 99999998lB''''''''''''''' | |
91007 | + case 18446744073709545907LLU: // 99999998kx''''''''''''''' | |
90697 | 91008 | { |
90698 | - state.addr = 18446744073709545930LLU; // 99999998lJ''''''''''''''' | |
91009 | + state.addr = 18446744073709545915LLU; // 99999998k5''''''''''''''' | |
90699 | 91010 | break; |
90700 | 91011 | } |
90701 | - case 18446744073709545930LLU: // 99999998lJ''''''''''''''' | |
91012 | + case 18446744073709545915LLU: // 99999998k5''''''''''''''' | |
90702 | 91013 | { |
90703 | - state.addr = 18446744073709545938LLU; // 99999998lR''''''''''''''' | |
91014 | + state.addr = 18446744073709545923LLU; // 99999998lC''''''''''''''' | |
90704 | 91015 | break; |
90705 | 91016 | } |
90706 | - case 18446744073709545938LLU: // 99999998lR''''''''''''''' | |
91017 | + case 18446744073709545923LLU: // 99999998lC''''''''''''''' | |
90707 | 91018 | { |
90708 | - state.addr = 18446744073709545946LLU; // 99999998lZ''''''''''''''' | |
91019 | + state.addr = 18446744073709545931LLU; // 99999998lK''''''''''''''' | |
90709 | 91020 | break; |
90710 | 91021 | } |
90711 | - case 18446744073709545946LLU: // 99999998lZ''''''''''''''' | |
91022 | + case 18446744073709545931LLU: // 99999998lK''''''''''''''' | |
90712 | 91023 | { |
90713 | 91024 | // variable u64 sym_______ goes out of scope |
90714 | 91025 | // emitted destructur for type u64 |
@@ -90769,21 +91080,21 @@ | ||
90769 | 91080 | LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
90770 | 91081 | } |
90771 | 91082 | *LOCAL_ACCESS(heap.data, 7LLU, 6LLU) = /*sym_______*/*LOCAL_ACCESS(heap.data, 7LLU, 5LLU) == /*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 7LLU, 4LLU)); |
90772 | - state.addr = 18446744073709545791LLU; // 99999998i9''''''''''''''' | |
91083 | + state.addr = 18446744073709545776LLU; // 99999998iu''''''''''''''' | |
90773 | 91084 | break; |
90774 | 91085 | } |
90775 | - case 18446744073709545791LLU: // 99999998i9''''''''''''''' | |
91086 | + case 18446744073709545776LLU: // 99999998iu''''''''''''''' | |
90776 | 91087 | { |
90777 | - state.addr = *LOCAL_ACCESS(heap.data, 7LLU, 6LLU) ? 18446744073709545793LLU : 18446744073709545792LLU; | |
91088 | + state.addr = *LOCAL_ACCESS(heap.data, 7LLU, 6LLU) ? 18446744073709545778LLU : 18446744073709545777LLU; | |
90778 | 91089 | (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 7 |
90779 | 91090 | break; |
90780 | 91091 | } |
90781 | - case 18446744073709545793LLU: // 99999998jA''''''''''''''' | |
91092 | + case 18446744073709545778LLU: // 99999998iw''''''''''''''' | |
90782 | 91093 | { |
90783 | - state.addr = *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 6LLU, 3LLU)) ? 18446744073709545790LLU : 18446744073709545789LLU; | |
91094 | + state.addr = *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 6LLU, 3LLU)) ? 18446744073709545775LLU : 18446744073709545774LLU; | |
90784 | 91095 | break; |
90785 | 91096 | } |
90786 | - case 18446744073709545790LLU: // 99999998i8''''''''''''''' | |
91097 | + case 18446744073709545775LLU: // 99999998it''''''''''''''' | |
90787 | 91098 | { |
90788 | 91099 | fprintf(stderr, "%s", "function "); |
90789 | 91100 | printid(stderr, /*def_id____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 6LLU, 0LLU))); |
@@ -90792,20 +91103,20 @@ | ||
90792 | 91103 | fprintf(stderr, "%s\n", ""); |
90793 | 91104 | exit(-1); |
90794 | 91105 | } |
90795 | - state.addr = 18446744073709545789LLU; // 99999998i7''''''''''''''' | |
91106 | + state.addr = 18446744073709545774LLU; // 99999998is''''''''''''''' | |
90796 | 91107 | break; |
90797 | 91108 | } |
90798 | - case 18446744073709545789LLU: // 99999998i7''''''''''''''' | |
91109 | + case 18446744073709545774LLU: // 99999998is''''''''''''''' | |
90799 | 91110 | { |
90800 | - state.addr = 18446744073709545788LLU; // 99999998i6''''''''''''''' | |
91111 | + state.addr = 18446744073709545773LLU; // 99999998ir''''''''''''''' | |
90801 | 91112 | break; |
90802 | 91113 | } |
90803 | - case 18446744073709545788LLU: // 99999998i6''''''''''''''' | |
91114 | + case 18446744073709545773LLU: // 99999998ir''''''''''''''' | |
90804 | 91115 | { |
90805 | 91116 | *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 6LLU, 4LLU)) = (uint64_t)getchar(); |
90806 | 91117 | if(!*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 6LLU, 4LLU)) || *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 6LLU, 4LLU)) > 255) |
90807 | 91118 | { |
90808 | - state.addr = 18446744073709545787LLU; // 99999998i5''''''''''''''' | |
91119 | + state.addr = 18446744073709545772LLU; // 99999998iq''''''''''''''' | |
90809 | 91120 | break; |
90810 | 91121 | } |
90811 | 91122 | { |
@@ -90813,24 +91124,24 @@ | ||
90813 | 91124 | LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
90814 | 91125 | } |
90815 | 91126 | *LOCAL_ACCESS(heap.data, 7LLU, 6LLU) = /*sym_______*/*LOCAL_ACCESS(heap.data, 7LLU, 5LLU) == /*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 7LLU, 4LLU)); |
90816 | - state.addr = 18446744073709545784LLU; // 99999998i2''''''''''''''' | |
91127 | + state.addr = 18446744073709545769LLU; // 99999998in''''''''''''''' | |
90817 | 91128 | break; |
90818 | 91129 | } |
90819 | - case 18446744073709545784LLU: // 99999998i2''''''''''''''' | |
91130 | + case 18446744073709545769LLU: // 99999998in''''''''''''''' | |
90820 | 91131 | { |
90821 | - state.addr = *LOCAL_ACCESS(heap.data, 7LLU, 6LLU) ? 18446744073709545786LLU : 18446744073709545785LLU; | |
91132 | + state.addr = *LOCAL_ACCESS(heap.data, 7LLU, 6LLU) ? 18446744073709545771LLU : 18446744073709545770LLU; | |
90822 | 91133 | (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 7 |
90823 | 91134 | break; |
90824 | 91135 | } |
90825 | - case 18446744073709545786LLU: // 99999998i4''''''''''''''' | |
91136 | + case 18446744073709545771LLU: // 99999998ip''''''''''''''' | |
90826 | 91137 | { |
90827 | 91138 | ungetc(0, stdin); |
90828 | 91139 | heap.availilable_size_for_dynamic_objects += 0LLU; |
90829 | 91140 | heap.availilable_size_for_dynamic_objects += 0LLU; |
90830 | - state.addr = 18446744073709545783LLU; // 99999998i1''''''''''''''' | |
91141 | + state.addr = 18446744073709545768LLU; // 99999998im''''''''''''''' | |
90831 | 91142 | break; |
90832 | 91143 | } |
90833 | - case 18446744073709545785LLU: // 99999998i3''''''''''''''' | |
91144 | + case 18446744073709545770LLU: // 99999998io''''''''''''''' | |
90834 | 91145 | { |
90835 | 91146 | // ACCUMULATE ARGUMENTS - BEGIN |
90836 | 91147 | { |
@@ -90838,7 +91149,7 @@ | ||
90838 | 91149 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
90839 | 91150 | } |
90840 | 91151 | // ACCUMULATE ARGUMENTS - END |
90841 | - uint64_t return_to = 18446744073709545781LLU; | |
91152 | + uint64_t return_to = 18446744073709545766LLU; | |
90842 | 91153 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
90843 | 91154 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
90844 | 91155 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -90847,41 +91158,41 @@ | ||
90847 | 91158 | state.addr = 587881343588366336LLU; // emitccode_ |
90848 | 91159 | break; |
90849 | 91160 | } |
90850 | - case 18446744073709545781LLU: // 99999998iz''''''''''''''' | |
91161 | + case 18446744073709545766LLU: // 99999998ik''''''''''''''' | |
90851 | 91162 | { |
90852 | - state.addr = 18446744073709545782LLU; // 99999998i0''''''''''''''' | |
91163 | + state.addr = 18446744073709545767LLU; // 99999998il''''''''''''''' | |
90853 | 91164 | break; |
90854 | 91165 | } |
90855 | - case 18446744073709545782LLU: // 99999998i0''''''''''''''' | |
91166 | + case 18446744073709545767LLU: // 99999998il''''''''''''''' | |
90856 | 91167 | { |
90857 | - state.addr = 18446744073709545783LLU; // 99999998i1''''''''''''''' | |
91168 | + state.addr = 18446744073709545768LLU; // 99999998im''''''''''''''' | |
90858 | 91169 | break; |
90859 | 91170 | } |
90860 | - case 18446744073709545783LLU: // 99999998i1''''''''''''''' | |
91171 | + case 18446744073709545768LLU: // 99999998im''''''''''''''' | |
90861 | 91172 | { |
90862 | - state.addr = 18446744073709545788LLU; // 99999998i6''''''''''''''' | |
91173 | + state.addr = 18446744073709545773LLU; // 99999998ir''''''''''''''' | |
90863 | 91174 | break; |
90864 | 91175 | } |
90865 | - case 18446744073709545787LLU: // 99999998i5''''''''''''''' | |
91176 | + case 18446744073709545772LLU: // 99999998iq''''''''''''''' | |
90866 | 91177 | { |
90867 | 91178 | |
90868 | - state.addr = 18446744073709545780LLU; // 99999998iy''''''''''''''' | |
91179 | + state.addr = 18446744073709545765LLU; // 99999998ij''''''''''''''' | |
90869 | 91180 | break; |
90870 | 91181 | } |
90871 | - case 18446744073709545780LLU: // 99999998iy''''''''''''''' | |
91182 | + case 18446744073709545765LLU: // 99999998ij''''''''''''''' | |
90872 | 91183 | { |
90873 | 91184 | *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 6LLU, 4LLU)) = (uint64_t)getchar(); |
90874 | - state.addr = 18446744073709545779LLU; // 99999998ix''''''''''''''' | |
91185 | + state.addr = 18446744073709545764LLU; // 99999998ii''''''''''''''' | |
90875 | 91186 | break; |
90876 | 91187 | } |
90877 | - case 18446744073709545779LLU: // 99999998ix''''''''''''''' | |
91188 | + case 18446744073709545764LLU: // 99999998ii''''''''''''''' | |
90878 | 91189 | { |
90879 | 91190 | heap.availilable_size_for_dynamic_objects += 0LLU; |
90880 | 91191 | heap.availilable_size_for_dynamic_objects += 0LLU; |
90881 | - state.addr = 18446744073709545778LLU; // 99999998iw''''''''''''''' | |
91192 | + state.addr = 18446744073709545763LLU; // 99999998ih''''''''''''''' | |
90882 | 91193 | break; |
90883 | 91194 | } |
90884 | - case 18446744073709545792LLU: // 99999998j_''''''''''''''' | |
91195 | + case 18446744073709545777LLU: // 99999998iv''''''''''''''' | |
90885 | 91196 | { |
90886 | 91197 | // ACCUMULATE ARGUMENTS - BEGIN |
90887 | 91198 | { |
@@ -90889,7 +91200,7 @@ | ||
90889 | 91200 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
90890 | 91201 | } |
90891 | 91202 | // ACCUMULATE ARGUMENTS - END |
90892 | - uint64_t return_to = 18446744073709545776LLU; | |
91203 | + uint64_t return_to = 18446744073709545761LLU; | |
90893 | 91204 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
90894 | 91205 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
90895 | 91206 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -90898,12 +91209,12 @@ | ||
90898 | 91209 | state.addr = 819847183515949359LLU; // reportinit |
90899 | 91210 | break; |
90900 | 91211 | } |
90901 | - case 18446744073709545776LLU: // 99999998iu''''''''''''''' | |
91212 | + case 18446744073709545761LLU: // 99999998if''''''''''''''' | |
90902 | 91213 | { |
90903 | - state.addr = 18446744073709545777LLU; // 99999998iv''''''''''''''' | |
91214 | + state.addr = 18446744073709545762LLU; // 99999998ig''''''''''''''' | |
90904 | 91215 | break; |
90905 | 91216 | } |
90906 | - case 18446744073709545777LLU: // 99999998iv''''''''''''''' | |
91217 | + case 18446744073709545762LLU: // 99999998ig''''''''''''''' | |
90907 | 91218 | { |
90908 | 91219 | fprintf(stderr, "%s", "INTERNAL ERROR: expected '`' but found "); |
90909 | 91220 | putc((char)/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 6LLU, 4LLU)), stderr); |
@@ -90911,10 +91222,10 @@ | ||
90911 | 91222 | fprintf(stderr, "%s\n", ""); |
90912 | 91223 | exit(-1); |
90913 | 91224 | } |
90914 | - state.addr = 18446744073709545778LLU; // 99999998iw''''''''''''''' | |
91225 | + state.addr = 18446744073709545763LLU; // 99999998ih''''''''''''''' | |
90915 | 91226 | break; |
90916 | 91227 | } |
90917 | - case 18446744073709545778LLU: // 99999998iw''''''''''''''' | |
91228 | + case 18446744073709545763LLU: // 99999998ih''''''''''''''' | |
90918 | 91229 | { |
90919 | 91230 | // variable u64 sym_______ goes out of scope |
90920 | 91231 | // emitted destructur for type u64 |
@@ -90939,15 +91250,15 @@ | ||
90939 | 91250 | } |
90940 | 91251 | case 782701543301228454LLU: // parseblock |
90941 | 91252 | { |
90942 | - state.addr = 18446744073709545775LLU; // 99999998it''''''''''''''' | |
91253 | + state.addr = 18446744073709545760LLU; // 99999998ie''''''''''''''' | |
90943 | 91254 | break; |
90944 | 91255 | } |
90945 | - case 18446744073709545775LLU: // 99999998it''''''''''''''' | |
91256 | + case 18446744073709545760LLU: // 99999998ie''''''''''''''' | |
90946 | 91257 | { |
90947 | 91258 | *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 16LLU, 5LLU)) = (uint64_t)getchar(); |
90948 | 91259 | if(!*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 16LLU, 5LLU)) || *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 16LLU, 5LLU)) > 255) |
90949 | 91260 | { |
90950 | - state.addr = 18446744073709545774LLU; // 99999998is''''''''''''''' | |
91261 | + state.addr = 18446744073709545759LLU; // 99999998id''''''''''''''' | |
90951 | 91262 | break; |
90952 | 91263 | } |
90953 | 91264 | // ACCUMULATE ARGUMENTS - BEGIN |
@@ -90956,7 +91267,7 @@ | ||
90956 | 91267 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
90957 | 91268 | } |
90958 | 91269 | // ACCUMULATE ARGUMENTS - END |
90959 | - uint64_t return_to = 18446744073709545772LLU; | |
91270 | + uint64_t return_to = 18446744073709545757LLU; | |
90960 | 91271 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
90961 | 91272 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
90962 | 91273 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -90965,12 +91276,12 @@ | ||
90965 | 91276 | state.addr = 839519665163075584LLU; // skip______ |
90966 | 91277 | break; |
90967 | 91278 | } |
90968 | - case 18446744073709545772LLU: // 99999998iq''''''''''''''' | |
91279 | + case 18446744073709545757LLU: // 99999998ib''''''''''''''' | |
90969 | 91280 | { |
90970 | - state.addr = 18446744073709545773LLU; // 99999998ir''''''''''''''' | |
91281 | + state.addr = 18446744073709545758LLU; // 99999998ic''''''''''''''' | |
90971 | 91282 | break; |
90972 | 91283 | } |
90973 | - case 18446744073709545773LLU: // 99999998ir''''''''''''''' | |
91284 | + case 18446744073709545758LLU: // 99999998ic''''''''''''''' | |
90974 | 91285 | { |
90975 | 91286 | { |
90976 | 91287 | uint64_t arg = 0; |
@@ -90982,16 +91293,16 @@ | ||
90982 | 91293 | LOCAL_PUSH_MOVE(&heap, 17, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
90983 | 91294 | } |
90984 | 91295 | *LOCAL_ACCESS(heap.data, 18LLU, 17LLU) = /*sym_______*/*LOCAL_ACCESS(heap.data, 18LLU, 16LLU) == /*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 18LLU, 5LLU)); |
90985 | - state.addr = 18446744073709545769LLU; // 99999998in''''''''''''''' | |
91296 | + state.addr = 18446744073709545754LLU; // 99999998iZ''''''''''''''' | |
90986 | 91297 | break; |
90987 | 91298 | } |
90988 | - case 18446744073709545769LLU: // 99999998in''''''''''''''' | |
91299 | + case 18446744073709545754LLU: // 99999998iZ''''''''''''''' | |
90989 | 91300 | { |
90990 | - state.addr = *LOCAL_ACCESS(heap.data, 18LLU, 17LLU) ? 18446744073709545771LLU : 18446744073709545770LLU; | |
91301 | + state.addr = *LOCAL_ACCESS(heap.data, 18LLU, 17LLU) ? 18446744073709545756LLU : 18446744073709545755LLU; | |
90991 | 91302 | (void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 18 |
90992 | 91303 | break; |
90993 | 91304 | } |
90994 | - case 18446744073709545771LLU: // 99999998ip''''''''''''''' | |
91305 | + case 18446744073709545756LLU: // 99999998ia''''''''''''''' | |
90995 | 91306 | { |
90996 | 91307 | // ACCUMULATE ARGUMENTS - BEGIN |
90997 | 91308 | { |
@@ -91015,7 +91326,7 @@ | ||
91015 | 91326 | LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
91016 | 91327 | } |
91017 | 91328 | // ACCUMULATE ARGUMENTS - END |
91018 | - uint64_t return_to = 18446744073709545767LLU; | |
91329 | + uint64_t return_to = 18446744073709545752LLU; | |
91019 | 91330 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)); |
91020 | 91331 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
91021 | 91332 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -91024,19 +91335,19 @@ | ||
91024 | 91335 | state.addr = 552446626445785088LLU; // copyccode_ |
91025 | 91336 | break; |
91026 | 91337 | } |
91027 | - case 18446744073709545767LLU: // 99999998il''''''''''''''' | |
91338 | + case 18446744073709545752LLU: // 99999998iX''''''''''''''' | |
91028 | 91339 | { |
91029 | - state.addr = 18446744073709545768LLU; // 99999998im''''''''''''''' | |
91340 | + state.addr = 18446744073709545753LLU; // 99999998iY''''''''''''''' | |
91030 | 91341 | break; |
91031 | 91342 | } |
91032 | - case 18446744073709545768LLU: // 99999998im''''''''''''''' | |
91343 | + case 18446744073709545753LLU: // 99999998iY''''''''''''''' | |
91033 | 91344 | { |
91034 | 91345 | heap.availilable_size_for_dynamic_objects += 0LLU; |
91035 | 91346 | heap.availilable_size_for_dynamic_objects += 0LLU; |
91036 | - state.addr = 18446744073709545766LLU; // 99999998ik''''''''''''''' | |
91347 | + state.addr = 18446744073709545751LLU; // 99999998iW''''''''''''''' | |
91037 | 91348 | break; |
91038 | 91349 | } |
91039 | - case 18446744073709545770LLU: // 99999998io''''''''''''''' | |
91350 | + case 18446744073709545755LLU: // 99999998i$''''''''''''''' | |
91040 | 91351 | { |
91041 | 91352 | { |
91042 | 91353 | uint64_t arg = 0; |
@@ -91052,7 +91363,7 @@ | ||
91052 | 91363 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
91053 | 91364 | } |
91054 | 91365 | // ACCUMULATE ARGUMENTS - END |
91055 | - uint64_t return_to = 18446744073709545762LLU; | |
91366 | + uint64_t return_to = 18446744073709545747LLU; | |
91056 | 91367 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
91057 | 91368 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
91058 | 91369 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -91061,18 +91372,18 @@ | ||
91061 | 91372 | state.addr = 661610008740528128LLU; // isequsym__ |
91062 | 91373 | break; |
91063 | 91374 | } |
91064 | - case 18446744073709545762LLU: // 99999998ig''''''''''''''' | |
91375 | + case 18446744073709545747LLU: // 99999998iS''''''''''''''' | |
91065 | 91376 | { |
91066 | - state.addr = 18446744073709545763LLU; // 99999998ih''''''''''''''' | |
91377 | + state.addr = 18446744073709545748LLU; // 99999998iT''''''''''''''' | |
91067 | 91378 | break; |
91068 | 91379 | } |
91069 | - case 18446744073709545763LLU: // 99999998ih''''''''''''''' | |
91380 | + case 18446744073709545748LLU: // 99999998iT''''''''''''''' | |
91070 | 91381 | { |
91071 | - state.addr = *LOCAL_ACCESS(heap.data, 18LLU, 17LLU) ? 18446744073709545765LLU : 18446744073709545764LLU; | |
91382 | + state.addr = *LOCAL_ACCESS(heap.data, 18LLU, 17LLU) ? 18446744073709545750LLU : 18446744073709545749LLU; | |
91072 | 91383 | (void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 18 |
91073 | 91384 | break; |
91074 | 91385 | } |
91075 | - case 18446744073709545765LLU: // 99999998ij''''''''''''''' | |
91386 | + case 18446744073709545750LLU: // 99999998iV''''''''''''''' | |
91076 | 91387 | { |
91077 | 91388 | matchid("==", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 5LLU))); |
91078 | 91389 | { |
@@ -91080,10 +91391,10 @@ | ||
91080 | 91391 | LOCAL_PUSH_MOVE(&heap, 17, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
91081 | 91392 | } |
91082 | 91393 | *LOCAL_ACCESS(heap.data, 18LLU, 17LLU) = parsenr(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 18LLU, 5LLU))); |
91083 | - state.addr = 18446744073709545761LLU; // 99999998if''''''''''''''' | |
91394 | + state.addr = 18446744073709545746LLU; // 99999998iR''''''''''''''' | |
91084 | 91395 | break; |
91085 | 91396 | } |
91086 | - case 18446744073709545761LLU: // 99999998if''''''''''''''' | |
91397 | + case 18446744073709545746LLU: // 99999998iR''''''''''''''' | |
91087 | 91398 | { |
91088 | 91399 | ungetc((int)/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 18LLU, 5LLU)), stdin); |
91089 | 91400 | if('=' != (char)getchar()) |
@@ -91101,22 +91412,22 @@ | ||
91101 | 91412 | LOCAL_PUSH_MOVE(&heap, 18, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
91102 | 91413 | } |
91103 | 91414 | *LOCAL_ACCESS(heap.data, 19LLU, 18LLU) = /*defargcnt_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 12LLU)) + /*defbodysz_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 13LLU)); |
91104 | - state.addr = 18446744073709545760LLU; // 99999998ie''''''''''''''' | |
91415 | + state.addr = 18446744073709545745LLU; // 99999998iQ''''''''''''''' | |
91105 | 91416 | break; |
91106 | 91417 | } |
91107 | - case 18446744073709545760LLU: // 99999998ie''''''''''''''' | |
91418 | + case 18446744073709545745LLU: // 99999998iQ''''''''''''''' | |
91108 | 91419 | { |
91109 | 91420 | |
91110 | - state.addr = 18446744073709545759LLU; // 99999998id''''''''''''''' | |
91421 | + state.addr = 18446744073709545744LLU; // 99999998iP''''''''''''''' | |
91111 | 91422 | break; |
91112 | 91423 | } |
91113 | - case 18446744073709545759LLU: // 99999998id''''''''''''''' | |
91424 | + case 18446744073709545744LLU: // 99999998iP''''''''''''''' | |
91114 | 91425 | { |
91115 | 91426 | *LOCAL_ACCESS(heap.data, 19LLU, 18LLU) = /*bufB______*/*LOCAL_ACCESS(heap.data, 19LLU, 18LLU) - /*remainsize*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 14LLU)); |
91116 | - state.addr = 18446744073709545758LLU; // 99999998ic''''''''''''''' | |
91427 | + state.addr = 18446744073709545743LLU; // 99999998iO''''''''''''''' | |
91117 | 91428 | break; |
91118 | 91429 | } |
91119 | - case 18446744073709545758LLU: // 99999998ic''''''''''''''' | |
91430 | + case 18446744073709545743LLU: // 99999998iO''''''''''''''' | |
91120 | 91431 | { |
91121 | 91432 | { |
91122 | 91433 | uint64_t arg = 0; |
@@ -91123,16 +91434,16 @@ | ||
91123 | 91434 | LOCAL_PUSH_MOVE(&heap, 19, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
91124 | 91435 | } |
91125 | 91436 | *LOCAL_ACCESS(heap.data, 20LLU, 19LLU) = /*level_____*/*LOCAL_ACCESS(heap.data, 20LLU, 17LLU) != /*bufB______*/*LOCAL_ACCESS(heap.data, 20LLU, 18LLU); |
91126 | - state.addr = 18446744073709545755LLU; // 99999998i$''''''''''''''' | |
91437 | + state.addr = 18446744073709545740LLU; // 99999998iL''''''''''''''' | |
91127 | 91438 | break; |
91128 | 91439 | } |
91129 | - case 18446744073709545755LLU: // 99999998i$''''''''''''''' | |
91440 | + case 18446744073709545740LLU: // 99999998iL''''''''''''''' | |
91130 | 91441 | { |
91131 | - state.addr = *LOCAL_ACCESS(heap.data, 20LLU, 19LLU) ? 18446744073709545757LLU : 18446744073709545756LLU; | |
91442 | + state.addr = *LOCAL_ACCESS(heap.data, 20LLU, 19LLU) ? 18446744073709545742LLU : 18446744073709545741LLU; | |
91132 | 91443 | (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 20 |
91133 | 91444 | break; |
91134 | 91445 | } |
91135 | - case 18446744073709545757LLU: // 99999998ib''''''''''''''' | |
91446 | + case 18446744073709545742LLU: // 99999998iN''''''''''''''' | |
91136 | 91447 | { |
91137 | 91448 | // ACCUMULATE ARGUMENTS - BEGIN |
91138 | 91449 | { |
@@ -91140,7 +91451,7 @@ | ||
91140 | 91451 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
91141 | 91452 | } |
91142 | 91453 | // ACCUMULATE ARGUMENTS - END |
91143 | - uint64_t return_to = 18446744073709545753LLU; | |
91454 | + uint64_t return_to = 18446744073709545738LLU; | |
91144 | 91455 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
91145 | 91456 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
91146 | 91457 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -91149,12 +91460,12 @@ | ||
91149 | 91460 | state.addr = 819847183515949359LLU; // reportinit |
91150 | 91461 | break; |
91151 | 91462 | } |
91152 | - case 18446744073709545753LLU: // 99999998iY''''''''''''''' | |
91463 | + case 18446744073709545738LLU: // 99999998iJ''''''''''''''' | |
91153 | 91464 | { |
91154 | - state.addr = 18446744073709545754LLU; // 99999998iZ''''''''''''''' | |
91465 | + state.addr = 18446744073709545739LLU; // 99999998iK''''''''''''''' | |
91155 | 91466 | break; |
91156 | 91467 | } |
91157 | - case 18446744073709545754LLU: // 99999998iZ''''''''''''''' | |
91468 | + case 18446744073709545739LLU: // 99999998iK''''''''''''''' | |
91158 | 91469 | { |
91159 | 91470 | fprintf(stderr, "%s", "expected specified level "); |
91160 | 91471 | // ACCUMULATE ARGUMENTS - BEGIN |
@@ -91163,7 +91474,7 @@ | ||
91163 | 91474 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
91164 | 91475 | } |
91165 | 91476 | // ACCUMULATE ARGUMENTS - END |
91166 | - uint64_t return_to = 18446744073709545751LLU; | |
91477 | + uint64_t return_to = 18446744073709545736LLU; | |
91167 | 91478 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
91168 | 91479 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
91169 | 91480 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -91172,12 +91483,12 @@ | ||
91172 | 91483 | state.addr = 819847183517274112LLU; // reportnr__ |
91173 | 91484 | break; |
91174 | 91485 | } |
91175 | - case 18446744073709545751LLU: // 99999998iW''''''''''''''' | |
91486 | + case 18446744073709545736LLU: // 99999998iH''''''''''''''' | |
91176 | 91487 | { |
91177 | - state.addr = 18446744073709545752LLU; // 99999998iX''''''''''''''' | |
91488 | + state.addr = 18446744073709545737LLU; // 99999998iI''''''''''''''' | |
91178 | 91489 | break; |
91179 | 91490 | } |
91180 | - case 18446744073709545752LLU: // 99999998iX''''''''''''''' | |
91491 | + case 18446744073709545737LLU: // 99999998iI''''''''''''''' | |
91181 | 91492 | { |
91182 | 91493 | fprintf(stderr, "%s", " but found actual level "); |
91183 | 91494 | // ACCUMULATE ARGUMENTS - BEGIN |
@@ -91186,7 +91497,7 @@ | ||
91186 | 91497 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
91187 | 91498 | } |
91188 | 91499 | // ACCUMULATE ARGUMENTS - END |
91189 | - uint64_t return_to = 18446744073709545749LLU; | |
91500 | + uint64_t return_to = 18446744073709545734LLU; | |
91190 | 91501 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
91191 | 91502 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
91192 | 91503 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -91195,21 +91506,21 @@ | ||
91195 | 91506 | state.addr = 819847183517274112LLU; // reportnr__ |
91196 | 91507 | break; |
91197 | 91508 | } |
91198 | - case 18446744073709545749LLU: // 99999998iU''''''''''''''' | |
91509 | + case 18446744073709545734LLU: // 99999998iF''''''''''''''' | |
91199 | 91510 | { |
91200 | - state.addr = 18446744073709545750LLU; // 99999998iV''''''''''''''' | |
91511 | + state.addr = 18446744073709545735LLU; // 99999998iG''''''''''''''' | |
91201 | 91512 | break; |
91202 | 91513 | } |
91203 | - case 18446744073709545750LLU: // 99999998iV''''''''''''''' | |
91514 | + case 18446744073709545735LLU: // 99999998iG''''''''''''''' | |
91204 | 91515 | { |
91205 | 91516 | { |
91206 | 91517 | fprintf(stderr, "%s\n", ""); |
91207 | 91518 | exit(-1); |
91208 | 91519 | } |
91209 | - state.addr = 18446744073709545756LLU; // 99999998ia''''''''''''''' | |
91520 | + state.addr = 18446744073709545741LLU; // 99999998iM''''''''''''''' | |
91210 | 91521 | break; |
91211 | 91522 | } |
91212 | - case 18446744073709545756LLU: // 99999998ia''''''''''''''' | |
91523 | + case 18446744073709545741LLU: // 99999998iM''''''''''''''' | |
91213 | 91524 | { |
91214 | 91525 | // variable u64 bufB______ goes out of scope |
91215 | 91526 | // emitted destructur for type u64 |
@@ -91219,16 +91530,16 @@ | ||
91219 | 91530 | (void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference level_____ at 18 |
91220 | 91531 | heap.availilable_size_for_dynamic_objects += 0LLU; |
91221 | 91532 | heap.availilable_size_for_dynamic_objects += 0LLU; |
91222 | - state.addr = 18446744073709545748LLU; // 99999998iT''''''''''''''' | |
91533 | + state.addr = 18446744073709545733LLU; // 99999998iE''''''''''''''' | |
91223 | 91534 | break; |
91224 | 91535 | } |
91225 | - case 18446744073709545764LLU: // 99999998ii''''''''''''''' | |
91536 | + case 18446744073709545749LLU: // 99999998iU''''''''''''''' | |
91226 | 91537 | { |
91227 | 91538 | |
91228 | - state.addr = 18446744073709545747LLU; // 99999998iS''''''''''''''' | |
91539 | + state.addr = 18446744073709545732LLU; // 99999998iD''''''''''''''' | |
91229 | 91540 | break; |
91230 | 91541 | } |
91231 | - case 18446744073709545747LLU: // 99999998iS''''''''''''''' | |
91542 | + case 18446744073709545732LLU: // 99999998iD''''''''''''''' | |
91232 | 91543 | { |
91233 | 91544 | *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = 123; |
91234 | 91545 | { |
@@ -91236,16 +91547,16 @@ | ||
91236 | 91547 | LOCAL_PUSH_MOVE(&heap, 17, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
91237 | 91548 | } |
91238 | 91549 | *LOCAL_ACCESS(heap.data, 18LLU, 17LLU) = /*sym_______*/*LOCAL_ACCESS(heap.data, 18LLU, 16LLU) == /*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 18LLU, 5LLU)); |
91239 | - state.addr = 18446744073709545744LLU; // 99999998iP''''''''''''''' | |
91550 | + state.addr = 18446744073709545729LLU; // 99999998iA''''''''''''''' | |
91240 | 91551 | break; |
91241 | 91552 | } |
91242 | - case 18446744073709545744LLU: // 99999998iP''''''''''''''' | |
91553 | + case 18446744073709545729LLU: // 99999998iA''''''''''''''' | |
91243 | 91554 | { |
91244 | - state.addr = *LOCAL_ACCESS(heap.data, 18LLU, 17LLU) ? 18446744073709545746LLU : 18446744073709545745LLU; | |
91555 | + state.addr = *LOCAL_ACCESS(heap.data, 18LLU, 17LLU) ? 18446744073709545731LLU : 18446744073709545730LLU; | |
91245 | 91556 | (void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 18 |
91246 | 91557 | break; |
91247 | 91558 | } |
91248 | - case 18446744073709545746LLU: // 99999998iR''''''''''''''' | |
91559 | + case 18446744073709545731LLU: // 99999998iC''''''''''''''' | |
91249 | 91560 | { |
91250 | 91561 | // ACCUMULATE ARGUMENTS - BEGIN |
91251 | 91562 | { |
@@ -91273,7 +91584,7 @@ | ||
91273 | 91584 | LOCAL_PUSH_MOVE(&heap, 5LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
91274 | 91585 | } |
91275 | 91586 | // ACCUMULATE ARGUMENTS - END |
91276 | - uint64_t return_to = 18446744073709545742LLU; | |
91587 | + uint64_t return_to = 18446744073709545727LLU; | |
91277 | 91588 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 6LLU, 0/*address of closure-in-construction*/, 0)); |
91278 | 91589 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
91279 | 91590 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 6LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -91282,25 +91593,25 @@ | ||
91282 | 91593 | state.addr = 533581901922699840LLU; // blockopen_ |
91283 | 91594 | break; |
91284 | 91595 | } |
91285 | - case 18446744073709545742LLU: // 99999998iN''''''''''''''' | |
91596 | + case 18446744073709545727LLU: // 99999998h9''''''''''''''' | |
91286 | 91597 | { |
91287 | - state.addr = 18446744073709545743LLU; // 99999998iO''''''''''''''' | |
91598 | + state.addr = 18446744073709545728LLU; // 99999998i_''''''''''''''' | |
91288 | 91599 | break; |
91289 | 91600 | } |
91290 | - case 18446744073709545743LLU: // 99999998iO''''''''''''''' | |
91601 | + case 18446744073709545728LLU: // 99999998i_''''''''''''''' | |
91291 | 91602 | { |
91292 | 91603 | heap.availilable_size_for_dynamic_objects += 0LLU; |
91293 | 91604 | heap.availilable_size_for_dynamic_objects += 0LLU; |
91294 | - state.addr = 18446744073709545741LLU; // 99999998iM''''''''''''''' | |
91605 | + state.addr = 18446744073709545726LLU; // 99999998h8''''''''''''''' | |
91295 | 91606 | break; |
91296 | 91607 | } |
91297 | - case 18446744073709545745LLU: // 99999998iQ''''''''''''''' | |
91608 | + case 18446744073709545730LLU: // 99999998iB''''''''''''''' | |
91298 | 91609 | { |
91299 | 91610 | |
91300 | - state.addr = 18446744073709545740LLU; // 99999998iL''''''''''''''' | |
91611 | + state.addr = 18446744073709545725LLU; // 99999998h7''''''''''''''' | |
91301 | 91612 | break; |
91302 | 91613 | } |
91303 | - case 18446744073709545740LLU: // 99999998iL''''''''''''''' | |
91614 | + case 18446744073709545725LLU: // 99999998h7''''''''''''''' | |
91304 | 91615 | { |
91305 | 91616 | *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = 125; |
91306 | 91617 | { |
@@ -91308,16 +91619,16 @@ | ||
91308 | 91619 | LOCAL_PUSH_MOVE(&heap, 17, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
91309 | 91620 | } |
91310 | 91621 | *LOCAL_ACCESS(heap.data, 18LLU, 17LLU) = /*sym_______*/*LOCAL_ACCESS(heap.data, 18LLU, 16LLU) == /*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 18LLU, 5LLU)); |
91311 | - state.addr = 18446744073709545737LLU; // 99999998iI''''''''''''''' | |
91622 | + state.addr = 18446744073709545722LLU; // 99999998h4''''''''''''''' | |
91312 | 91623 | break; |
91313 | 91624 | } |
91314 | - case 18446744073709545737LLU: // 99999998iI''''''''''''''' | |
91625 | + case 18446744073709545722LLU: // 99999998h4''''''''''''''' | |
91315 | 91626 | { |
91316 | - state.addr = *LOCAL_ACCESS(heap.data, 18LLU, 17LLU) ? 18446744073709545739LLU : 18446744073709545738LLU; | |
91627 | + state.addr = *LOCAL_ACCESS(heap.data, 18LLU, 17LLU) ? 18446744073709545724LLU : 18446744073709545723LLU; | |
91317 | 91628 | (void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 18 |
91318 | 91629 | break; |
91319 | 91630 | } |
91320 | - case 18446744073709545739LLU: // 99999998iK''''''''''''''' | |
91631 | + case 18446744073709545724LLU: // 99999998h6''''''''''''''' | |
91321 | 91632 | { |
91322 | 91633 | { |
91323 | 91634 | uint64_t arg = /*results___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 11LLU)); |
@@ -91327,10 +91638,10 @@ | ||
91327 | 91638 | uint64_t arg = 0; |
91328 | 91639 | LOCAL_PUSH_MOVE(&heap, 18, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
91329 | 91640 | } |
91330 | - state.addr = 18446744073709545736LLU; // 99999998iH''''''''''''''' | |
91641 | + state.addr = 18446744073709545721LLU; // 99999998h3''''''''''''''' | |
91331 | 91642 | break; |
91332 | 91643 | } |
91333 | - case 18446744073709545736LLU: // 99999998iH''''''''''''''' | |
91644 | + case 18446744073709545721LLU: // 99999998h3''''''''''''''' | |
91334 | 91645 | { |
91335 | 91646 | if(!*LOCAL_ACCESS(heap.data, 19LLU, 17LLU)) |
91336 | 91647 | { |
@@ -91337,7 +91648,7 @@ | ||
91337 | 91648 | (void)LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 19 |
91338 | 91649 | (void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 18 |
91339 | 91650 | { |
91340 | - state.addr = 18446744073709545735LLU; // 99999 |
Part of diff was cut off due to size limit. Use your local client to view the full diff.