Revision | 1006 (tree) |
---|---|
Time | 2020-05-07 08:22:26 |
Author | jakobthomsen |
implement checkarg builtin function
@@ -5,6 +5,7 @@ | ||
5 | 5 | #include <stdlib.h> |
6 | 6 | #include <stdint.h> |
7 | 7 | #include <stdio.h> |
8 | +#include <string.h> | |
8 | 9 | |
9 | 10 | uint64_t max(uint64_t x, uint64_t y) |
10 | 11 | { |
@@ -17920,6 +17921,7 @@ | ||
17920 | 17921 | fprintf(stdout, "%s", "\n#include <stdlib.h>"); |
17921 | 17922 | fprintf(stdout, "%s", "\n#include <stdint.h>"); |
17922 | 17923 | fprintf(stdout, "%s", "\n#include <stdio.h>"); |
17924 | + fprintf(stdout, "%s", "\n#include <string.h>"); | |
17923 | 17925 | fprintf(stdout, "%s", "\n"); |
17924 | 17926 | fprintf(stdout, "%s", "\nuint64_t max(uint64_t x, uint64_t y)"); |
17925 | 17927 | fprintf(stdout, "%s", "\n{"); |
@@ -47429,6 +47431,308 @@ | ||
47429 | 47431 | } |
47430 | 47432 | case 18446744073709549569LLU: // 99999999eA''''''''''''''' |
47431 | 47433 | { |
47434 | + | |
47435 | + *LOCAL_ACCESS(heap.data, 16LLU, 15LLU) = 550426419825876992; | |
47436 | + | |
47437 | + *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 16LLU, 0LLU)) = /*sym_______*/*LOCAL_ACCESS(heap.data, 16LLU, 15LLU) == /*callee_id_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 16LLU, 6LLU)); | |
47438 | + { | |
47439 | + uint64_t arg = 0; | |
47440 | + LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/*address of current closure*/, &arg); | |
47441 | + } | |
47442 | + *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 0LLU)); | |
47443 | + state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549555LLU : 18446744073709549554LLU; | |
47444 | + (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 17 | |
47445 | + break; | |
47446 | + } | |
47447 | + case 18446744073709549555LLU: // 99999999dx''''''''''''''' | |
47448 | + { | |
47449 | + { | |
47450 | + uint64_t arg = 0; | |
47451 | + LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/*address of current closure*/, &arg); | |
47452 | + } | |
47453 | + *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = 0; | |
47454 | + { | |
47455 | + uint64_t arg = 0; | |
47456 | + LOCAL_PUSH_MOVE(&heap, 17, &(heap.data[0].elem1)/*address of current closure*/, &arg); | |
47457 | + } | |
47458 | + *LOCAL_ACCESS(heap.data, 18LLU, 17LLU) = 0; | |
47459 | + { | |
47460 | + uint64_t arg = 0; | |
47461 | + LOCAL_PUSH_MOVE(&heap, 18, &(heap.data[0].elem1)/*address of current closure*/, &arg); | |
47462 | + } | |
47463 | + *LOCAL_ACCESS(heap.data, 19LLU, 18LLU) = 0; | |
47464 | + { | |
47465 | + uint64_t arg = 0; | |
47466 | + LOCAL_PUSH_MOVE(&heap, 19, &(heap.data[0].elem1)/*address of current closure*/, &arg); | |
47467 | + } | |
47468 | + // ACCUMULATE ARGUMENTS - BEGIN | |
47469 | + { | |
47470 | + uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 20LLU, 19LLU); | |
47471 | + LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
47472 | + } | |
47473 | + // ACCUMULATE ARGUMENTS - END | |
47474 | + uint64_t return_to = 18446744073709549552LLU; | |
47475 | + const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); | |
47476 | + uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); | |
47477 | + *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; | |
47478 | + heap.data[0].elem1 = heap.data[0].elem0; | |
47479 | + heap.data[0].elem0 = restore; | |
47480 | + state.addr = 861504796319285248LLU; // typeu64___ | |
47481 | + break; | |
47482 | + } | |
47483 | + case 18446744073709549552LLU: // 99999999du''''''''''''''' | |
47484 | + { | |
47485 | + { | |
47486 | + uint64_t arg = 0; | |
47487 | + LOCAL_PUSH_MOVE(&heap, 20, &(heap.data[0].elem1)/*address of current closure*/, &arg); | |
47488 | + } | |
47489 | + // ACCUMULATE ARGUMENTS - BEGIN | |
47490 | + { | |
47491 | + uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 21LLU, 20LLU); | |
47492 | + LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
47493 | + } | |
47494 | + { | |
47495 | + uint64_t arg = heap.data[0].elem0; | |
47496 | + LOCAL_PUSH_MOVE(&heap, 21, &(heap.data[0].elem1)/*address of current closure*/, &arg); | |
47497 | + } | |
47498 | + { | |
47499 | + uint64_t arg = 0; | |
47500 | + LOCAL_PUSH_MOVE(&heap, 22, &(heap.data[0].elem1)/*address of current closure*/, &arg); | |
47501 | + } | |
47502 | + // ACCUMULATE ARGUMENTS - BEGIN | |
47503 | + { | |
47504 | + uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 23LLU, 22LLU); | |
47505 | + LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
47506 | + } | |
47507 | + // ACCUMULATE ARGUMENTS - END | |
47508 | + uint64_t return_to = 18446744073709549550LLU; | |
47509 | + const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); | |
47510 | + uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); | |
47511 | + *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; | |
47512 | + heap.data[0].elem1 = heap.data[0].elem0; | |
47513 | + heap.data[0].elem0 = restore; | |
47514 | + state.addr = 861504796319285248LLU; // typeu64___ | |
47515 | + break; | |
47516 | + } | |
47517 | + case 18446744073709549550LLU: // 99999999ds''''''''''''''' | |
47518 | + { | |
47519 | + { | |
47520 | + uint64_t exchange = LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 23*/; | |
47521 | + heap.data[0].elem0 = LOCAL_POP_MOVE(&heap, 22LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 22*/; | |
47522 | + | |
47523 | + { | |
47524 | + uint64_t arg = exchange; | |
47525 | + LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
47526 | + } | |
47527 | + } | |
47528 | + { | |
47529 | + uint64_t arg = 0LLU; | |
47530 | + LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
47531 | + } | |
47532 | + { | |
47533 | + uint64_t arg = 0LLU; | |
47534 | + LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
47535 | + } | |
47536 | + // ACCUMULATE ARGUMENTS - END | |
47537 | + uint64_t return_to = 18446744073709549551LLU; | |
47538 | + const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); | |
47539 | + uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); | |
47540 | + *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; | |
47541 | + heap.data[0].elem1 = heap.data[0].elem0; | |
47542 | + heap.data[0].elem0 = restore; | |
47543 | + state.addr = 819859607768530944LLU; // resdest___ | |
47544 | + break; | |
47545 | + } | |
47546 | + case 18446744073709549551LLU: // 99999999dt''''''''''''''' | |
47547 | + { | |
47548 | + // ACCUMULATE ARGUMENTS - BEGIN | |
47549 | + { | |
47550 | + uint64_t arg = /*single____*/LOCAL_ACCESS_ADDR(heap.data, 21LLU, 20LLU); | |
47551 | + LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
47552 | + } | |
47553 | + { | |
47554 | + uint64_t arg = /*def_id____*/*LOCAL_ACCESS(heap.data, 21LLU, 9LLU); | |
47555 | + LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
47556 | + } | |
47557 | + { | |
47558 | + uint64_t arg = /*callee_id_*/*LOCAL_ACCESS(heap.data, 21LLU, 6LLU); | |
47559 | + LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
47560 | + } | |
47561 | + { | |
47562 | + uint64_t arg = /*newresults*/*LOCAL_ACCESS(heap.data, 21LLU, 14LLU); | |
47563 | + LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
47564 | + } | |
47565 | + // ACCUMULATE ARGUMENTS - END | |
47566 | + uint64_t return_to = 18446744073709549549LLU; | |
47567 | + const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); | |
47568 | + uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); | |
47569 | + *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; | |
47570 | + heap.data[0].elem1 = heap.data[0].elem0; | |
47571 | + heap.data[0].elem0 = restore; | |
47572 | + state.addr = 819857494882385920LLU; // res_u64___ | |
47573 | + break; | |
47574 | + } | |
47575 | + case 18446744073709549549LLU: // 99999999dr''''''''''''''' | |
47576 | + { | |
47577 | + // ACCUMULATE ARGUMENTS - BEGIN | |
47578 | + { | |
47579 | + uint64_t arg = /*c_________*/*LOCAL_ACCESS(heap.data, 21LLU, 7LLU); | |
47580 | + LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
47581 | + } | |
47582 | + // ACCUMULATE ARGUMENTS - END | |
47583 | + uint64_t return_to = 18446744073709549548LLU; | |
47584 | + const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); | |
47585 | + uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); | |
47586 | + *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; | |
47587 | + heap.data[0].elem1 = heap.data[0].elem0; | |
47588 | + heap.data[0].elem0 = restore; | |
47589 | + state.addr = 839519665163075584LLU; // skip______ | |
47590 | + break; | |
47591 | + } | |
47592 | + case 18446744073709549548LLU: // 99999999dq''''''''''''''' | |
47593 | + { | |
47594 | + matchid("(", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU))); | |
47595 | + fprintf(stdout, "%s", "\n {"); | |
47596 | + fprintf(stdout, "%s", "\n uint64_t match = 0;"); | |
47597 | + fprintf(stdout, "%s", "\n for(int i = 0; i < argc; i++)"); | |
47598 | + fprintf(stdout, "%s", "\n {"); | |
47599 | + fprintf(stdout, "%s", "\n if(strcmp(args[i], \""); | |
47600 | + // ACCUMULATE ARGUMENTS - BEGIN | |
47601 | + { | |
47602 | + uint64_t arg = /*c_________*/*LOCAL_ACCESS(heap.data, 21LLU, 7LLU); | |
47603 | + LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
47604 | + } | |
47605 | + // ACCUMULATE ARGUMENTS - END | |
47606 | + uint64_t return_to = 18446744073709549547LLU; | |
47607 | + const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); | |
47608 | + uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); | |
47609 | + *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; | |
47610 | + heap.data[0].elem1 = heap.data[0].elem0; | |
47611 | + heap.data[0].elem0 = restore; | |
47612 | + state.addr = 585061869643254370LLU; // echostring | |
47613 | + break; | |
47614 | + } | |
47615 | + case 18446744073709549547LLU: // 99999999dp''''''''''''''' | |
47616 | + { | |
47617 | + fprintf(stdout, "%s", "\") == 0)"); | |
47618 | + fprintf(stdout, "%s", "\n {"); | |
47619 | + fprintf(stdout, "%s", "\n match = 1;"); | |
47620 | + fprintf(stdout, "%s", "\n break;"); | |
47621 | + fprintf(stdout, "%s", "\n }"); | |
47622 | + fprintf(stdout, "%s", "\n }"); | |
47623 | + fprintf(stdout, "%s", "\n "); | |
47624 | + // ACCUMULATE ARGUMENTS - BEGIN | |
47625 | + { | |
47626 | + uint64_t arg = /*defargcnt_*/*LOCAL_ACCESS(heap.data, 21LLU, 10LLU); | |
47627 | + LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
47628 | + } | |
47629 | + { | |
47630 | + uint64_t arg = /*defbodysz_*/*LOCAL_ACCESS(heap.data, 21LLU, 11LLU); | |
47631 | + LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
47632 | + } | |
47633 | + { | |
47634 | + uint64_t arg = /*remainsize*/*LOCAL_ACCESS(heap.data, 21LLU, 12LLU); | |
47635 | + LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
47636 | + } | |
47637 | + { | |
47638 | + uint64_t arg = /*single____*/tree_elem_addr(heap.data, 3LLU, LOCAL_ACCESS_ADDR(heap.data, 21LLU, 20LLU), 1LLU); | |
47639 | + LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
47640 | + } | |
47641 | + { | |
47642 | + uint64_t arg = /*single____*/tree_elem_addr(heap.data, 3LLU, LOCAL_ACCESS_ADDR(heap.data, 21LLU, 20LLU), 2LLU); | |
47643 | + LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
47644 | + } | |
47645 | + // ACCUMULATE ARGUMENTS - END | |
47646 | + uint64_t return_to = 18446744073709549546LLU; | |
47647 | + const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)); | |
47648 | + uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); | |
47649 | + *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; | |
47650 | + heap.data[0].elem1 = heap.data[0].elem0; | |
47651 | + heap.data[0].elem0 = restore; | |
47652 | + state.addr = 587881357514113024LLU; // emitpar___ | |
47653 | + break; | |
47654 | + } | |
47655 | + case 18446744073709549546LLU: // 99999999do''''''''''''''' | |
47656 | + { | |
47657 | + fprintf(stdout, "%s", " = match;"); | |
47658 | + fprintf(stdout, "%s", "\n }"); | |
47659 | + // ACCUMULATE ARGUMENTS - BEGIN | |
47660 | + { | |
47661 | + uint64_t arg = /*c_________*/*LOCAL_ACCESS(heap.data, 21LLU, 7LLU); | |
47662 | + LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
47663 | + } | |
47664 | + // ACCUMULATE ARGUMENTS - END | |
47665 | + uint64_t return_to = 18446744073709549545LLU; | |
47666 | + const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); | |
47667 | + uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); | |
47668 | + *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; | |
47669 | + heap.data[0].elem1 = heap.data[0].elem0; | |
47670 | + heap.data[0].elem0 = restore; | |
47671 | + state.addr = 839519665163075584LLU; // skip______ | |
47672 | + break; | |
47673 | + } | |
47674 | + case 18446744073709549545LLU: // 99999999dn''''''''''''''' | |
47675 | + { | |
47676 | + matchid(")", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU))); | |
47677 | + // variable resdest___ single____ goes out of scope | |
47678 | + // emitted destructur for type resdest___ | |
47679 | + // ACCUMULATE ARGUMENTS - BEGIN | |
47680 | + { | |
47681 | + uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 21LLU, 20LLU); | |
47682 | + LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
47683 | + } | |
47684 | + // ACCUMULATE ARGUMENTS - END | |
47685 | + uint64_t return_to = 18446744073709549544LLU; | |
47686 | + const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); | |
47687 | + uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); | |
47688 | + *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; | |
47689 | + heap.data[0].elem1 = heap.data[0].elem0; | |
47690 | + heap.data[0].elem0 = restore; | |
47691 | + state.addr = 18446744073709551534LLU; // 999999998s''''''''''''''' | |
47692 | + break; | |
47693 | + } | |
47694 | + case 18446744073709549544LLU: // 99999999dm''''''''''''''' | |
47695 | + { | |
47696 | + (void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference single____ at 21 | |
47697 | + // variable type______ type______ goes out of scope | |
47698 | + // emitted destructur for type type______ | |
47699 | + // ACCUMULATE ARGUMENTS - BEGIN | |
47700 | + { | |
47701 | + uint64_t arg = LOCAL_ACCESS_ADDR(heap.data, 20LLU, 19LLU); | |
47702 | + LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
47703 | + } | |
47704 | + // ACCUMULATE ARGUMENTS - END | |
47705 | + uint64_t return_to = 18446744073709549543LLU; | |
47706 | + const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); | |
47707 | + uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); | |
47708 | + *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; | |
47709 | + heap.data[0].elem1 = heap.data[0].elem0; | |
47710 | + heap.data[0].elem0 = restore; | |
47711 | + state.addr = 18446744073709551573LLU; // 999999999U''''''''''''''' | |
47712 | + break; | |
47713 | + } | |
47714 | + case 18446744073709549543LLU: // 99999999dl''''''''''''''' | |
47715 | + { | |
47716 | + (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type______ at 20 | |
47717 | + // variable u64 mutable___ goes out of scope | |
47718 | + // emitted destructur for type u64 | |
47719 | + (void)LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference mutable___ at 19 | |
47720 | + // variable u64 INDIRECT__ goes out of scope | |
47721 | + // emitted destructur for type u64 | |
47722 | + (void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference INDIRECT__ at 18 | |
47723 | + // variable u64 id________ goes out of scope | |
47724 | + // emitted destructur for type u64 | |
47725 | + (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id________ at 17 | |
47726 | + state.addr = 18446744073709549553LLU; // 99999999dv''''''''''''''' | |
47727 | + break; | |
47728 | + } | |
47729 | + case 18446744073709549554LLU: // 99999999dw''''''''''''''' | |
47730 | + { | |
47731 | + state.addr = 18446744073709549553LLU; // 99999999dv''''''''''''''' | |
47732 | + break; | |
47733 | + } | |
47734 | + case 18446744073709549553LLU: // 99999999dv''''''''''''''' | |
47735 | + { | |
47432 | 47736 | state.addr = 18446744073709549568LLU; // 99999999e_''''''''''''''' |
47433 | 47737 | break; |
47434 | 47738 | } |
@@ -47516,11 +47820,11 @@ | ||
47516 | 47820 | LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
47517 | 47821 | } |
47518 | 47822 | *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 0LLU)); |
47519 | - state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549555LLU : 18446744073709549554LLU; | |
47823 | + state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549542LLU : 18446744073709549541LLU; | |
47520 | 47824 | (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 17 |
47521 | 47825 | break; |
47522 | 47826 | } |
47523 | - case 18446744073709549555LLU: // 99999999dx''''''''''''''' | |
47827 | + case 18446744073709549542LLU: // 99999999dk''''''''''''''' | |
47524 | 47828 | { |
47525 | 47829 | { |
47526 | 47830 | uint64_t arg = 0; |
@@ -47547,7 +47851,7 @@ | ||
47547 | 47851 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
47548 | 47852 | } |
47549 | 47853 | // ACCUMULATE ARGUMENTS - END |
47550 | - uint64_t return_to = 18446744073709549552LLU; | |
47854 | + uint64_t return_to = 18446744073709549539LLU; | |
47551 | 47855 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
47552 | 47856 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
47553 | 47857 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -47556,7 +47860,7 @@ | ||
47556 | 47860 | state.addr = 861504796319285248LLU; // typeu64___ |
47557 | 47861 | break; |
47558 | 47862 | } |
47559 | - case 18446744073709549552LLU: // 99999999du''''''''''''''' | |
47863 | + case 18446744073709549539LLU: // 99999999dh''''''''''''''' | |
47560 | 47864 | { |
47561 | 47865 | { |
47562 | 47866 | uint64_t arg = 0; |
@@ -47581,7 +47885,7 @@ | ||
47581 | 47885 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
47582 | 47886 | } |
47583 | 47887 | // ACCUMULATE ARGUMENTS - END |
47584 | - uint64_t return_to = 18446744073709549550LLU; | |
47888 | + uint64_t return_to = 18446744073709549537LLU; | |
47585 | 47889 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
47586 | 47890 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
47587 | 47891 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -47590,7 +47894,7 @@ | ||
47590 | 47894 | state.addr = 861504796319285248LLU; // typeu64___ |
47591 | 47895 | break; |
47592 | 47896 | } |
47593 | - case 18446744073709549550LLU: // 99999999ds''''''''''''''' | |
47897 | + case 18446744073709549537LLU: // 99999999df''''''''''''''' | |
47594 | 47898 | { |
47595 | 47899 | { |
47596 | 47900 | uint64_t exchange = LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 23*/; |
@@ -47610,7 +47914,7 @@ | ||
47610 | 47914 | LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
47611 | 47915 | } |
47612 | 47916 | // ACCUMULATE ARGUMENTS - END |
47613 | - uint64_t return_to = 18446744073709549551LLU; | |
47917 | + uint64_t return_to = 18446744073709549538LLU; | |
47614 | 47918 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
47615 | 47919 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
47616 | 47920 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -47619,7 +47923,7 @@ | ||
47619 | 47923 | state.addr = 819859607768530944LLU; // resdest___ |
47620 | 47924 | break; |
47621 | 47925 | } |
47622 | - case 18446744073709549551LLU: // 99999999dt''''''''''''''' | |
47926 | + case 18446744073709549538LLU: // 99999999dg''''''''''''''' | |
47623 | 47927 | { |
47624 | 47928 | // ACCUMULATE ARGUMENTS - BEGIN |
47625 | 47929 | { |
@@ -47639,7 +47943,7 @@ | ||
47639 | 47943 | LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
47640 | 47944 | } |
47641 | 47945 | // ACCUMULATE ARGUMENTS - END |
47642 | - uint64_t return_to = 18446744073709549549LLU; | |
47946 | + uint64_t return_to = 18446744073709549536LLU; | |
47643 | 47947 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
47644 | 47948 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
47645 | 47949 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -47648,7 +47952,7 @@ | ||
47648 | 47952 | state.addr = 819857494882385920LLU; // res_u64___ |
47649 | 47953 | break; |
47650 | 47954 | } |
47651 | - case 18446744073709549549LLU: // 99999999dr''''''''''''''' | |
47955 | + case 18446744073709549536LLU: // 99999999de''''''''''''''' | |
47652 | 47956 | { |
47653 | 47957 | // ACCUMULATE ARGUMENTS - BEGIN |
47654 | 47958 | { |
@@ -47656,7 +47960,7 @@ | ||
47656 | 47960 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
47657 | 47961 | } |
47658 | 47962 | // ACCUMULATE ARGUMENTS - END |
47659 | - uint64_t return_to = 18446744073709549548LLU; | |
47963 | + uint64_t return_to = 18446744073709549535LLU; | |
47660 | 47964 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
47661 | 47965 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
47662 | 47966 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -47665,7 +47969,7 @@ | ||
47665 | 47969 | state.addr = 839519665163075584LLU; // skip______ |
47666 | 47970 | break; |
47667 | 47971 | } |
47668 | - case 18446744073709549548LLU: // 99999999dq''''''''''''''' | |
47972 | + case 18446744073709549535LLU: // 99999999dd''''''''''''''' | |
47669 | 47973 | { |
47670 | 47974 | matchid("(", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU))); |
47671 | 47975 | fprintf(stdout, "%s", "\n "); |
@@ -47691,7 +47995,7 @@ | ||
47691 | 47995 | LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
47692 | 47996 | } |
47693 | 47997 | // ACCUMULATE ARGUMENTS - END |
47694 | - uint64_t return_to = 18446744073709549547LLU; | |
47998 | + uint64_t return_to = 18446744073709549534LLU; | |
47695 | 47999 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)); |
47696 | 48000 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
47697 | 48001 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -47700,7 +48004,7 @@ | ||
47700 | 48004 | state.addr = 587881357514113024LLU; // emitpar___ |
47701 | 48005 | break; |
47702 | 48006 | } |
47703 | - case 18446744073709549547LLU: // 99999999dp''''''''''''''' | |
48007 | + case 18446744073709549534LLU: // 99999999dc''''''''''''''' | |
47704 | 48008 | { |
47705 | 48009 | fprintf(stdout, "%s", " = "); |
47706 | 48010 | // ACCUMULATE ARGUMENTS - BEGIN |
@@ -47709,7 +48013,7 @@ | ||
47709 | 48013 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
47710 | 48014 | } |
47711 | 48015 | // ACCUMULATE ARGUMENTS - END |
47712 | - uint64_t return_to = 18446744073709549546LLU; | |
48016 | + uint64_t return_to = 18446744073709549533LLU; | |
47713 | 48017 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
47714 | 48018 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
47715 | 48019 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -47718,7 +48022,7 @@ | ||
47718 | 48022 | state.addr = 839519665163075584LLU; // skip______ |
47719 | 48023 | break; |
47720 | 48024 | } |
47721 | - case 18446744073709549546LLU: // 99999999do''''''''''''''' | |
48025 | + case 18446744073709549533LLU: // 99999999db''''''''''''''' | |
47722 | 48026 | { |
47723 | 48027 | |
47724 | 48028 | *LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU))); |
@@ -47740,7 +48044,7 @@ | ||
47740 | 48044 | LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
47741 | 48045 | } |
47742 | 48046 | // ACCUMULATE ARGUMENTS - END |
47743 | - uint64_t return_to = 18446744073709549545LLU; | |
48047 | + uint64_t return_to = 18446744073709549532LLU; | |
47744 | 48048 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
47745 | 48049 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
47746 | 48050 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -47749,7 +48053,7 @@ | ||
47749 | 48053 | state.addr = 23446349213393492LLU; // ASSERTINIT |
47750 | 48054 | break; |
47751 | 48055 | } |
47752 | - case 18446744073709549545LLU: // 99999999dn''''''''''''''' | |
48056 | + case 18446744073709549532LLU: // 99999999da''''''''''''''' | |
47753 | 48057 | { |
47754 | 48058 | { |
47755 | 48059 | uint64_t arg = 0; |
@@ -47828,7 +48132,7 @@ | ||
47828 | 48132 | LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
47829 | 48133 | } |
47830 | 48134 | // ACCUMULATE ARGUMENTS - END |
47831 | - uint64_t return_to = 18446744073709549544LLU; | |
48135 | + uint64_t return_to = 18446744073709549531LLU; | |
47832 | 48136 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)); |
47833 | 48137 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
47834 | 48138 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -47837,7 +48141,7 @@ | ||
47837 | 48141 | state.addr = 293363126232490310LLU; // PROCVARREF |
47838 | 48142 | break; |
47839 | 48143 | } |
47840 | - case 18446744073709549544LLU: // 99999999dm''''''''''''''' | |
48144 | + case 18446744073709549531LLU: // 99999999d$''''''''''''''' | |
47841 | 48145 | { |
47842 | 48146 | // variable u64 initialize goes out of scope |
47843 | 48147 | // emitted destructur for type u64 |
@@ -47858,7 +48162,7 @@ | ||
47858 | 48162 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
47859 | 48163 | } |
47860 | 48164 | // ACCUMULATE ARGUMENTS - END |
47861 | - uint64_t return_to = 18446744073709549543LLU; | |
48165 | + uint64_t return_to = 18446744073709549530LLU; | |
47862 | 48166 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
47863 | 48167 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
47864 | 48168 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -47867,7 +48171,7 @@ | ||
47867 | 48171 | state.addr = 517555565476695680LLU; // assertu64_ |
47868 | 48172 | break; |
47869 | 48173 | } |
47870 | - case 18446744073709549543LLU: // 99999999dl''''''''''''''' | |
48174 | + case 18446744073709549530LLU: // 99999999dZ''''''''''''''' | |
47871 | 48175 | { |
47872 | 48176 | // ACCUMULATE ARGUMENTS - BEGIN |
47873 | 48177 | { |
@@ -47875,7 +48179,7 @@ | ||
47875 | 48179 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
47876 | 48180 | } |
47877 | 48181 | // ACCUMULATE ARGUMENTS - END |
47878 | - uint64_t return_to = 18446744073709549542LLU; | |
48182 | + uint64_t return_to = 18446744073709549529LLU; | |
47879 | 48183 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
47880 | 48184 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
47881 | 48185 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -47884,7 +48188,7 @@ | ||
47884 | 48188 | state.addr = 839519665163075584LLU; // skip______ |
47885 | 48189 | break; |
47886 | 48190 | } |
47887 | - case 18446744073709549542LLU: // 99999999dk''''''''''''''' | |
48191 | + case 18446744073709549529LLU: // 99999999dY''''''''''''''' | |
47888 | 48192 | { |
47889 | 48193 | matchid(",", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU))); |
47890 | 48194 | fprintf(stdout, "%s", " & "); |
@@ -47894,7 +48198,7 @@ | ||
47894 | 48198 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
47895 | 48199 | } |
47896 | 48200 | // ACCUMULATE ARGUMENTS - END |
47897 | - uint64_t return_to = 18446744073709549541LLU; | |
48201 | + uint64_t return_to = 18446744073709549528LLU; | |
47898 | 48202 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
47899 | 48203 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
47900 | 48204 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -47903,7 +48207,7 @@ | ||
47903 | 48207 | state.addr = 839519665163075584LLU; // skip______ |
47904 | 48208 | break; |
47905 | 48209 | } |
47906 | - case 18446744073709549541LLU: // 99999999dj''''''''''''''' | |
48210 | + case 18446744073709549528LLU: // 99999999dX''''''''''''''' | |
47907 | 48211 | { |
47908 | 48212 | |
47909 | 48213 | *LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU))); |
@@ -47925,7 +48229,7 @@ | ||
47925 | 48229 | LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
47926 | 48230 | } |
47927 | 48231 | // ACCUMULATE ARGUMENTS - END |
47928 | - uint64_t return_to = 18446744073709549540LLU; | |
48232 | + uint64_t return_to = 18446744073709549527LLU; | |
47929 | 48233 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
47930 | 48234 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
47931 | 48235 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -47934,7 +48238,7 @@ | ||
47934 | 48238 | state.addr = 23446349213393492LLU; // ASSERTINIT |
47935 | 48239 | break; |
47936 | 48240 | } |
47937 | - case 18446744073709549540LLU: // 99999999di''''''''''''''' | |
48241 | + case 18446744073709549527LLU: // 99999999dW''''''''''''''' | |
47938 | 48242 | { |
47939 | 48243 | { |
47940 | 48244 | uint64_t arg = 0; |
@@ -48013,7 +48317,7 @@ | ||
48013 | 48317 | LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
48014 | 48318 | } |
48015 | 48319 | // ACCUMULATE ARGUMENTS - END |
48016 | - uint64_t return_to = 18446744073709549539LLU; | |
48320 | + uint64_t return_to = 18446744073709549526LLU; | |
48017 | 48321 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)); |
48018 | 48322 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
48019 | 48323 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -48022,7 +48326,7 @@ | ||
48022 | 48326 | state.addr = 293363126232490310LLU; // PROCVARREF |
48023 | 48327 | break; |
48024 | 48328 | } |
48025 | - case 18446744073709549539LLU: // 99999999dh''''''''''''''' | |
48329 | + case 18446744073709549526LLU: // 99999999dV''''''''''''''' | |
48026 | 48330 | { |
48027 | 48331 | // variable u64 initialize goes out of scope |
48028 | 48332 | // emitted destructur for type u64 |
@@ -48043,7 +48347,7 @@ | ||
48043 | 48347 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
48044 | 48348 | } |
48045 | 48349 | // ACCUMULATE ARGUMENTS - END |
48046 | - uint64_t return_to = 18446744073709549538LLU; | |
48350 | + uint64_t return_to = 18446744073709549525LLU; | |
48047 | 48351 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
48048 | 48352 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
48049 | 48353 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -48052,7 +48356,7 @@ | ||
48052 | 48356 | state.addr = 517555565476695680LLU; // assertu64_ |
48053 | 48357 | break; |
48054 | 48358 | } |
48055 | - case 18446744073709549538LLU: // 99999999dg''''''''''''''' | |
48359 | + case 18446744073709549525LLU: // 99999999dU''''''''''''''' | |
48056 | 48360 | { |
48057 | 48361 | // ACCUMULATE ARGUMENTS - BEGIN |
48058 | 48362 | { |
@@ -48060,7 +48364,7 @@ | ||
48060 | 48364 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
48061 | 48365 | } |
48062 | 48366 | // ACCUMULATE ARGUMENTS - END |
48063 | - uint64_t return_to = 18446744073709549537LLU; | |
48367 | + uint64_t return_to = 18446744073709549524LLU; | |
48064 | 48368 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
48065 | 48369 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
48066 | 48370 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -48069,7 +48373,7 @@ | ||
48069 | 48373 | state.addr = 839519665163075584LLU; // skip______ |
48070 | 48374 | break; |
48071 | 48375 | } |
48072 | - case 18446744073709549537LLU: // 99999999df''''''''''''''' | |
48376 | + case 18446744073709549524LLU: // 99999999dT''''''''''''''' | |
48073 | 48377 | { |
48074 | 48378 | matchid(")", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU))); |
48075 | 48379 | fprintf(stdout, "%s", ";"); |
@@ -48081,7 +48385,7 @@ | ||
48081 | 48385 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
48082 | 48386 | } |
48083 | 48387 | // ACCUMULATE ARGUMENTS - END |
48084 | - uint64_t return_to = 18446744073709549536LLU; | |
48388 | + uint64_t return_to = 18446744073709549523LLU; | |
48085 | 48389 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
48086 | 48390 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
48087 | 48391 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -48090,7 +48394,7 @@ | ||
48090 | 48394 | state.addr = 18446744073709551534LLU; // 999999998s''''''''''''''' |
48091 | 48395 | break; |
48092 | 48396 | } |
48093 | - case 18446744073709549536LLU: // 99999999de''''''''''''''' | |
48397 | + case 18446744073709549523LLU: // 99999999dS''''''''''''''' | |
48094 | 48398 | { |
48095 | 48399 | (void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference single____ at 21 |
48096 | 48400 | // variable type______ type______ goes out of scope |
@@ -48101,7 +48405,7 @@ | ||
48101 | 48405 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
48102 | 48406 | } |
48103 | 48407 | // ACCUMULATE ARGUMENTS - END |
48104 | - uint64_t return_to = 18446744073709549535LLU; | |
48408 | + uint64_t return_to = 18446744073709549522LLU; | |
48105 | 48409 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
48106 | 48410 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
48107 | 48411 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -48110,7 +48414,7 @@ | ||
48110 | 48414 | state.addr = 18446744073709551573LLU; // 999999999U''''''''''''''' |
48111 | 48415 | break; |
48112 | 48416 | } |
48113 | - case 18446744073709549535LLU: // 99999999dd''''''''''''''' | |
48417 | + case 18446744073709549522LLU: // 99999999dR''''''''''''''' | |
48114 | 48418 | { |
48115 | 48419 | (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type______ at 20 |
48116 | 48420 | // variable u64 mutable___ goes out of scope |
@@ -48122,10 +48426,10 @@ | ||
48122 | 48426 | // variable u64 id________ goes out of scope |
48123 | 48427 | // emitted destructur for type u64 |
48124 | 48428 | (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id________ at 17 |
48125 | - state.addr = 18446744073709549553LLU; // 99999999dv''''''''''''''' | |
48429 | + state.addr = 18446744073709549540LLU; // 99999999di''''''''''''''' | |
48126 | 48430 | break; |
48127 | 48431 | } |
48128 | - case 18446744073709549554LLU: // 99999999dw''''''''''''''' | |
48432 | + case 18446744073709549541LLU: // 99999999dj''''''''''''''' | |
48129 | 48433 | { |
48130 | 48434 | |
48131 | 48435 | *LOCAL_ACCESS(heap.data, 16LLU, 15LLU) = 532757409974714368; |
@@ -48136,11 +48440,11 @@ | ||
48136 | 48440 | LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
48137 | 48441 | } |
48138 | 48442 | *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 0LLU)); |
48139 | - state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549534LLU : 18446744073709549533LLU; | |
48443 | + state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549521LLU : 18446744073709549520LLU; | |
48140 | 48444 | (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 17 |
48141 | 48445 | break; |
48142 | 48446 | } |
48143 | - case 18446744073709549534LLU: // 99999999dc''''''''''''''' | |
48447 | + case 18446744073709549521LLU: // 99999999dQ''''''''''''''' | |
48144 | 48448 | { |
48145 | 48449 | { |
48146 | 48450 | uint64_t arg = 0; |
@@ -48167,7 +48471,7 @@ | ||
48167 | 48471 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
48168 | 48472 | } |
48169 | 48473 | // ACCUMULATE ARGUMENTS - END |
48170 | - uint64_t return_to = 18446744073709549531LLU; | |
48474 | + uint64_t return_to = 18446744073709549518LLU; | |
48171 | 48475 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
48172 | 48476 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
48173 | 48477 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -48176,7 +48480,7 @@ | ||
48176 | 48480 | state.addr = 861504796319285248LLU; // typeu64___ |
48177 | 48481 | break; |
48178 | 48482 | } |
48179 | - case 18446744073709549531LLU: // 99999999d$''''''''''''''' | |
48483 | + case 18446744073709549518LLU: // 99999999dN''''''''''''''' | |
48180 | 48484 | { |
48181 | 48485 | { |
48182 | 48486 | uint64_t arg = 0; |
@@ -48201,7 +48505,7 @@ | ||
48201 | 48505 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
48202 | 48506 | } |
48203 | 48507 | // ACCUMULATE ARGUMENTS - END |
48204 | - uint64_t return_to = 18446744073709549529LLU; | |
48508 | + uint64_t return_to = 18446744073709549516LLU; | |
48205 | 48509 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
48206 | 48510 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
48207 | 48511 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -48210,7 +48514,7 @@ | ||
48210 | 48514 | state.addr = 861504796319285248LLU; // typeu64___ |
48211 | 48515 | break; |
48212 | 48516 | } |
48213 | - case 18446744073709549529LLU: // 99999999dY''''''''''''''' | |
48517 | + case 18446744073709549516LLU: // 99999999dL''''''''''''''' | |
48214 | 48518 | { |
48215 | 48519 | { |
48216 | 48520 | uint64_t exchange = LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 23*/; |
@@ -48230,7 +48534,7 @@ | ||
48230 | 48534 | LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
48231 | 48535 | } |
48232 | 48536 | // ACCUMULATE ARGUMENTS - END |
48233 | - uint64_t return_to = 18446744073709549530LLU; | |
48537 | + uint64_t return_to = 18446744073709549517LLU; | |
48234 | 48538 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
48235 | 48539 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
48236 | 48540 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -48239,7 +48543,7 @@ | ||
48239 | 48543 | state.addr = 819859607768530944LLU; // resdest___ |
48240 | 48544 | break; |
48241 | 48545 | } |
48242 | - case 18446744073709549530LLU: // 99999999dZ''''''''''''''' | |
48546 | + case 18446744073709549517LLU: // 99999999dM''''''''''''''' | |
48243 | 48547 | { |
48244 | 48548 | // ACCUMULATE ARGUMENTS - BEGIN |
48245 | 48549 | { |
@@ -48259,7 +48563,7 @@ | ||
48259 | 48563 | LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
48260 | 48564 | } |
48261 | 48565 | // ACCUMULATE ARGUMENTS - END |
48262 | - uint64_t return_to = 18446744073709549528LLU; | |
48566 | + uint64_t return_to = 18446744073709549515LLU; | |
48263 | 48567 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
48264 | 48568 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
48265 | 48569 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -48268,7 +48572,7 @@ | ||
48268 | 48572 | state.addr = 819857494882385920LLU; // res_u64___ |
48269 | 48573 | break; |
48270 | 48574 | } |
48271 | - case 18446744073709549528LLU: // 99999999dX''''''''''''''' | |
48575 | + case 18446744073709549515LLU: // 99999999dK''''''''''''''' | |
48272 | 48576 | { |
48273 | 48577 | // ACCUMULATE ARGUMENTS - BEGIN |
48274 | 48578 | { |
@@ -48276,7 +48580,7 @@ | ||
48276 | 48580 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
48277 | 48581 | } |
48278 | 48582 | // ACCUMULATE ARGUMENTS - END |
48279 | - uint64_t return_to = 18446744073709549527LLU; | |
48583 | + uint64_t return_to = 18446744073709549514LLU; | |
48280 | 48584 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
48281 | 48585 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
48282 | 48586 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -48285,7 +48589,7 @@ | ||
48285 | 48589 | state.addr = 839519665163075584LLU; // skip______ |
48286 | 48590 | break; |
48287 | 48591 | } |
48288 | - case 18446744073709549527LLU: // 99999999dW''''''''''''''' | |
48592 | + case 18446744073709549514LLU: // 99999999dJ''''''''''''''' | |
48289 | 48593 | { |
48290 | 48594 | matchid("(", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU))); |
48291 | 48595 | fprintf(stdout, "%s", "\n "); |
@@ -48311,7 +48615,7 @@ | ||
48311 | 48615 | LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
48312 | 48616 | } |
48313 | 48617 | // ACCUMULATE ARGUMENTS - END |
48314 | - uint64_t return_to = 18446744073709549526LLU; | |
48618 | + uint64_t return_to = 18446744073709549513LLU; | |
48315 | 48619 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)); |
48316 | 48620 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
48317 | 48621 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -48320,7 +48624,7 @@ | ||
48320 | 48624 | state.addr = 587881357514113024LLU; // emitpar___ |
48321 | 48625 | break; |
48322 | 48626 | } |
48323 | - case 18446744073709549526LLU: // 99999999dV''''''''''''''' | |
48627 | + case 18446744073709549513LLU: // 99999999dI''''''''''''''' | |
48324 | 48628 | { |
48325 | 48629 | fprintf(stdout, "%s", " = "); |
48326 | 48630 | // ACCUMULATE ARGUMENTS - BEGIN |
@@ -48329,7 +48633,7 @@ | ||
48329 | 48633 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
48330 | 48634 | } |
48331 | 48635 | // ACCUMULATE ARGUMENTS - END |
48332 | - uint64_t return_to = 18446744073709549525LLU; | |
48636 | + uint64_t return_to = 18446744073709549512LLU; | |
48333 | 48637 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
48334 | 48638 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
48335 | 48639 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -48338,7 +48642,7 @@ | ||
48338 | 48642 | state.addr = 839519665163075584LLU; // skip______ |
48339 | 48643 | break; |
48340 | 48644 | } |
48341 | - case 18446744073709549525LLU: // 99999999dU''''''''''''''' | |
48645 | + case 18446744073709549512LLU: // 99999999dH''''''''''''''' | |
48342 | 48646 | { |
48343 | 48647 | |
48344 | 48648 | *LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU))); |
@@ -48360,7 +48664,7 @@ | ||
48360 | 48664 | LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
48361 | 48665 | } |
48362 | 48666 | // ACCUMULATE ARGUMENTS - END |
48363 | - uint64_t return_to = 18446744073709549524LLU; | |
48667 | + uint64_t return_to = 18446744073709549511LLU; | |
48364 | 48668 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
48365 | 48669 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
48366 | 48670 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -48369,7 +48673,7 @@ | ||
48369 | 48673 | state.addr = 23446349213393492LLU; // ASSERTINIT |
48370 | 48674 | break; |
48371 | 48675 | } |
48372 | - case 18446744073709549524LLU: // 99999999dT''''''''''''''' | |
48676 | + case 18446744073709549511LLU: // 99999999dG''''''''''''''' | |
48373 | 48677 | { |
48374 | 48678 | { |
48375 | 48679 | uint64_t arg = 0; |
@@ -48448,7 +48752,7 @@ | ||
48448 | 48752 | LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
48449 | 48753 | } |
48450 | 48754 | // ACCUMULATE ARGUMENTS - END |
48451 | - uint64_t return_to = 18446744073709549523LLU; | |
48755 | + uint64_t return_to = 18446744073709549510LLU; | |
48452 | 48756 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)); |
48453 | 48757 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
48454 | 48758 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -48457,7 +48761,7 @@ | ||
48457 | 48761 | state.addr = 293363126232490310LLU; // PROCVARREF |
48458 | 48762 | break; |
48459 | 48763 | } |
48460 | - case 18446744073709549523LLU: // 99999999dS''''''''''''''' | |
48764 | + case 18446744073709549510LLU: // 99999999dF''''''''''''''' | |
48461 | 48765 | { |
48462 | 48766 | // variable u64 initialize goes out of scope |
48463 | 48767 | // emitted destructur for type u64 |
@@ -48478,7 +48782,7 @@ | ||
48478 | 48782 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
48479 | 48783 | } |
48480 | 48784 | // ACCUMULATE ARGUMENTS - END |
48481 | - uint64_t return_to = 18446744073709549522LLU; | |
48785 | + uint64_t return_to = 18446744073709549509LLU; | |
48482 | 48786 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
48483 | 48787 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
48484 | 48788 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -48487,7 +48791,7 @@ | ||
48487 | 48791 | state.addr = 517555565476695680LLU; // assertu64_ |
48488 | 48792 | break; |
48489 | 48793 | } |
48490 | - case 18446744073709549522LLU: // 99999999dR''''''''''''''' | |
48794 | + case 18446744073709549509LLU: // 99999999dE''''''''''''''' | |
48491 | 48795 | { |
48492 | 48796 | // ACCUMULATE ARGUMENTS - BEGIN |
48493 | 48797 | { |
@@ -48495,7 +48799,7 @@ | ||
48495 | 48799 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
48496 | 48800 | } |
48497 | 48801 | // ACCUMULATE ARGUMENTS - END |
48498 | - uint64_t return_to = 18446744073709549521LLU; | |
48802 | + uint64_t return_to = 18446744073709549508LLU; | |
48499 | 48803 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
48500 | 48804 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
48501 | 48805 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -48504,7 +48808,7 @@ | ||
48504 | 48808 | state.addr = 839519665163075584LLU; // skip______ |
48505 | 48809 | break; |
48506 | 48810 | } |
48507 | - case 18446744073709549521LLU: // 99999999dQ''''''''''''''' | |
48811 | + case 18446744073709549508LLU: // 99999999dD''''''''''''''' | |
48508 | 48812 | { |
48509 | 48813 | matchid(",", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU))); |
48510 | 48814 | fprintf(stdout, "%s", " | "); |
@@ -48514,7 +48818,7 @@ | ||
48514 | 48818 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
48515 | 48819 | } |
48516 | 48820 | // ACCUMULATE ARGUMENTS - END |
48517 | - uint64_t return_to = 18446744073709549520LLU; | |
48821 | + uint64_t return_to = 18446744073709549507LLU; | |
48518 | 48822 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
48519 | 48823 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
48520 | 48824 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -48523,7 +48827,7 @@ | ||
48523 | 48827 | state.addr = 839519665163075584LLU; // skip______ |
48524 | 48828 | break; |
48525 | 48829 | } |
48526 | - case 18446744073709549520LLU: // 99999999dP''''''''''''''' | |
48830 | + case 18446744073709549507LLU: // 99999999dC''''''''''''''' | |
48527 | 48831 | { |
48528 | 48832 | |
48529 | 48833 | *LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU))); |
@@ -48545,7 +48849,7 @@ | ||
48545 | 48849 | LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
48546 | 48850 | } |
48547 | 48851 | // ACCUMULATE ARGUMENTS - END |
48548 | - uint64_t return_to = 18446744073709549519LLU; | |
48852 | + uint64_t return_to = 18446744073709549506LLU; | |
48549 | 48853 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
48550 | 48854 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
48551 | 48855 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -48554,7 +48858,7 @@ | ||
48554 | 48858 | state.addr = 23446349213393492LLU; // ASSERTINIT |
48555 | 48859 | break; |
48556 | 48860 | } |
48557 | - case 18446744073709549519LLU: // 99999999dO''''''''''''''' | |
48861 | + case 18446744073709549506LLU: // 99999999dB''''''''''''''' | |
48558 | 48862 | { |
48559 | 48863 | { |
48560 | 48864 | uint64_t arg = 0; |
@@ -48633,7 +48937,7 @@ | ||
48633 | 48937 | LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
48634 | 48938 | } |
48635 | 48939 | // ACCUMULATE ARGUMENTS - END |
48636 | - uint64_t return_to = 18446744073709549518LLU; | |
48940 | + uint64_t return_to = 18446744073709549505LLU; | |
48637 | 48941 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)); |
48638 | 48942 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
48639 | 48943 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -48642,7 +48946,7 @@ | ||
48642 | 48946 | state.addr = 293363126232490310LLU; // PROCVARREF |
48643 | 48947 | break; |
48644 | 48948 | } |
48645 | - case 18446744073709549518LLU: // 99999999dN''''''''''''''' | |
48949 | + case 18446744073709549505LLU: // 99999999dA''''''''''''''' | |
48646 | 48950 | { |
48647 | 48951 | // variable u64 initialize goes out of scope |
48648 | 48952 | // emitted destructur for type u64 |
@@ -48663,7 +48967,7 @@ | ||
48663 | 48967 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
48664 | 48968 | } |
48665 | 48969 | // ACCUMULATE ARGUMENTS - END |
48666 | - uint64_t return_to = 18446744073709549517LLU; | |
48970 | + uint64_t return_to = 18446744073709549504LLU; | |
48667 | 48971 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
48668 | 48972 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
48669 | 48973 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -48672,7 +48976,7 @@ | ||
48672 | 48976 | state.addr = 517555565476695680LLU; // assertu64_ |
48673 | 48977 | break; |
48674 | 48978 | } |
48675 | - case 18446744073709549517LLU: // 99999999dM''''''''''''''' | |
48979 | + case 18446744073709549504LLU: // 99999999d_''''''''''''''' | |
48676 | 48980 | { |
48677 | 48981 | // ACCUMULATE ARGUMENTS - BEGIN |
48678 | 48982 | { |
@@ -48680,7 +48984,7 @@ | ||
48680 | 48984 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
48681 | 48985 | } |
48682 | 48986 | // ACCUMULATE ARGUMENTS - END |
48683 | - uint64_t return_to = 18446744073709549516LLU; | |
48987 | + uint64_t return_to = 18446744073709549503LLU; | |
48684 | 48988 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
48685 | 48989 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
48686 | 48990 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -48689,7 +48993,7 @@ | ||
48689 | 48993 | state.addr = 839519665163075584LLU; // skip______ |
48690 | 48994 | break; |
48691 | 48995 | } |
48692 | - case 18446744073709549516LLU: // 99999999dL''''''''''''''' | |
48996 | + case 18446744073709549503LLU: // 99999999c9''''''''''''''' | |
48693 | 48997 | { |
48694 | 48998 | matchid(")", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU))); |
48695 | 48999 | fprintf(stdout, "%s", ";"); |
@@ -48701,7 +49005,7 @@ | ||
48701 | 49005 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
48702 | 49006 | } |
48703 | 49007 | // ACCUMULATE ARGUMENTS - END |
48704 | - uint64_t return_to = 18446744073709549515LLU; | |
49008 | + uint64_t return_to = 18446744073709549502LLU; | |
48705 | 49009 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
48706 | 49010 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
48707 | 49011 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -48710,7 +49014,7 @@ | ||
48710 | 49014 | state.addr = 18446744073709551534LLU; // 999999998s''''''''''''''' |
48711 | 49015 | break; |
48712 | 49016 | } |
48713 | - case 18446744073709549515LLU: // 99999999dK''''''''''''''' | |
49017 | + case 18446744073709549502LLU: // 99999999c8''''''''''''''' | |
48714 | 49018 | { |
48715 | 49019 | (void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference single____ at 21 |
48716 | 49020 | // variable type______ type______ goes out of scope |
@@ -48721,7 +49025,7 @@ | ||
48721 | 49025 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
48722 | 49026 | } |
48723 | 49027 | // ACCUMULATE ARGUMENTS - END |
48724 | - uint64_t return_to = 18446744073709549514LLU; | |
49028 | + uint64_t return_to = 18446744073709549501LLU; | |
48725 | 49029 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
48726 | 49030 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
48727 | 49031 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -48730,7 +49034,7 @@ | ||
48730 | 49034 | state.addr = 18446744073709551573LLU; // 999999999U''''''''''''''' |
48731 | 49035 | break; |
48732 | 49036 | } |
48733 | - case 18446744073709549514LLU: // 99999999dJ''''''''''''''' | |
49037 | + case 18446744073709549501LLU: // 99999999c7''''''''''''''' | |
48734 | 49038 | { |
48735 | 49039 | (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type______ at 20 |
48736 | 49040 | // variable u64 mutable___ goes out of scope |
@@ -48742,10 +49046,10 @@ | ||
48742 | 49046 | // variable u64 id________ goes out of scope |
48743 | 49047 | // emitted destructur for type u64 |
48744 | 49048 | (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id________ at 17 |
48745 | - state.addr = 18446744073709549532LLU; // 99999999da''''''''''''''' | |
49049 | + state.addr = 18446744073709549519LLU; // 99999999dO''''''''''''''' | |
48746 | 49050 | break; |
48747 | 49051 | } |
48748 | - case 18446744073709549533LLU: // 99999999db''''''''''''''' | |
49052 | + case 18446744073709549520LLU: // 99999999dP''''''''''''''' | |
48749 | 49053 | { |
48750 | 49054 | |
48751 | 49055 | *LOCAL_ACCESS(heap.data, 16LLU, 15LLU) = 516079971752476672; |
@@ -48756,11 +49060,11 @@ | ||
48756 | 49060 | LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
48757 | 49061 | } |
48758 | 49062 | *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 0LLU)); |
48759 | - state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549513LLU : 18446744073709549512LLU; | |
49063 | + state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549500LLU : 18446744073709549499LLU; | |
48760 | 49064 | (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 17 |
48761 | 49065 | break; |
48762 | 49066 | } |
48763 | - case 18446744073709549513LLU: // 99999999dI''''''''''''''' | |
49067 | + case 18446744073709549500LLU: // 99999999c6''''''''''''''' | |
48764 | 49068 | { |
48765 | 49069 | { |
48766 | 49070 | uint64_t arg = 0; |
@@ -48787,7 +49091,7 @@ | ||
48787 | 49091 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
48788 | 49092 | } |
48789 | 49093 | // ACCUMULATE ARGUMENTS - END |
48790 | - uint64_t return_to = 18446744073709549510LLU; | |
49094 | + uint64_t return_to = 18446744073709549497LLU; | |
48791 | 49095 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
48792 | 49096 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
48793 | 49097 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -48796,7 +49100,7 @@ | ||
48796 | 49100 | state.addr = 861504796319285248LLU; // typeu64___ |
48797 | 49101 | break; |
48798 | 49102 | } |
48799 | - case 18446744073709549510LLU: // 99999999dF''''''''''''''' | |
49103 | + case 18446744073709549497LLU: // 99999999c3''''''''''''''' | |
48800 | 49104 | { |
48801 | 49105 | { |
48802 | 49106 | uint64_t arg = 0; |
@@ -48821,7 +49125,7 @@ | ||
48821 | 49125 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
48822 | 49126 | } |
48823 | 49127 | // ACCUMULATE ARGUMENTS - END |
48824 | - uint64_t return_to = 18446744073709549508LLU; | |
49128 | + uint64_t return_to = 18446744073709549495LLU; | |
48825 | 49129 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
48826 | 49130 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
48827 | 49131 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -48830,7 +49134,7 @@ | ||
48830 | 49134 | state.addr = 861504796319285248LLU; // typeu64___ |
48831 | 49135 | break; |
48832 | 49136 | } |
48833 | - case 18446744073709549508LLU: // 99999999dD''''''''''''''' | |
49137 | + case 18446744073709549495LLU: // 99999999c1''''''''''''''' | |
48834 | 49138 | { |
48835 | 49139 | { |
48836 | 49140 | uint64_t exchange = LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 23*/; |
@@ -48850,7 +49154,7 @@ | ||
48850 | 49154 | LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
48851 | 49155 | } |
48852 | 49156 | // ACCUMULATE ARGUMENTS - END |
48853 | - uint64_t return_to = 18446744073709549509LLU; | |
49157 | + uint64_t return_to = 18446744073709549496LLU; | |
48854 | 49158 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
48855 | 49159 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
48856 | 49160 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -48859,7 +49163,7 @@ | ||
48859 | 49163 | state.addr = 819859607768530944LLU; // resdest___ |
48860 | 49164 | break; |
48861 | 49165 | } |
48862 | - case 18446744073709549509LLU: // 99999999dE''''''''''''''' | |
49166 | + case 18446744073709549496LLU: // 99999999c2''''''''''''''' | |
48863 | 49167 | { |
48864 | 49168 | // ACCUMULATE ARGUMENTS - BEGIN |
48865 | 49169 | { |
@@ -48879,7 +49183,7 @@ | ||
48879 | 49183 | LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
48880 | 49184 | } |
48881 | 49185 | // ACCUMULATE ARGUMENTS - END |
48882 | - uint64_t return_to = 18446744073709549507LLU; | |
49186 | + uint64_t return_to = 18446744073709549494LLU; | |
48883 | 49187 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
48884 | 49188 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
48885 | 49189 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -48888,7 +49192,7 @@ | ||
48888 | 49192 | state.addr = 819857494882385920LLU; // res_u64___ |
48889 | 49193 | break; |
48890 | 49194 | } |
48891 | - case 18446744073709549507LLU: // 99999999dC''''''''''''''' | |
49195 | + case 18446744073709549494LLU: // 99999999c0''''''''''''''' | |
48892 | 49196 | { |
48893 | 49197 | // ACCUMULATE ARGUMENTS - BEGIN |
48894 | 49198 | { |
@@ -48896,7 +49200,7 @@ | ||
48896 | 49200 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
48897 | 49201 | } |
48898 | 49202 | // ACCUMULATE ARGUMENTS - END |
48899 | - uint64_t return_to = 18446744073709549506LLU; | |
49203 | + uint64_t return_to = 18446744073709549493LLU; | |
48900 | 49204 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
48901 | 49205 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
48902 | 49206 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -48905,7 +49209,7 @@ | ||
48905 | 49209 | state.addr = 839519665163075584LLU; // skip______ |
48906 | 49210 | break; |
48907 | 49211 | } |
48908 | - case 18446744073709549506LLU: // 99999999dB''''''''''''''' | |
49212 | + case 18446744073709549493LLU: // 99999999cz''''''''''''''' | |
48909 | 49213 | { |
48910 | 49214 | matchid("(", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU))); |
48911 | 49215 | fprintf(stdout, "%s", "\n "); |
@@ -48931,7 +49235,7 @@ | ||
48931 | 49235 | LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
48932 | 49236 | } |
48933 | 49237 | // ACCUMULATE ARGUMENTS - END |
48934 | - uint64_t return_to = 18446744073709549505LLU; | |
49238 | + uint64_t return_to = 18446744073709549492LLU; | |
48935 | 49239 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)); |
48936 | 49240 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
48937 | 49241 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -48940,7 +49244,7 @@ | ||
48940 | 49244 | state.addr = 587881357514113024LLU; // emitpar___ |
48941 | 49245 | break; |
48942 | 49246 | } |
48943 | - case 18446744073709549505LLU: // 99999999dA''''''''''''''' | |
49247 | + case 18446744073709549492LLU: // 99999999cy''''''''''''''' | |
48944 | 49248 | { |
48945 | 49249 | fprintf(stdout, "%s", " = "); |
48946 | 49250 | // ACCUMULATE ARGUMENTS - BEGIN |
@@ -48949,7 +49253,7 @@ | ||
48949 | 49253 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
48950 | 49254 | } |
48951 | 49255 | // ACCUMULATE ARGUMENTS - END |
48952 | - uint64_t return_to = 18446744073709549504LLU; | |
49256 | + uint64_t return_to = 18446744073709549491LLU; | |
48953 | 49257 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
48954 | 49258 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
48955 | 49259 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -48958,7 +49262,7 @@ | ||
48958 | 49262 | state.addr = 839519665163075584LLU; // skip______ |
48959 | 49263 | break; |
48960 | 49264 | } |
48961 | - case 18446744073709549504LLU: // 99999999d_''''''''''''''' | |
49265 | + case 18446744073709549491LLU: // 99999999cx''''''''''''''' | |
48962 | 49266 | { |
48963 | 49267 | |
48964 | 49268 | *LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU))); |
@@ -48980,7 +49284,7 @@ | ||
48980 | 49284 | LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
48981 | 49285 | } |
48982 | 49286 | // ACCUMULATE ARGUMENTS - END |
48983 | - uint64_t return_to = 18446744073709549503LLU; | |
49287 | + uint64_t return_to = 18446744073709549490LLU; | |
48984 | 49288 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
48985 | 49289 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
48986 | 49290 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -48989,7 +49293,7 @@ | ||
48989 | 49293 | state.addr = 23446349213393492LLU; // ASSERTINIT |
48990 | 49294 | break; |
48991 | 49295 | } |
48992 | - case 18446744073709549503LLU: // 99999999c9''''''''''''''' | |
49296 | + case 18446744073709549490LLU: // 99999999cw''''''''''''''' | |
48993 | 49297 | { |
48994 | 49298 | { |
48995 | 49299 | uint64_t arg = 0; |
@@ -49068,7 +49372,7 @@ | ||
49068 | 49372 | LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
49069 | 49373 | } |
49070 | 49374 | // ACCUMULATE ARGUMENTS - END |
49071 | - uint64_t return_to = 18446744073709549502LLU; | |
49375 | + uint64_t return_to = 18446744073709549489LLU; | |
49072 | 49376 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)); |
49073 | 49377 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
49074 | 49378 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -49077,7 +49381,7 @@ | ||
49077 | 49381 | state.addr = 293363126232490310LLU; // PROCVARREF |
49078 | 49382 | break; |
49079 | 49383 | } |
49080 | - case 18446744073709549502LLU: // 99999999c8''''''''''''''' | |
49384 | + case 18446744073709549489LLU: // 99999999cv''''''''''''''' | |
49081 | 49385 | { |
49082 | 49386 | // variable u64 initialize goes out of scope |
49083 | 49387 | // emitted destructur for type u64 |
@@ -49098,7 +49402,7 @@ | ||
49098 | 49402 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
49099 | 49403 | } |
49100 | 49404 | // ACCUMULATE ARGUMENTS - END |
49101 | - uint64_t return_to = 18446744073709549501LLU; | |
49405 | + uint64_t return_to = 18446744073709549488LLU; | |
49102 | 49406 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
49103 | 49407 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
49104 | 49408 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -49107,7 +49411,7 @@ | ||
49107 | 49411 | state.addr = 517555565476695680LLU; // assertu64_ |
49108 | 49412 | break; |
49109 | 49413 | } |
49110 | - case 18446744073709549501LLU: // 99999999c7''''''''''''''' | |
49414 | + case 18446744073709549488LLU: // 99999999cu''''''''''''''' | |
49111 | 49415 | { |
49112 | 49416 | // ACCUMULATE ARGUMENTS - BEGIN |
49113 | 49417 | { |
@@ -49115,7 +49419,7 @@ | ||
49115 | 49419 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
49116 | 49420 | } |
49117 | 49421 | // ACCUMULATE ARGUMENTS - END |
49118 | - uint64_t return_to = 18446744073709549500LLU; | |
49422 | + uint64_t return_to = 18446744073709549487LLU; | |
49119 | 49423 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
49120 | 49424 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
49121 | 49425 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -49124,7 +49428,7 @@ | ||
49124 | 49428 | state.addr = 839519665163075584LLU; // skip______ |
49125 | 49429 | break; |
49126 | 49430 | } |
49127 | - case 18446744073709549500LLU: // 99999999c6''''''''''''''' | |
49431 | + case 18446744073709549487LLU: // 99999999ct''''''''''''''' | |
49128 | 49432 | { |
49129 | 49433 | matchid(",", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU))); |
49130 | 49434 | fprintf(stdout, "%s", " && "); |
@@ -49134,7 +49438,7 @@ | ||
49134 | 49438 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
49135 | 49439 | } |
49136 | 49440 | // ACCUMULATE ARGUMENTS - END |
49137 | - uint64_t return_to = 18446744073709549499LLU; | |
49441 | + uint64_t return_to = 18446744073709549486LLU; | |
49138 | 49442 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
49139 | 49443 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
49140 | 49444 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -49143,7 +49447,7 @@ | ||
49143 | 49447 | state.addr = 839519665163075584LLU; // skip______ |
49144 | 49448 | break; |
49145 | 49449 | } |
49146 | - case 18446744073709549499LLU: // 99999999c5''''''''''''''' | |
49450 | + case 18446744073709549486LLU: // 99999999cs''''''''''''''' | |
49147 | 49451 | { |
49148 | 49452 | |
49149 | 49453 | *LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU))); |
@@ -49165,7 +49469,7 @@ | ||
49165 | 49469 | LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
49166 | 49470 | } |
49167 | 49471 | // ACCUMULATE ARGUMENTS - END |
49168 | - uint64_t return_to = 18446744073709549498LLU; | |
49472 | + uint64_t return_to = 18446744073709549485LLU; | |
49169 | 49473 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
49170 | 49474 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
49171 | 49475 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -49174,7 +49478,7 @@ | ||
49174 | 49478 | state.addr = 23446349213393492LLU; // ASSERTINIT |
49175 | 49479 | break; |
49176 | 49480 | } |
49177 | - case 18446744073709549498LLU: // 99999999c4''''''''''''''' | |
49481 | + case 18446744073709549485LLU: // 99999999cr''''''''''''''' | |
49178 | 49482 | { |
49179 | 49483 | { |
49180 | 49484 | uint64_t arg = 0; |
@@ -49253,7 +49557,7 @@ | ||
49253 | 49557 | LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
49254 | 49558 | } |
49255 | 49559 | // ACCUMULATE ARGUMENTS - END |
49256 | - uint64_t return_to = 18446744073709549497LLU; | |
49560 | + uint64_t return_to = 18446744073709549484LLU; | |
49257 | 49561 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)); |
49258 | 49562 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
49259 | 49563 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -49262,7 +49566,7 @@ | ||
49262 | 49566 | state.addr = 293363126232490310LLU; // PROCVARREF |
49263 | 49567 | break; |
49264 | 49568 | } |
49265 | - case 18446744073709549497LLU: // 99999999c3''''''''''''''' | |
49569 | + case 18446744073709549484LLU: // 99999999cq''''''''''''''' | |
49266 | 49570 | { |
49267 | 49571 | // variable u64 initialize goes out of scope |
49268 | 49572 | // emitted destructur for type u64 |
@@ -49283,7 +49587,7 @@ | ||
49283 | 49587 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
49284 | 49588 | } |
49285 | 49589 | // ACCUMULATE ARGUMENTS - END |
49286 | - uint64_t return_to = 18446744073709549496LLU; | |
49590 | + uint64_t return_to = 18446744073709549483LLU; | |
49287 | 49591 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
49288 | 49592 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
49289 | 49593 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -49292,7 +49596,7 @@ | ||
49292 | 49596 | state.addr = 517555565476695680LLU; // assertu64_ |
49293 | 49597 | break; |
49294 | 49598 | } |
49295 | - case 18446744073709549496LLU: // 99999999c2''''''''''''''' | |
49599 | + case 18446744073709549483LLU: // 99999999cp''''''''''''''' | |
49296 | 49600 | { |
49297 | 49601 | // ACCUMULATE ARGUMENTS - BEGIN |
49298 | 49602 | { |
@@ -49300,7 +49604,7 @@ | ||
49300 | 49604 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
49301 | 49605 | } |
49302 | 49606 | // ACCUMULATE ARGUMENTS - END |
49303 | - uint64_t return_to = 18446744073709549495LLU; | |
49607 | + uint64_t return_to = 18446744073709549482LLU; | |
49304 | 49608 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
49305 | 49609 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
49306 | 49610 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -49309,7 +49613,7 @@ | ||
49309 | 49613 | state.addr = 839519665163075584LLU; // skip______ |
49310 | 49614 | break; |
49311 | 49615 | } |
49312 | - case 18446744073709549495LLU: // 99999999c1''''''''''''''' | |
49616 | + case 18446744073709549482LLU: // 99999999co''''''''''''''' | |
49313 | 49617 | { |
49314 | 49618 | matchid(")", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU))); |
49315 | 49619 | fprintf(stdout, "%s", ";"); |
@@ -49321,7 +49625,7 @@ | ||
49321 | 49625 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
49322 | 49626 | } |
49323 | 49627 | // ACCUMULATE ARGUMENTS - END |
49324 | - uint64_t return_to = 18446744073709549494LLU; | |
49628 | + uint64_t return_to = 18446744073709549481LLU; | |
49325 | 49629 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
49326 | 49630 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
49327 | 49631 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -49330,7 +49634,7 @@ | ||
49330 | 49634 | state.addr = 18446744073709551534LLU; // 999999998s''''''''''''''' |
49331 | 49635 | break; |
49332 | 49636 | } |
49333 | - case 18446744073709549494LLU: // 99999999c0''''''''''''''' | |
49637 | + case 18446744073709549481LLU: // 99999999cn''''''''''''''' | |
49334 | 49638 | { |
49335 | 49639 | (void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference single____ at 21 |
49336 | 49640 | // variable type______ type______ goes out of scope |
@@ -49341,7 +49645,7 @@ | ||
49341 | 49645 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
49342 | 49646 | } |
49343 | 49647 | // ACCUMULATE ARGUMENTS - END |
49344 | - uint64_t return_to = 18446744073709549493LLU; | |
49648 | + uint64_t return_to = 18446744073709549480LLU; | |
49345 | 49649 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
49346 | 49650 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
49347 | 49651 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -49350,7 +49654,7 @@ | ||
49350 | 49654 | state.addr = 18446744073709551573LLU; // 999999999U''''''''''''''' |
49351 | 49655 | break; |
49352 | 49656 | } |
49353 | - case 18446744073709549493LLU: // 99999999cz''''''''''''''' | |
49657 | + case 18446744073709549480LLU: // 99999999cm''''''''''''''' | |
49354 | 49658 | { |
49355 | 49659 | (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type______ at 20 |
49356 | 49660 | // variable u64 mutable___ goes out of scope |
@@ -49362,10 +49666,10 @@ | ||
49362 | 49666 | // variable u64 id________ goes out of scope |
49363 | 49667 | // emitted destructur for type u64 |
49364 | 49668 | (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id________ at 17 |
49365 | - state.addr = 18446744073709549511LLU; // 99999999dG''''''''''''''' | |
49669 | + state.addr = 18446744073709549498LLU; // 99999999c4''''''''''''''' | |
49366 | 49670 | break; |
49367 | 49671 | } |
49368 | - case 18446744073709549512LLU: // 99999999dH''''''''''''''' | |
49672 | + case 18446744073709549499LLU: // 99999999c5''''''''''''''' | |
49369 | 49673 | { |
49370 | 49674 | |
49371 | 49675 | *LOCAL_ACCESS(heap.data, 16LLU, 15LLU) = 769271111350222848; |
@@ -49376,11 +49680,11 @@ | ||
49376 | 49680 | LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
49377 | 49681 | } |
49378 | 49682 | *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 0LLU)); |
49379 | - state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549492LLU : 18446744073709549491LLU; | |
49683 | + state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549479LLU : 18446744073709549478LLU; | |
49380 | 49684 | (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 17 |
49381 | 49685 | break; |
49382 | 49686 | } |
49383 | - case 18446744073709549492LLU: // 99999999cy''''''''''''''' | |
49687 | + case 18446744073709549479LLU: // 99999999cl''''''''''''''' | |
49384 | 49688 | { |
49385 | 49689 | { |
49386 | 49690 | uint64_t arg = 0; |
@@ -49407,7 +49711,7 @@ | ||
49407 | 49711 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
49408 | 49712 | } |
49409 | 49713 | // ACCUMULATE ARGUMENTS - END |
49410 | - uint64_t return_to = 18446744073709549489LLU; | |
49714 | + uint64_t return_to = 18446744073709549476LLU; | |
49411 | 49715 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
49412 | 49716 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
49413 | 49717 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -49416,7 +49720,7 @@ | ||
49416 | 49720 | state.addr = 861504796319285248LLU; // typeu64___ |
49417 | 49721 | break; |
49418 | 49722 | } |
49419 | - case 18446744073709549489LLU: // 99999999cv''''''''''''''' | |
49723 | + case 18446744073709549476LLU: // 99999999ci''''''''''''''' | |
49420 | 49724 | { |
49421 | 49725 | { |
49422 | 49726 | uint64_t arg = 0; |
@@ -49441,7 +49745,7 @@ | ||
49441 | 49745 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
49442 | 49746 | } |
49443 | 49747 | // ACCUMULATE ARGUMENTS - END |
49444 | - uint64_t return_to = 18446744073709549487LLU; | |
49748 | + uint64_t return_to = 18446744073709549474LLU; | |
49445 | 49749 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
49446 | 49750 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
49447 | 49751 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -49450,7 +49754,7 @@ | ||
49450 | 49754 | state.addr = 861504796319285248LLU; // typeu64___ |
49451 | 49755 | break; |
49452 | 49756 | } |
49453 | - case 18446744073709549487LLU: // 99999999ct''''''''''''''' | |
49757 | + case 18446744073709549474LLU: // 99999999cg''''''''''''''' | |
49454 | 49758 | { |
49455 | 49759 | { |
49456 | 49760 | uint64_t exchange = LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 23*/; |
@@ -49470,7 +49774,7 @@ | ||
49470 | 49774 | LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
49471 | 49775 | } |
49472 | 49776 | // ACCUMULATE ARGUMENTS - END |
49473 | - uint64_t return_to = 18446744073709549488LLU; | |
49777 | + uint64_t return_to = 18446744073709549475LLU; | |
49474 | 49778 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
49475 | 49779 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
49476 | 49780 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -49479,7 +49783,7 @@ | ||
49479 | 49783 | state.addr = 819859607768530944LLU; // resdest___ |
49480 | 49784 | break; |
49481 | 49785 | } |
49482 | - case 18446744073709549488LLU: // 99999999cu''''''''''''''' | |
49786 | + case 18446744073709549475LLU: // 99999999ch''''''''''''''' | |
49483 | 49787 | { |
49484 | 49788 | // ACCUMULATE ARGUMENTS - BEGIN |
49485 | 49789 | { |
@@ -49499,7 +49803,7 @@ | ||
49499 | 49803 | LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
49500 | 49804 | } |
49501 | 49805 | // ACCUMULATE ARGUMENTS - END |
49502 | - uint64_t return_to = 18446744073709549486LLU; | |
49806 | + uint64_t return_to = 18446744073709549473LLU; | |
49503 | 49807 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
49504 | 49808 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
49505 | 49809 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -49508,7 +49812,7 @@ | ||
49508 | 49812 | state.addr = 819857494882385920LLU; // res_u64___ |
49509 | 49813 | break; |
49510 | 49814 | } |
49511 | - case 18446744073709549486LLU: // 99999999cs''''''''''''''' | |
49815 | + case 18446744073709549473LLU: // 99999999cf''''''''''''''' | |
49512 | 49816 | { |
49513 | 49817 | // ACCUMULATE ARGUMENTS - BEGIN |
49514 | 49818 | { |
@@ -49516,7 +49820,7 @@ | ||
49516 | 49820 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
49517 | 49821 | } |
49518 | 49822 | // ACCUMULATE ARGUMENTS - END |
49519 | - uint64_t return_to = 18446744073709549485LLU; | |
49823 | + uint64_t return_to = 18446744073709549472LLU; | |
49520 | 49824 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
49521 | 49825 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
49522 | 49826 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -49525,7 +49829,7 @@ | ||
49525 | 49829 | state.addr = 839519665163075584LLU; // skip______ |
49526 | 49830 | break; |
49527 | 49831 | } |
49528 | - case 18446744073709549485LLU: // 99999999cr''''''''''''''' | |
49832 | + case 18446744073709549472LLU: // 99999999ce''''''''''''''' | |
49529 | 49833 | { |
49530 | 49834 | matchid("(", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU))); |
49531 | 49835 | fprintf(stdout, "%s", "\n "); |
@@ -49551,7 +49855,7 @@ | ||
49551 | 49855 | LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
49552 | 49856 | } |
49553 | 49857 | // ACCUMULATE ARGUMENTS - END |
49554 | - uint64_t return_to = 18446744073709549484LLU; | |
49858 | + uint64_t return_to = 18446744073709549471LLU; | |
49555 | 49859 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)); |
49556 | 49860 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
49557 | 49861 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -49560,7 +49864,7 @@ | ||
49560 | 49864 | state.addr = 587881357514113024LLU; // emitpar___ |
49561 | 49865 | break; |
49562 | 49866 | } |
49563 | - case 18446744073709549484LLU: // 99999999cq''''''''''''''' | |
49867 | + case 18446744073709549471LLU: // 99999999cd''''''''''''''' | |
49564 | 49868 | { |
49565 | 49869 | fprintf(stdout, "%s", " = "); |
49566 | 49870 | // ACCUMULATE ARGUMENTS - BEGIN |
@@ -49569,7 +49873,7 @@ | ||
49569 | 49873 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
49570 | 49874 | } |
49571 | 49875 | // ACCUMULATE ARGUMENTS - END |
49572 | - uint64_t return_to = 18446744073709549483LLU; | |
49876 | + uint64_t return_to = 18446744073709549470LLU; | |
49573 | 49877 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
49574 | 49878 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
49575 | 49879 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -49578,7 +49882,7 @@ | ||
49578 | 49882 | state.addr = 839519665163075584LLU; // skip______ |
49579 | 49883 | break; |
49580 | 49884 | } |
49581 | - case 18446744073709549483LLU: // 99999999cp''''''''''''''' | |
49885 | + case 18446744073709549470LLU: // 99999999cc''''''''''''''' | |
49582 | 49886 | { |
49583 | 49887 | |
49584 | 49888 | *LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU))); |
@@ -49600,7 +49904,7 @@ | ||
49600 | 49904 | LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
49601 | 49905 | } |
49602 | 49906 | // ACCUMULATE ARGUMENTS - END |
49603 | - uint64_t return_to = 18446744073709549482LLU; | |
49907 | + uint64_t return_to = 18446744073709549469LLU; | |
49604 | 49908 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
49605 | 49909 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
49606 | 49910 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -49609,7 +49913,7 @@ | ||
49609 | 49913 | state.addr = 23446349213393492LLU; // ASSERTINIT |
49610 | 49914 | break; |
49611 | 49915 | } |
49612 | - case 18446744073709549482LLU: // 99999999co''''''''''''''' | |
49916 | + case 18446744073709549469LLU: // 99999999cb''''''''''''''' | |
49613 | 49917 | { |
49614 | 49918 | { |
49615 | 49919 | uint64_t arg = 0; |
@@ -49688,7 +49992,7 @@ | ||
49688 | 49992 | LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
49689 | 49993 | } |
49690 | 49994 | // ACCUMULATE ARGUMENTS - END |
49691 | - uint64_t return_to = 18446744073709549481LLU; | |
49995 | + uint64_t return_to = 18446744073709549468LLU; | |
49692 | 49996 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)); |
49693 | 49997 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
49694 | 49998 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -49697,7 +50001,7 @@ | ||
49697 | 50001 | state.addr = 293363126232490310LLU; // PROCVARREF |
49698 | 50002 | break; |
49699 | 50003 | } |
49700 | - case 18446744073709549481LLU: // 99999999cn''''''''''''''' | |
50004 | + case 18446744073709549468LLU: // 99999999ca''''''''''''''' | |
49701 | 50005 | { |
49702 | 50006 | // variable u64 initialize goes out of scope |
49703 | 50007 | // emitted destructur for type u64 |
@@ -49718,7 +50022,7 @@ | ||
49718 | 50022 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
49719 | 50023 | } |
49720 | 50024 | // ACCUMULATE ARGUMENTS - END |
49721 | - uint64_t return_to = 18446744073709549480LLU; | |
50025 | + uint64_t return_to = 18446744073709549467LLU; | |
49722 | 50026 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
49723 | 50027 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
49724 | 50028 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -49727,7 +50031,7 @@ | ||
49727 | 50031 | state.addr = 517555565476695680LLU; // assertu64_ |
49728 | 50032 | break; |
49729 | 50033 | } |
49730 | - case 18446744073709549480LLU: // 99999999cm''''''''''''''' | |
50034 | + case 18446744073709549467LLU: // 99999999c$''''''''''''''' | |
49731 | 50035 | { |
49732 | 50036 | // ACCUMULATE ARGUMENTS - BEGIN |
49733 | 50037 | { |
@@ -49735,7 +50039,7 @@ | ||
49735 | 50039 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
49736 | 50040 | } |
49737 | 50041 | // ACCUMULATE ARGUMENTS - END |
49738 | - uint64_t return_to = 18446744073709549479LLU; | |
50042 | + uint64_t return_to = 18446744073709549466LLU; | |
49739 | 50043 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
49740 | 50044 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
49741 | 50045 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -49744,7 +50048,7 @@ | ||
49744 | 50048 | state.addr = 839519665163075584LLU; // skip______ |
49745 | 50049 | break; |
49746 | 50050 | } |
49747 | - case 18446744073709549479LLU: // 99999999cl''''''''''''''' | |
50051 | + case 18446744073709549466LLU: // 99999999cZ''''''''''''''' | |
49748 | 50052 | { |
49749 | 50053 | matchid(",", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU))); |
49750 | 50054 | fprintf(stdout, "%s", " || "); |
@@ -49754,7 +50058,7 @@ | ||
49754 | 50058 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
49755 | 50059 | } |
49756 | 50060 | // ACCUMULATE ARGUMENTS - END |
49757 | - uint64_t return_to = 18446744073709549478LLU; | |
50061 | + uint64_t return_to = 18446744073709549465LLU; | |
49758 | 50062 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
49759 | 50063 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
49760 | 50064 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -49763,7 +50067,7 @@ | ||
49763 | 50067 | state.addr = 839519665163075584LLU; // skip______ |
49764 | 50068 | break; |
49765 | 50069 | } |
49766 | - case 18446744073709549478LLU: // 99999999ck''''''''''''''' | |
50070 | + case 18446744073709549465LLU: // 99999999cY''''''''''''''' | |
49767 | 50071 | { |
49768 | 50072 | |
49769 | 50073 | *LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU))); |
@@ -49785,7 +50089,7 @@ | ||
49785 | 50089 | LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
49786 | 50090 | } |
49787 | 50091 | // ACCUMULATE ARGUMENTS - END |
49788 | - uint64_t return_to = 18446744073709549477LLU; | |
50092 | + uint64_t return_to = 18446744073709549464LLU; | |
49789 | 50093 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
49790 | 50094 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
49791 | 50095 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -49794,7 +50098,7 @@ | ||
49794 | 50098 | state.addr = 23446349213393492LLU; // ASSERTINIT |
49795 | 50099 | break; |
49796 | 50100 | } |
49797 | - case 18446744073709549477LLU: // 99999999cj''''''''''''''' | |
50101 | + case 18446744073709549464LLU: // 99999999cX''''''''''''''' | |
49798 | 50102 | { |
49799 | 50103 | { |
49800 | 50104 | uint64_t arg = 0; |
@@ -49873,7 +50177,7 @@ | ||
49873 | 50177 | LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
49874 | 50178 | } |
49875 | 50179 | // ACCUMULATE ARGUMENTS - END |
49876 | - uint64_t return_to = 18446744073709549476LLU; | |
50180 | + uint64_t return_to = 18446744073709549463LLU; | |
49877 | 50181 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)); |
49878 | 50182 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
49879 | 50183 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -49882,7 +50186,7 @@ | ||
49882 | 50186 | state.addr = 293363126232490310LLU; // PROCVARREF |
49883 | 50187 | break; |
49884 | 50188 | } |
49885 | - case 18446744073709549476LLU: // 99999999ci''''''''''''''' | |
50189 | + case 18446744073709549463LLU: // 99999999cW''''''''''''''' | |
49886 | 50190 | { |
49887 | 50191 | // variable u64 initialize goes out of scope |
49888 | 50192 | // emitted destructur for type u64 |
@@ -49903,7 +50207,7 @@ | ||
49903 | 50207 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
49904 | 50208 | } |
49905 | 50209 | // ACCUMULATE ARGUMENTS - END |
49906 | - uint64_t return_to = 18446744073709549475LLU; | |
50210 | + uint64_t return_to = 18446744073709549462LLU; | |
49907 | 50211 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
49908 | 50212 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
49909 | 50213 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -49912,7 +50216,7 @@ | ||
49912 | 50216 | state.addr = 517555565476695680LLU; // assertu64_ |
49913 | 50217 | break; |
49914 | 50218 | } |
49915 | - case 18446744073709549475LLU: // 99999999ch''''''''''''''' | |
50219 | + case 18446744073709549462LLU: // 99999999cV''''''''''''''' | |
49916 | 50220 | { |
49917 | 50221 | // ACCUMULATE ARGUMENTS - BEGIN |
49918 | 50222 | { |
@@ -49920,7 +50224,7 @@ | ||
49920 | 50224 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
49921 | 50225 | } |
49922 | 50226 | // ACCUMULATE ARGUMENTS - END |
49923 | - uint64_t return_to = 18446744073709549474LLU; | |
50227 | + uint64_t return_to = 18446744073709549461LLU; | |
49924 | 50228 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
49925 | 50229 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
49926 | 50230 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -49929,7 +50233,7 @@ | ||
49929 | 50233 | state.addr = 839519665163075584LLU; // skip______ |
49930 | 50234 | break; |
49931 | 50235 | } |
49932 | - case 18446744073709549474LLU: // 99999999cg''''''''''''''' | |
50236 | + case 18446744073709549461LLU: // 99999999cU''''''''''''''' | |
49933 | 50237 | { |
49934 | 50238 | matchid(")", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU))); |
49935 | 50239 | fprintf(stdout, "%s", ";"); |
@@ -49941,7 +50245,7 @@ | ||
49941 | 50245 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
49942 | 50246 | } |
49943 | 50247 | // ACCUMULATE ARGUMENTS - END |
49944 | - uint64_t return_to = 18446744073709549473LLU; | |
50248 | + uint64_t return_to = 18446744073709549460LLU; | |
49945 | 50249 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
49946 | 50250 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
49947 | 50251 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -49950,7 +50254,7 @@ | ||
49950 | 50254 | state.addr = 18446744073709551534LLU; // 999999998s''''''''''''''' |
49951 | 50255 | break; |
49952 | 50256 | } |
49953 | - case 18446744073709549473LLU: // 99999999cf''''''''''''''' | |
50257 | + case 18446744073709549460LLU: // 99999999cT''''''''''''''' | |
49954 | 50258 | { |
49955 | 50259 | (void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference single____ at 21 |
49956 | 50260 | // variable type______ type______ goes out of scope |
@@ -49961,7 +50265,7 @@ | ||
49961 | 50265 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
49962 | 50266 | } |
49963 | 50267 | // ACCUMULATE ARGUMENTS - END |
49964 | - uint64_t return_to = 18446744073709549472LLU; | |
50268 | + uint64_t return_to = 18446744073709549459LLU; | |
49965 | 50269 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
49966 | 50270 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
49967 | 50271 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -49970,7 +50274,7 @@ | ||
49970 | 50274 | state.addr = 18446744073709551573LLU; // 999999999U''''''''''''''' |
49971 | 50275 | break; |
49972 | 50276 | } |
49973 | - case 18446744073709549472LLU: // 99999999ce''''''''''''''' | |
50277 | + case 18446744073709549459LLU: // 99999999cS''''''''''''''' | |
49974 | 50278 | { |
49975 | 50279 | (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type______ at 20 |
49976 | 50280 | // variable u64 mutable___ goes out of scope |
@@ -49982,10 +50286,10 @@ | ||
49982 | 50286 | // variable u64 id________ goes out of scope |
49983 | 50287 | // emitted destructur for type u64 |
49984 | 50288 | (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id________ at 17 |
49985 | - state.addr = 18446744073709549490LLU; // 99999999cw''''''''''''''' | |
50289 | + state.addr = 18446744073709549477LLU; // 99999999cj''''''''''''''' | |
49986 | 50290 | break; |
49987 | 50291 | } |
49988 | - case 18446744073709549491LLU: // 99999999cx''''''''''''''' | |
50292 | + case 18446744073709549478LLU: // 99999999ck''''''''''''''' | |
49989 | 50293 | { |
49990 | 50294 | |
49991 | 50295 | *LOCAL_ACCESS(heap.data, 16LLU, 15LLU) = 838674604158353408; |
@@ -49996,11 +50300,11 @@ | ||
49996 | 50300 | LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
49997 | 50301 | } |
49998 | 50302 | *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 0LLU)); |
49999 | - state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549471LLU : 18446744073709549470LLU; | |
50303 | + state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549458LLU : 18446744073709549457LLU; | |
50000 | 50304 | (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 17 |
50001 | 50305 | break; |
50002 | 50306 | } |
50003 | - case 18446744073709549471LLU: // 99999999cd''''''''''''''' | |
50307 | + case 18446744073709549458LLU: // 99999999cR''''''''''''''' | |
50004 | 50308 | { |
50005 | 50309 | { |
50006 | 50310 | uint64_t arg = 0; |
@@ -50027,7 +50331,7 @@ | ||
50027 | 50331 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
50028 | 50332 | } |
50029 | 50333 | // ACCUMULATE ARGUMENTS - END |
50030 | - uint64_t return_to = 18446744073709549468LLU; | |
50334 | + uint64_t return_to = 18446744073709549455LLU; | |
50031 | 50335 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
50032 | 50336 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
50033 | 50337 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -50036,7 +50340,7 @@ | ||
50036 | 50340 | state.addr = 861504796319285248LLU; // typeu64___ |
50037 | 50341 | break; |
50038 | 50342 | } |
50039 | - case 18446744073709549468LLU: // 99999999ca''''''''''''''' | |
50343 | + case 18446744073709549455LLU: // 99999999cO''''''''''''''' | |
50040 | 50344 | { |
50041 | 50345 | { |
50042 | 50346 | uint64_t arg = 0; |
@@ -50061,7 +50365,7 @@ | ||
50061 | 50365 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
50062 | 50366 | } |
50063 | 50367 | // ACCUMULATE ARGUMENTS - END |
50064 | - uint64_t return_to = 18446744073709549466LLU; | |
50368 | + uint64_t return_to = 18446744073709549453LLU; | |
50065 | 50369 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
50066 | 50370 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
50067 | 50371 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -50070,7 +50374,7 @@ | ||
50070 | 50374 | state.addr = 861504796319285248LLU; // typeu64___ |
50071 | 50375 | break; |
50072 | 50376 | } |
50073 | - case 18446744073709549466LLU: // 99999999cZ''''''''''''''' | |
50377 | + case 18446744073709549453LLU: // 99999999cM''''''''''''''' | |
50074 | 50378 | { |
50075 | 50379 | { |
50076 | 50380 | uint64_t exchange = LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 23*/; |
@@ -50090,7 +50394,7 @@ | ||
50090 | 50394 | LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
50091 | 50395 | } |
50092 | 50396 | // ACCUMULATE ARGUMENTS - END |
50093 | - uint64_t return_to = 18446744073709549467LLU; | |
50397 | + uint64_t return_to = 18446744073709549454LLU; | |
50094 | 50398 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
50095 | 50399 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
50096 | 50400 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -50099,7 +50403,7 @@ | ||
50099 | 50403 | state.addr = 819859607768530944LLU; // resdest___ |
50100 | 50404 | break; |
50101 | 50405 | } |
50102 | - case 18446744073709549467LLU: // 99999999c$''''''''''''''' | |
50406 | + case 18446744073709549454LLU: // 99999999cN''''''''''''''' | |
50103 | 50407 | { |
50104 | 50408 | // ACCUMULATE ARGUMENTS - BEGIN |
50105 | 50409 | { |
@@ -50119,7 +50423,7 @@ | ||
50119 | 50423 | LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
50120 | 50424 | } |
50121 | 50425 | // ACCUMULATE ARGUMENTS - END |
50122 | - uint64_t return_to = 18446744073709549465LLU; | |
50426 | + uint64_t return_to = 18446744073709549452LLU; | |
50123 | 50427 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
50124 | 50428 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
50125 | 50429 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -50128,7 +50432,7 @@ | ||
50128 | 50432 | state.addr = 819857494882385920LLU; // res_u64___ |
50129 | 50433 | break; |
50130 | 50434 | } |
50131 | - case 18446744073709549465LLU: // 99999999cY''''''''''''''' | |
50435 | + case 18446744073709549452LLU: // 99999999cL''''''''''''''' | |
50132 | 50436 | { |
50133 | 50437 | // ACCUMULATE ARGUMENTS - BEGIN |
50134 | 50438 | { |
@@ -50136,7 +50440,7 @@ | ||
50136 | 50440 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
50137 | 50441 | } |
50138 | 50442 | // ACCUMULATE ARGUMENTS - END |
50139 | - uint64_t return_to = 18446744073709549464LLU; | |
50443 | + uint64_t return_to = 18446744073709549451LLU; | |
50140 | 50444 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
50141 | 50445 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
50142 | 50446 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -50145,7 +50449,7 @@ | ||
50145 | 50449 | state.addr = 839519665163075584LLU; // skip______ |
50146 | 50450 | break; |
50147 | 50451 | } |
50148 | - case 18446744073709549464LLU: // 99999999cX''''''''''''''' | |
50452 | + case 18446744073709549451LLU: // 99999999cK''''''''''''''' | |
50149 | 50453 | { |
50150 | 50454 | matchid("(", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU))); |
50151 | 50455 | fprintf(stdout, "%s", "\n "); |
@@ -50171,7 +50475,7 @@ | ||
50171 | 50475 | LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
50172 | 50476 | } |
50173 | 50477 | // ACCUMULATE ARGUMENTS - END |
50174 | - uint64_t return_to = 18446744073709549463LLU; | |
50478 | + uint64_t return_to = 18446744073709549450LLU; | |
50175 | 50479 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)); |
50176 | 50480 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
50177 | 50481 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -50180,7 +50484,7 @@ | ||
50180 | 50484 | state.addr = 587881357514113024LLU; // emitpar___ |
50181 | 50485 | break; |
50182 | 50486 | } |
50183 | - case 18446744073709549463LLU: // 99999999cW''''''''''''''' | |
50487 | + case 18446744073709549450LLU: // 99999999cJ''''''''''''''' | |
50184 | 50488 | { |
50185 | 50489 | fprintf(stdout, "%s", " = "); |
50186 | 50490 | // ACCUMULATE ARGUMENTS - BEGIN |
@@ -50189,7 +50493,7 @@ | ||
50189 | 50493 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
50190 | 50494 | } |
50191 | 50495 | // ACCUMULATE ARGUMENTS - END |
50192 | - uint64_t return_to = 18446744073709549462LLU; | |
50496 | + uint64_t return_to = 18446744073709549449LLU; | |
50193 | 50497 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
50194 | 50498 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
50195 | 50499 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -50198,7 +50502,7 @@ | ||
50198 | 50502 | state.addr = 839519665163075584LLU; // skip______ |
50199 | 50503 | break; |
50200 | 50504 | } |
50201 | - case 18446744073709549462LLU: // 99999999cV''''''''''''''' | |
50505 | + case 18446744073709549449LLU: // 99999999cI''''''''''''''' | |
50202 | 50506 | { |
50203 | 50507 | |
50204 | 50508 | *LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU))); |
@@ -50220,7 +50524,7 @@ | ||
50220 | 50524 | LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
50221 | 50525 | } |
50222 | 50526 | // ACCUMULATE ARGUMENTS - END |
50223 | - uint64_t return_to = 18446744073709549461LLU; | |
50527 | + uint64_t return_to = 18446744073709549448LLU; | |
50224 | 50528 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
50225 | 50529 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
50226 | 50530 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -50229,7 +50533,7 @@ | ||
50229 | 50533 | state.addr = 23446349213393492LLU; // ASSERTINIT |
50230 | 50534 | break; |
50231 | 50535 | } |
50232 | - case 18446744073709549461LLU: // 99999999cU''''''''''''''' | |
50536 | + case 18446744073709549448LLU: // 99999999cH''''''''''''''' | |
50233 | 50537 | { |
50234 | 50538 | { |
50235 | 50539 | uint64_t arg = 0; |
@@ -50308,7 +50612,7 @@ | ||
50308 | 50612 | LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
50309 | 50613 | } |
50310 | 50614 | // ACCUMULATE ARGUMENTS - END |
50311 | - uint64_t return_to = 18446744073709549460LLU; | |
50615 | + uint64_t return_to = 18446744073709549447LLU; | |
50312 | 50616 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)); |
50313 | 50617 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
50314 | 50618 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -50317,7 +50621,7 @@ | ||
50317 | 50621 | state.addr = 293363126232490310LLU; // PROCVARREF |
50318 | 50622 | break; |
50319 | 50623 | } |
50320 | - case 18446744073709549460LLU: // 99999999cT''''''''''''''' | |
50624 | + case 18446744073709549447LLU: // 99999999cG''''''''''''''' | |
50321 | 50625 | { |
50322 | 50626 | // variable u64 initialize goes out of scope |
50323 | 50627 | // emitted destructur for type u64 |
@@ -50338,7 +50642,7 @@ | ||
50338 | 50642 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
50339 | 50643 | } |
50340 | 50644 | // ACCUMULATE ARGUMENTS - END |
50341 | - uint64_t return_to = 18446744073709549459LLU; | |
50645 | + uint64_t return_to = 18446744073709549446LLU; | |
50342 | 50646 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
50343 | 50647 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
50344 | 50648 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -50347,7 +50651,7 @@ | ||
50347 | 50651 | state.addr = 517555565476695680LLU; // assertu64_ |
50348 | 50652 | break; |
50349 | 50653 | } |
50350 | - case 18446744073709549459LLU: // 99999999cS''''''''''''''' | |
50654 | + case 18446744073709549446LLU: // 99999999cF''''''''''''''' | |
50351 | 50655 | { |
50352 | 50656 | // ACCUMULATE ARGUMENTS - BEGIN |
50353 | 50657 | { |
@@ -50355,7 +50659,7 @@ | ||
50355 | 50659 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
50356 | 50660 | } |
50357 | 50661 | // ACCUMULATE ARGUMENTS - END |
50358 | - uint64_t return_to = 18446744073709549458LLU; | |
50662 | + uint64_t return_to = 18446744073709549445LLU; | |
50359 | 50663 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
50360 | 50664 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
50361 | 50665 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -50364,7 +50668,7 @@ | ||
50364 | 50668 | state.addr = 839519665163075584LLU; // skip______ |
50365 | 50669 | break; |
50366 | 50670 | } |
50367 | - case 18446744073709549458LLU: // 99999999cR''''''''''''''' | |
50671 | + case 18446744073709549445LLU: // 99999999cE''''''''''''''' | |
50368 | 50672 | { |
50369 | 50673 | matchid(",", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU))); |
50370 | 50674 | fprintf(stdout, "%s", " << "); |
@@ -50374,7 +50678,7 @@ | ||
50374 | 50678 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
50375 | 50679 | } |
50376 | 50680 | // ACCUMULATE ARGUMENTS - END |
50377 | - uint64_t return_to = 18446744073709549457LLU; | |
50681 | + uint64_t return_to = 18446744073709549444LLU; | |
50378 | 50682 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
50379 | 50683 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
50380 | 50684 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -50383,7 +50687,7 @@ | ||
50383 | 50687 | state.addr = 839519665163075584LLU; // skip______ |
50384 | 50688 | break; |
50385 | 50689 | } |
50386 | - case 18446744073709549457LLU: // 99999999cQ''''''''''''''' | |
50690 | + case 18446744073709549444LLU: // 99999999cD''''''''''''''' | |
50387 | 50691 | { |
50388 | 50692 | |
50389 | 50693 | *LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU))); |
@@ -50405,7 +50709,7 @@ | ||
50405 | 50709 | LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
50406 | 50710 | } |
50407 | 50711 | // ACCUMULATE ARGUMENTS - END |
50408 | - uint64_t return_to = 18446744073709549456LLU; | |
50712 | + uint64_t return_to = 18446744073709549443LLU; | |
50409 | 50713 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
50410 | 50714 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
50411 | 50715 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -50414,7 +50718,7 @@ | ||
50414 | 50718 | state.addr = 23446349213393492LLU; // ASSERTINIT |
50415 | 50719 | break; |
50416 | 50720 | } |
50417 | - case 18446744073709549456LLU: // 99999999cP''''''''''''''' | |
50721 | + case 18446744073709549443LLU: // 99999999cC''''''''''''''' | |
50418 | 50722 | { |
50419 | 50723 | { |
50420 | 50724 | uint64_t arg = 0; |
@@ -50493,7 +50797,7 @@ | ||
50493 | 50797 | LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
50494 | 50798 | } |
50495 | 50799 | // ACCUMULATE ARGUMENTS - END |
50496 | - uint64_t return_to = 18446744073709549455LLU; | |
50800 | + uint64_t return_to = 18446744073709549442LLU; | |
50497 | 50801 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)); |
50498 | 50802 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
50499 | 50803 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -50502,7 +50806,7 @@ | ||
50502 | 50806 | state.addr = 293363126232490310LLU; // PROCVARREF |
50503 | 50807 | break; |
50504 | 50808 | } |
50505 | - case 18446744073709549455LLU: // 99999999cO''''''''''''''' | |
50809 | + case 18446744073709549442LLU: // 99999999cB''''''''''''''' | |
50506 | 50810 | { |
50507 | 50811 | // variable u64 initialize goes out of scope |
50508 | 50812 | // emitted destructur for type u64 |
@@ -50523,7 +50827,7 @@ | ||
50523 | 50827 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
50524 | 50828 | } |
50525 | 50829 | // ACCUMULATE ARGUMENTS - END |
50526 | - uint64_t return_to = 18446744073709549454LLU; | |
50830 | + uint64_t return_to = 18446744073709549441LLU; | |
50527 | 50831 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
50528 | 50832 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
50529 | 50833 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -50532,7 +50836,7 @@ | ||
50532 | 50836 | state.addr = 517555565476695680LLU; // assertu64_ |
50533 | 50837 | break; |
50534 | 50838 | } |
50535 | - case 18446744073709549454LLU: // 99999999cN''''''''''''''' | |
50839 | + case 18446744073709549441LLU: // 99999999cA''''''''''''''' | |
50536 | 50840 | { |
50537 | 50841 | // ACCUMULATE ARGUMENTS - BEGIN |
50538 | 50842 | { |
@@ -50540,7 +50844,7 @@ | ||
50540 | 50844 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
50541 | 50845 | } |
50542 | 50846 | // ACCUMULATE ARGUMENTS - END |
50543 | - uint64_t return_to = 18446744073709549453LLU; | |
50847 | + uint64_t return_to = 18446744073709549440LLU; | |
50544 | 50848 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
50545 | 50849 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
50546 | 50850 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -50549,7 +50853,7 @@ | ||
50549 | 50853 | state.addr = 839519665163075584LLU; // skip______ |
50550 | 50854 | break; |
50551 | 50855 | } |
50552 | - case 18446744073709549453LLU: // 99999999cM''''''''''''''' | |
50856 | + case 18446744073709549440LLU: // 99999999c_''''''''''''''' | |
50553 | 50857 | { |
50554 | 50858 | matchid(")", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU))); |
50555 | 50859 | fprintf(stdout, "%s", ";"); |
@@ -50561,7 +50865,7 @@ | ||
50561 | 50865 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
50562 | 50866 | } |
50563 | 50867 | // ACCUMULATE ARGUMENTS - END |
50564 | - uint64_t return_to = 18446744073709549452LLU; | |
50868 | + uint64_t return_to = 18446744073709549439LLU; | |
50565 | 50869 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
50566 | 50870 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
50567 | 50871 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -50570,7 +50874,7 @@ | ||
50570 | 50874 | state.addr = 18446744073709551534LLU; // 999999998s''''''''''''''' |
50571 | 50875 | break; |
50572 | 50876 | } |
50573 | - case 18446744073709549452LLU: // 99999999cL''''''''''''''' | |
50877 | + case 18446744073709549439LLU: // 99999999b9''''''''''''''' | |
50574 | 50878 | { |
50575 | 50879 | (void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference single____ at 21 |
50576 | 50880 | // variable type______ type______ goes out of scope |
@@ -50581,7 +50885,7 @@ | ||
50581 | 50885 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
50582 | 50886 | } |
50583 | 50887 | // ACCUMULATE ARGUMENTS - END |
50584 | - uint64_t return_to = 18446744073709549451LLU; | |
50888 | + uint64_t return_to = 18446744073709549438LLU; | |
50585 | 50889 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
50586 | 50890 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
50587 | 50891 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -50590,7 +50894,7 @@ | ||
50590 | 50894 | state.addr = 18446744073709551573LLU; // 999999999U''''''''''''''' |
50591 | 50895 | break; |
50592 | 50896 | } |
50593 | - case 18446744073709549451LLU: // 99999999cK''''''''''''''' | |
50897 | + case 18446744073709549438LLU: // 99999999b8''''''''''''''' | |
50594 | 50898 | { |
50595 | 50899 | (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type______ at 20 |
50596 | 50900 | // variable u64 mutable___ goes out of scope |
@@ -50602,10 +50906,10 @@ | ||
50602 | 50906 | // variable u64 id________ goes out of scope |
50603 | 50907 | // emitted destructur for type u64 |
50604 | 50908 | (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id________ at 17 |
50605 | - state.addr = 18446744073709549469LLU; // 99999999cb''''''''''''''' | |
50909 | + state.addr = 18446744073709549456LLU; // 99999999cP''''''''''''''' | |
50606 | 50910 | break; |
50607 | 50911 | } |
50608 | - case 18446744073709549470LLU: // 99999999cc''''''''''''''' | |
50912 | + case 18446744073709549457LLU: // 99999999cQ''''''''''''''' | |
50609 | 50913 | { |
50610 | 50914 | |
50611 | 50915 | *LOCAL_ACCESS(heap.data, 16LLU, 15LLU) = 838674604259016704; |
@@ -50616,11 +50920,11 @@ | ||
50616 | 50920 | LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
50617 | 50921 | } |
50618 | 50922 | *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 0LLU)); |
50619 | - state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549450LLU : 18446744073709549449LLU; | |
50923 | + state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549437LLU : 18446744073709549436LLU; | |
50620 | 50924 | (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 17 |
50621 | 50925 | break; |
50622 | 50926 | } |
50623 | - case 18446744073709549450LLU: // 99999999cJ''''''''''''''' | |
50927 | + case 18446744073709549437LLU: // 99999999b7''''''''''''''' | |
50624 | 50928 | { |
50625 | 50929 | { |
50626 | 50930 | uint64_t arg = 0; |
@@ -50647,7 +50951,7 @@ | ||
50647 | 50951 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
50648 | 50952 | } |
50649 | 50953 | // ACCUMULATE ARGUMENTS - END |
50650 | - uint64_t return_to = 18446744073709549447LLU; | |
50954 | + uint64_t return_to = 18446744073709549434LLU; | |
50651 | 50955 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
50652 | 50956 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
50653 | 50957 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -50656,7 +50960,7 @@ | ||
50656 | 50960 | state.addr = 861504796319285248LLU; // typeu64___ |
50657 | 50961 | break; |
50658 | 50962 | } |
50659 | - case 18446744073709549447LLU: // 99999999cG''''''''''''''' | |
50963 | + case 18446744073709549434LLU: // 99999999b4''''''''''''''' | |
50660 | 50964 | { |
50661 | 50965 | { |
50662 | 50966 | uint64_t arg = 0; |
@@ -50681,7 +50985,7 @@ | ||
50681 | 50985 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
50682 | 50986 | } |
50683 | 50987 | // ACCUMULATE ARGUMENTS - END |
50684 | - uint64_t return_to = 18446744073709549445LLU; | |
50988 | + uint64_t return_to = 18446744073709549432LLU; | |
50685 | 50989 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
50686 | 50990 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
50687 | 50991 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -50690,7 +50994,7 @@ | ||
50690 | 50994 | state.addr = 861504796319285248LLU; // typeu64___ |
50691 | 50995 | break; |
50692 | 50996 | } |
50693 | - case 18446744073709549445LLU: // 99999999cE''''''''''''''' | |
50997 | + case 18446744073709549432LLU: // 99999999b2''''''''''''''' | |
50694 | 50998 | { |
50695 | 50999 | { |
50696 | 51000 | uint64_t exchange = LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 23*/; |
@@ -50710,7 +51014,7 @@ | ||
50710 | 51014 | LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
50711 | 51015 | } |
50712 | 51016 | // ACCUMULATE ARGUMENTS - END |
50713 | - uint64_t return_to = 18446744073709549446LLU; | |
51017 | + uint64_t return_to = 18446744073709549433LLU; | |
50714 | 51018 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
50715 | 51019 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
50716 | 51020 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -50719,7 +51023,7 @@ | ||
50719 | 51023 | state.addr = 819859607768530944LLU; // resdest___ |
50720 | 51024 | break; |
50721 | 51025 | } |
50722 | - case 18446744073709549446LLU: // 99999999cF''''''''''''''' | |
51026 | + case 18446744073709549433LLU: // 99999999b3''''''''''''''' | |
50723 | 51027 | { |
50724 | 51028 | // ACCUMULATE ARGUMENTS - BEGIN |
50725 | 51029 | { |
@@ -50739,7 +51043,7 @@ | ||
50739 | 51043 | LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
50740 | 51044 | } |
50741 | 51045 | // ACCUMULATE ARGUMENTS - END |
50742 | - uint64_t return_to = 18446744073709549444LLU; | |
51046 | + uint64_t return_to = 18446744073709549431LLU; | |
50743 | 51047 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
50744 | 51048 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
50745 | 51049 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -50748,7 +51052,7 @@ | ||
50748 | 51052 | state.addr = 819857494882385920LLU; // res_u64___ |
50749 | 51053 | break; |
50750 | 51054 | } |
50751 | - case 18446744073709549444LLU: // 99999999cD''''''''''''''' | |
51055 | + case 18446744073709549431LLU: // 99999999b1''''''''''''''' | |
50752 | 51056 | { |
50753 | 51057 | // ACCUMULATE ARGUMENTS - BEGIN |
50754 | 51058 | { |
@@ -50756,7 +51060,7 @@ | ||
50756 | 51060 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
50757 | 51061 | } |
50758 | 51062 | // ACCUMULATE ARGUMENTS - END |
50759 | - uint64_t return_to = 18446744073709549443LLU; | |
51063 | + uint64_t return_to = 18446744073709549430LLU; | |
50760 | 51064 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
50761 | 51065 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
50762 | 51066 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -50765,7 +51069,7 @@ | ||
50765 | 51069 | state.addr = 839519665163075584LLU; // skip______ |
50766 | 51070 | break; |
50767 | 51071 | } |
50768 | - case 18446744073709549443LLU: // 99999999cC''''''''''''''' | |
51072 | + case 18446744073709549430LLU: // 99999999b0''''''''''''''' | |
50769 | 51073 | { |
50770 | 51074 | matchid("(", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU))); |
50771 | 51075 | fprintf(stdout, "%s", "\n "); |
@@ -50791,7 +51095,7 @@ | ||
50791 | 51095 | LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
50792 | 51096 | } |
50793 | 51097 | // ACCUMULATE ARGUMENTS - END |
50794 | - uint64_t return_to = 18446744073709549442LLU; | |
51098 | + uint64_t return_to = 18446744073709549429LLU; | |
50795 | 51099 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)); |
50796 | 51100 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
50797 | 51101 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -50800,7 +51104,7 @@ | ||
50800 | 51104 | state.addr = 587881357514113024LLU; // emitpar___ |
50801 | 51105 | break; |
50802 | 51106 | } |
50803 | - case 18446744073709549442LLU: // 99999999cB''''''''''''''' | |
51107 | + case 18446744073709549429LLU: // 99999999bz''''''''''''''' | |
50804 | 51108 | { |
50805 | 51109 | fprintf(stdout, "%s", " = "); |
50806 | 51110 | // ACCUMULATE ARGUMENTS - BEGIN |
@@ -50809,7 +51113,7 @@ | ||
50809 | 51113 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
50810 | 51114 | } |
50811 | 51115 | // ACCUMULATE ARGUMENTS - END |
50812 | - uint64_t return_to = 18446744073709549441LLU; | |
51116 | + uint64_t return_to = 18446744073709549428LLU; | |
50813 | 51117 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
50814 | 51118 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
50815 | 51119 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -50818,7 +51122,7 @@ | ||
50818 | 51122 | state.addr = 839519665163075584LLU; // skip______ |
50819 | 51123 | break; |
50820 | 51124 | } |
50821 | - case 18446744073709549441LLU: // 99999999cA''''''''''''''' | |
51125 | + case 18446744073709549428LLU: // 99999999by''''''''''''''' | |
50822 | 51126 | { |
50823 | 51127 | |
50824 | 51128 | *LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU))); |
@@ -50840,7 +51144,7 @@ | ||
50840 | 51144 | LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
50841 | 51145 | } |
50842 | 51146 | // ACCUMULATE ARGUMENTS - END |
50843 | - uint64_t return_to = 18446744073709549440LLU; | |
51147 | + uint64_t return_to = 18446744073709549427LLU; | |
50844 | 51148 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
50845 | 51149 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
50846 | 51150 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -50849,7 +51153,7 @@ | ||
50849 | 51153 | state.addr = 23446349213393492LLU; // ASSERTINIT |
50850 | 51154 | break; |
50851 | 51155 | } |
50852 | - case 18446744073709549440LLU: // 99999999c_''''''''''''''' | |
51156 | + case 18446744073709549427LLU: // 99999999bx''''''''''''''' | |
50853 | 51157 | { |
50854 | 51158 | { |
50855 | 51159 | uint64_t arg = 0; |
@@ -50928,7 +51232,7 @@ | ||
50928 | 51232 | LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
50929 | 51233 | } |
50930 | 51234 | // ACCUMULATE ARGUMENTS - END |
50931 | - uint64_t return_to = 18446744073709549439LLU; | |
51235 | + uint64_t return_to = 18446744073709549426LLU; | |
50932 | 51236 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)); |
50933 | 51237 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
50934 | 51238 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -50937,7 +51241,7 @@ | ||
50937 | 51241 | state.addr = 293363126232490310LLU; // PROCVARREF |
50938 | 51242 | break; |
50939 | 51243 | } |
50940 | - case 18446744073709549439LLU: // 99999999b9''''''''''''''' | |
51244 | + case 18446744073709549426LLU: // 99999999bw''''''''''''''' | |
50941 | 51245 | { |
50942 | 51246 | // variable u64 initialize goes out of scope |
50943 | 51247 | // emitted destructur for type u64 |
@@ -50958,7 +51262,7 @@ | ||
50958 | 51262 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
50959 | 51263 | } |
50960 | 51264 | // ACCUMULATE ARGUMENTS - END |
50961 | - uint64_t return_to = 18446744073709549438LLU; | |
51265 | + uint64_t return_to = 18446744073709549425LLU; | |
50962 | 51266 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
50963 | 51267 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
50964 | 51268 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -50967,7 +51271,7 @@ | ||
50967 | 51271 | state.addr = 517555565476695680LLU; // assertu64_ |
50968 | 51272 | break; |
50969 | 51273 | } |
50970 | - case 18446744073709549438LLU: // 99999999b8''''''''''''''' | |
51274 | + case 18446744073709549425LLU: // 99999999bv''''''''''''''' | |
50971 | 51275 | { |
50972 | 51276 | // ACCUMULATE ARGUMENTS - BEGIN |
50973 | 51277 | { |
@@ -50975,7 +51279,7 @@ | ||
50975 | 51279 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
50976 | 51280 | } |
50977 | 51281 | // ACCUMULATE ARGUMENTS - END |
50978 | - uint64_t return_to = 18446744073709549437LLU; | |
51282 | + uint64_t return_to = 18446744073709549424LLU; | |
50979 | 51283 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
50980 | 51284 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
50981 | 51285 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -50984,7 +51288,7 @@ | ||
50984 | 51288 | state.addr = 839519665163075584LLU; // skip______ |
50985 | 51289 | break; |
50986 | 51290 | } |
50987 | - case 18446744073709549437LLU: // 99999999b7''''''''''''''' | |
51291 | + case 18446744073709549424LLU: // 99999999bu''''''''''''''' | |
50988 | 51292 | { |
50989 | 51293 | matchid(",", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU))); |
50990 | 51294 | fprintf(stdout, "%s", " >> "); |
@@ -50994,7 +51298,7 @@ | ||
50994 | 51298 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
50995 | 51299 | } |
50996 | 51300 | // ACCUMULATE ARGUMENTS - END |
50997 | - uint64_t return_to = 18446744073709549436LLU; | |
51301 | + uint64_t return_to = 18446744073709549423LLU; | |
50998 | 51302 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
50999 | 51303 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
51000 | 51304 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -51003,7 +51307,7 @@ | ||
51003 | 51307 | state.addr = 839519665163075584LLU; // skip______ |
51004 | 51308 | break; |
51005 | 51309 | } |
51006 | - case 18446744073709549436LLU: // 99999999b6''''''''''''''' | |
51310 | + case 18446744073709549423LLU: // 99999999bt''''''''''''''' | |
51007 | 51311 | { |
51008 | 51312 | |
51009 | 51313 | *LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU))); |
@@ -51025,7 +51329,7 @@ | ||
51025 | 51329 | LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
51026 | 51330 | } |
51027 | 51331 | // ACCUMULATE ARGUMENTS - END |
51028 | - uint64_t return_to = 18446744073709549435LLU; | |
51332 | + uint64_t return_to = 18446744073709549422LLU; | |
51029 | 51333 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
51030 | 51334 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
51031 | 51335 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -51034,7 +51338,7 @@ | ||
51034 | 51338 | state.addr = 23446349213393492LLU; // ASSERTINIT |
51035 | 51339 | break; |
51036 | 51340 | } |
51037 | - case 18446744073709549435LLU: // 99999999b5''''''''''''''' | |
51341 | + case 18446744073709549422LLU: // 99999999bs''''''''''''''' | |
51038 | 51342 | { |
51039 | 51343 | { |
51040 | 51344 | uint64_t arg = 0; |
@@ -51113,7 +51417,7 @@ | ||
51113 | 51417 | LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
51114 | 51418 | } |
51115 | 51419 | // ACCUMULATE ARGUMENTS - END |
51116 | - uint64_t return_to = 18446744073709549434LLU; | |
51420 | + uint64_t return_to = 18446744073709549421LLU; | |
51117 | 51421 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)); |
51118 | 51422 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
51119 | 51423 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -51122,7 +51426,7 @@ | ||
51122 | 51426 | state.addr = 293363126232490310LLU; // PROCVARREF |
51123 | 51427 | break; |
51124 | 51428 | } |
51125 | - case 18446744073709549434LLU: // 99999999b4''''''''''''''' | |
51429 | + case 18446744073709549421LLU: // 99999999br''''''''''''''' | |
51126 | 51430 | { |
51127 | 51431 | // variable u64 initialize goes out of scope |
51128 | 51432 | // emitted destructur for type u64 |
@@ -51143,7 +51447,7 @@ | ||
51143 | 51447 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
51144 | 51448 | } |
51145 | 51449 | // ACCUMULATE ARGUMENTS - END |
51146 | - uint64_t return_to = 18446744073709549433LLU; | |
51450 | + uint64_t return_to = 18446744073709549420LLU; | |
51147 | 51451 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
51148 | 51452 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
51149 | 51453 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -51152,7 +51456,7 @@ | ||
51152 | 51456 | state.addr = 517555565476695680LLU; // assertu64_ |
51153 | 51457 | break; |
51154 | 51458 | } |
51155 | - case 18446744073709549433LLU: // 99999999b3''''''''''''''' | |
51459 | + case 18446744073709549420LLU: // 99999999bq''''''''''''''' | |
51156 | 51460 | { |
51157 | 51461 | // ACCUMULATE ARGUMENTS - BEGIN |
51158 | 51462 | { |
@@ -51160,7 +51464,7 @@ | ||
51160 | 51464 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
51161 | 51465 | } |
51162 | 51466 | // ACCUMULATE ARGUMENTS - END |
51163 | - uint64_t return_to = 18446744073709549432LLU; | |
51467 | + uint64_t return_to = 18446744073709549419LLU; | |
51164 | 51468 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
51165 | 51469 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
51166 | 51470 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -51169,7 +51473,7 @@ | ||
51169 | 51473 | state.addr = 839519665163075584LLU; // skip______ |
51170 | 51474 | break; |
51171 | 51475 | } |
51172 | - case 18446744073709549432LLU: // 99999999b2''''''''''''''' | |
51476 | + case 18446744073709549419LLU: // 99999999bp''''''''''''''' | |
51173 | 51477 | { |
51174 | 51478 | matchid(")", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU))); |
51175 | 51479 | fprintf(stdout, "%s", ";"); |
@@ -51181,7 +51485,7 @@ | ||
51181 | 51485 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
51182 | 51486 | } |
51183 | 51487 | // ACCUMULATE ARGUMENTS - END |
51184 | - uint64_t return_to = 18446744073709549431LLU; | |
51488 | + uint64_t return_to = 18446744073709549418LLU; | |
51185 | 51489 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
51186 | 51490 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
51187 | 51491 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -51190,7 +51494,7 @@ | ||
51190 | 51494 | state.addr = 18446744073709551534LLU; // 999999998s''''''''''''''' |
51191 | 51495 | break; |
51192 | 51496 | } |
51193 | - case 18446744073709549431LLU: // 99999999b1''''''''''''''' | |
51497 | + case 18446744073709549418LLU: // 99999999bo''''''''''''''' | |
51194 | 51498 | { |
51195 | 51499 | (void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference single____ at 21 |
51196 | 51500 | // variable type______ type______ goes out of scope |
@@ -51201,7 +51505,7 @@ | ||
51201 | 51505 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
51202 | 51506 | } |
51203 | 51507 | // ACCUMULATE ARGUMENTS - END |
51204 | - uint64_t return_to = 18446744073709549430LLU; | |
51508 | + uint64_t return_to = 18446744073709549417LLU; | |
51205 | 51509 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
51206 | 51510 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
51207 | 51511 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -51210,7 +51514,7 @@ | ||
51210 | 51514 | state.addr = 18446744073709551573LLU; // 999999999U''''''''''''''' |
51211 | 51515 | break; |
51212 | 51516 | } |
51213 | - case 18446744073709549430LLU: // 99999999b0''''''''''''''' | |
51517 | + case 18446744073709549417LLU: // 99999999bn''''''''''''''' | |
51214 | 51518 | { |
51215 | 51519 | (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type______ at 20 |
51216 | 51520 | // variable u64 mutable___ goes out of scope |
@@ -51222,10 +51526,10 @@ | ||
51222 | 51526 | // variable u64 id________ goes out of scope |
51223 | 51527 | // emitted destructur for type u64 |
51224 | 51528 | (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id________ at 17 |
51225 | - state.addr = 18446744073709549448LLU; // 99999999cH''''''''''''''' | |
51529 | + state.addr = 18446744073709549435LLU; // 99999999b5''''''''''''''' | |
51226 | 51530 | break; |
51227 | 51531 | } |
51228 | - case 18446744073709549449LLU: // 99999999cI''''''''''''''' | |
51532 | + case 18446744073709549436LLU: // 99999999b6''''''''''''''' | |
51229 | 51533 | { |
51230 | 51534 | |
51231 | 51535 | *LOCAL_ACCESS(heap.data, 16LLU, 15LLU) = 513265221985370112; |
@@ -51236,11 +51540,11 @@ | ||
51236 | 51540 | LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
51237 | 51541 | } |
51238 | 51542 | *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 0LLU)); |
51239 | - state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549429LLU : 18446744073709549428LLU; | |
51543 | + state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549416LLU : 18446744073709549415LLU; | |
51240 | 51544 | (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 17 |
51241 | 51545 | break; |
51242 | 51546 | } |
51243 | - case 18446744073709549429LLU: // 99999999bz''''''''''''''' | |
51547 | + case 18446744073709549416LLU: // 99999999bm''''''''''''''' | |
51244 | 51548 | { |
51245 | 51549 | { |
51246 | 51550 | uint64_t arg = 0; |
@@ -51267,7 +51571,7 @@ | ||
51267 | 51571 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
51268 | 51572 | } |
51269 | 51573 | // ACCUMULATE ARGUMENTS - END |
51270 | - uint64_t return_to = 18446744073709549426LLU; | |
51574 | + uint64_t return_to = 18446744073709549413LLU; | |
51271 | 51575 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
51272 | 51576 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
51273 | 51577 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -51276,7 +51580,7 @@ | ||
51276 | 51580 | state.addr = 861504796319285248LLU; // typeu64___ |
51277 | 51581 | break; |
51278 | 51582 | } |
51279 | - case 18446744073709549426LLU: // 99999999bw''''''''''''''' | |
51583 | + case 18446744073709549413LLU: // 99999999bj''''''''''''''' | |
51280 | 51584 | { |
51281 | 51585 | { |
51282 | 51586 | uint64_t arg = 0; |
@@ -51301,7 +51605,7 @@ | ||
51301 | 51605 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
51302 | 51606 | } |
51303 | 51607 | // ACCUMULATE ARGUMENTS - END |
51304 | - uint64_t return_to = 18446744073709549424LLU; | |
51608 | + uint64_t return_to = 18446744073709549411LLU; | |
51305 | 51609 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
51306 | 51610 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
51307 | 51611 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -51310,7 +51614,7 @@ | ||
51310 | 51614 | state.addr = 861504796319285248LLU; // typeu64___ |
51311 | 51615 | break; |
51312 | 51616 | } |
51313 | - case 18446744073709549424LLU: // 99999999bu''''''''''''''' | |
51617 | + case 18446744073709549411LLU: // 99999999bh''''''''''''''' | |
51314 | 51618 | { |
51315 | 51619 | { |
51316 | 51620 | uint64_t exchange = LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 23*/; |
@@ -51330,7 +51634,7 @@ | ||
51330 | 51634 | LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
51331 | 51635 | } |
51332 | 51636 | // ACCUMULATE ARGUMENTS - END |
51333 | - uint64_t return_to = 18446744073709549425LLU; | |
51637 | + uint64_t return_to = 18446744073709549412LLU; | |
51334 | 51638 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
51335 | 51639 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
51336 | 51640 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -51339,7 +51643,7 @@ | ||
51339 | 51643 | state.addr = 819859607768530944LLU; // resdest___ |
51340 | 51644 | break; |
51341 | 51645 | } |
51342 | - case 18446744073709549425LLU: // 99999999bv''''''''''''''' | |
51646 | + case 18446744073709549412LLU: // 99999999bi''''''''''''''' | |
51343 | 51647 | { |
51344 | 51648 | // ACCUMULATE ARGUMENTS - BEGIN |
51345 | 51649 | { |
@@ -51359,7 +51663,7 @@ | ||
51359 | 51663 | LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
51360 | 51664 | } |
51361 | 51665 | // ACCUMULATE ARGUMENTS - END |
51362 | - uint64_t return_to = 18446744073709549423LLU; | |
51666 | + uint64_t return_to = 18446744073709549410LLU; | |
51363 | 51667 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
51364 | 51668 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
51365 | 51669 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -51368,7 +51672,7 @@ | ||
51368 | 51672 | state.addr = 819857494882385920LLU; // res_u64___ |
51369 | 51673 | break; |
51370 | 51674 | } |
51371 | - case 18446744073709549423LLU: // 99999999bt''''''''''''''' | |
51675 | + case 18446744073709549410LLU: // 99999999bg''''''''''''''' | |
51372 | 51676 | { |
51373 | 51677 | // ACCUMULATE ARGUMENTS - BEGIN |
51374 | 51678 | { |
@@ -51376,7 +51680,7 @@ | ||
51376 | 51680 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
51377 | 51681 | } |
51378 | 51682 | // ACCUMULATE ARGUMENTS - END |
51379 | - uint64_t return_to = 18446744073709549422LLU; | |
51683 | + uint64_t return_to = 18446744073709549409LLU; | |
51380 | 51684 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
51381 | 51685 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
51382 | 51686 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -51385,7 +51689,7 @@ | ||
51385 | 51689 | state.addr = 839519665163075584LLU; // skip______ |
51386 | 51690 | break; |
51387 | 51691 | } |
51388 | - case 18446744073709549422LLU: // 99999999bs''''''''''''''' | |
51692 | + case 18446744073709549409LLU: // 99999999bf''''''''''''''' | |
51389 | 51693 | { |
51390 | 51694 | matchid("(", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU))); |
51391 | 51695 | fprintf(stdout, "%s", "\n "); |
@@ -51411,7 +51715,7 @@ | ||
51411 | 51715 | LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
51412 | 51716 | } |
51413 | 51717 | // ACCUMULATE ARGUMENTS - END |
51414 | - uint64_t return_to = 18446744073709549421LLU; | |
51718 | + uint64_t return_to = 18446744073709549408LLU; | |
51415 | 51719 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)); |
51416 | 51720 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
51417 | 51721 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -51420,7 +51724,7 @@ | ||
51420 | 51724 | state.addr = 587881357514113024LLU; // emitpar___ |
51421 | 51725 | break; |
51422 | 51726 | } |
51423 | - case 18446744073709549421LLU: // 99999999br''''''''''''''' | |
51727 | + case 18446744073709549408LLU: // 99999999be''''''''''''''' | |
51424 | 51728 | { |
51425 | 51729 | fprintf(stdout, "%s", " = "); |
51426 | 51730 | // ACCUMULATE ARGUMENTS - BEGIN |
@@ -51429,7 +51733,7 @@ | ||
51429 | 51733 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
51430 | 51734 | } |
51431 | 51735 | // ACCUMULATE ARGUMENTS - END |
51432 | - uint64_t return_to = 18446744073709549420LLU; | |
51736 | + uint64_t return_to = 18446744073709549407LLU; | |
51433 | 51737 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
51434 | 51738 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
51435 | 51739 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -51438,7 +51742,7 @@ | ||
51438 | 51742 | state.addr = 839519665163075584LLU; // skip______ |
51439 | 51743 | break; |
51440 | 51744 | } |
51441 | - case 18446744073709549420LLU: // 99999999bq''''''''''''''' | |
51745 | + case 18446744073709549407LLU: // 99999999bd''''''''''''''' | |
51442 | 51746 | { |
51443 | 51747 | |
51444 | 51748 | *LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU))); |
@@ -51460,7 +51764,7 @@ | ||
51460 | 51764 | LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
51461 | 51765 | } |
51462 | 51766 | // ACCUMULATE ARGUMENTS - END |
51463 | - uint64_t return_to = 18446744073709549419LLU; | |
51767 | + uint64_t return_to = 18446744073709549406LLU; | |
51464 | 51768 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
51465 | 51769 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
51466 | 51770 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -51469,7 +51773,7 @@ | ||
51469 | 51773 | state.addr = 23446349213393492LLU; // ASSERTINIT |
51470 | 51774 | break; |
51471 | 51775 | } |
51472 | - case 18446744073709549419LLU: // 99999999bp''''''''''''''' | |
51776 | + case 18446744073709549406LLU: // 99999999bc''''''''''''''' | |
51473 | 51777 | { |
51474 | 51778 | { |
51475 | 51779 | uint64_t arg = 0; |
@@ -51548,7 +51852,7 @@ | ||
51548 | 51852 | LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
51549 | 51853 | } |
51550 | 51854 | // ACCUMULATE ARGUMENTS - END |
51551 | - uint64_t return_to = 18446744073709549418LLU; | |
51855 | + uint64_t return_to = 18446744073709549405LLU; | |
51552 | 51856 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)); |
51553 | 51857 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
51554 | 51858 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -51557,7 +51861,7 @@ | ||
51557 | 51861 | state.addr = 293363126232490310LLU; // PROCVARREF |
51558 | 51862 | break; |
51559 | 51863 | } |
51560 | - case 18446744073709549418LLU: // 99999999bo''''''''''''''' | |
51864 | + case 18446744073709549405LLU: // 99999999bb''''''''''''''' | |
51561 | 51865 | { |
51562 | 51866 | // variable u64 initialize goes out of scope |
51563 | 51867 | // emitted destructur for type u64 |
@@ -51578,7 +51882,7 @@ | ||
51578 | 51882 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
51579 | 51883 | } |
51580 | 51884 | // ACCUMULATE ARGUMENTS - END |
51581 | - uint64_t return_to = 18446744073709549417LLU; | |
51885 | + uint64_t return_to = 18446744073709549404LLU; | |
51582 | 51886 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
51583 | 51887 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
51584 | 51888 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -51587,7 +51891,7 @@ | ||
51587 | 51891 | state.addr = 517555565476695680LLU; // assertu64_ |
51588 | 51892 | break; |
51589 | 51893 | } |
51590 | - case 18446744073709549417LLU: // 99999999bn''''''''''''''' | |
51894 | + case 18446744073709549404LLU: // 99999999ba''''''''''''''' | |
51591 | 51895 | { |
51592 | 51896 | // ACCUMULATE ARGUMENTS - BEGIN |
51593 | 51897 | { |
@@ -51595,7 +51899,7 @@ | ||
51595 | 51899 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
51596 | 51900 | } |
51597 | 51901 | // ACCUMULATE ARGUMENTS - END |
51598 | - uint64_t return_to = 18446744073709549416LLU; | |
51902 | + uint64_t return_to = 18446744073709549403LLU; | |
51599 | 51903 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
51600 | 51904 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
51601 | 51905 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -51604,7 +51908,7 @@ | ||
51604 | 51908 | state.addr = 839519665163075584LLU; // skip______ |
51605 | 51909 | break; |
51606 | 51910 | } |
51607 | - case 18446744073709549416LLU: // 99999999bm''''''''''''''' | |
51911 | + case 18446744073709549403LLU: // 99999999b$''''''''''''''' | |
51608 | 51912 | { |
51609 | 51913 | matchid(",", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU))); |
51610 | 51914 | fprintf(stdout, "%s", " + "); |
@@ -51614,7 +51918,7 @@ | ||
51614 | 51918 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
51615 | 51919 | } |
51616 | 51920 | // ACCUMULATE ARGUMENTS - END |
51617 | - uint64_t return_to = 18446744073709549415LLU; | |
51921 | + uint64_t return_to = 18446744073709549402LLU; | |
51618 | 51922 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
51619 | 51923 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
51620 | 51924 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -51623,7 +51927,7 @@ | ||
51623 | 51927 | state.addr = 839519665163075584LLU; // skip______ |
51624 | 51928 | break; |
51625 | 51929 | } |
51626 | - case 18446744073709549415LLU: // 99999999bl''''''''''''''' | |
51930 | + case 18446744073709549402LLU: // 99999999bZ''''''''''''''' | |
51627 | 51931 | { |
51628 | 51932 | |
51629 | 51933 | *LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU))); |
@@ -51645,7 +51949,7 @@ | ||
51645 | 51949 | LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
51646 | 51950 | } |
51647 | 51951 | // ACCUMULATE ARGUMENTS - END |
51648 | - uint64_t return_to = 18446744073709549414LLU; | |
51952 | + uint64_t return_to = 18446744073709549401LLU; | |
51649 | 51953 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
51650 | 51954 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
51651 | 51955 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -51654,7 +51958,7 @@ | ||
51654 | 51958 | state.addr = 23446349213393492LLU; // ASSERTINIT |
51655 | 51959 | break; |
51656 | 51960 | } |
51657 | - case 18446744073709549414LLU: // 99999999bk''''''''''''''' | |
51961 | + case 18446744073709549401LLU: // 99999999bY''''''''''''''' | |
51658 | 51962 | { |
51659 | 51963 | { |
51660 | 51964 | uint64_t arg = 0; |
@@ -51733,7 +52037,7 @@ | ||
51733 | 52037 | LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
51734 | 52038 | } |
51735 | 52039 | // ACCUMULATE ARGUMENTS - END |
51736 | - uint64_t return_to = 18446744073709549413LLU; | |
52040 | + uint64_t return_to = 18446744073709549400LLU; | |
51737 | 52041 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)); |
51738 | 52042 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
51739 | 52043 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -51742,7 +52046,7 @@ | ||
51742 | 52046 | state.addr = 293363126232490310LLU; // PROCVARREF |
51743 | 52047 | break; |
51744 | 52048 | } |
51745 | - case 18446744073709549413LLU: // 99999999bj''''''''''''''' | |
52049 | + case 18446744073709549400LLU: // 99999999bX''''''''''''''' | |
51746 | 52050 | { |
51747 | 52051 | // variable u64 initialize goes out of scope |
51748 | 52052 | // emitted destructur for type u64 |
@@ -51763,7 +52067,7 @@ | ||
51763 | 52067 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
51764 | 52068 | } |
51765 | 52069 | // ACCUMULATE ARGUMENTS - END |
51766 | - uint64_t return_to = 18446744073709549412LLU; | |
52070 | + uint64_t return_to = 18446744073709549399LLU; | |
51767 | 52071 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
51768 | 52072 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
51769 | 52073 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -51772,7 +52076,7 @@ | ||
51772 | 52076 | state.addr = 517555565476695680LLU; // assertu64_ |
51773 | 52077 | break; |
51774 | 52078 | } |
51775 | - case 18446744073709549412LLU: // 99999999bi''''''''''''''' | |
52079 | + case 18446744073709549399LLU: // 99999999bW''''''''''''''' | |
51776 | 52080 | { |
51777 | 52081 | // ACCUMULATE ARGUMENTS - BEGIN |
51778 | 52082 | { |
@@ -51780,7 +52084,7 @@ | ||
51780 | 52084 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
51781 | 52085 | } |
51782 | 52086 | // ACCUMULATE ARGUMENTS - END |
51783 | - uint64_t return_to = 18446744073709549411LLU; | |
52087 | + uint64_t return_to = 18446744073709549398LLU; | |
51784 | 52088 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
51785 | 52089 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
51786 | 52090 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -51789,7 +52093,7 @@ | ||
51789 | 52093 | state.addr = 839519665163075584LLU; // skip______ |
51790 | 52094 | break; |
51791 | 52095 | } |
51792 | - case 18446744073709549411LLU: // 99999999bh''''''''''''''' | |
52096 | + case 18446744073709549398LLU: // 99999999bV''''''''''''''' | |
51793 | 52097 | { |
51794 | 52098 | matchid(")", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU))); |
51795 | 52099 | fprintf(stdout, "%s", ";"); |
@@ -51801,7 +52105,7 @@ | ||
51801 | 52105 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
51802 | 52106 | } |
51803 | 52107 | // ACCUMULATE ARGUMENTS - END |
51804 | - uint64_t return_to = 18446744073709549410LLU; | |
52108 | + uint64_t return_to = 18446744073709549397LLU; | |
51805 | 52109 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
51806 | 52110 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
51807 | 52111 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -51810,7 +52114,7 @@ | ||
51810 | 52114 | state.addr = 18446744073709551534LLU; // 999999998s''''''''''''''' |
51811 | 52115 | break; |
51812 | 52116 | } |
51813 | - case 18446744073709549410LLU: // 99999999bg''''''''''''''' | |
52117 | + case 18446744073709549397LLU: // 99999999bU''''''''''''''' | |
51814 | 52118 | { |
51815 | 52119 | (void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference single____ at 21 |
51816 | 52120 | // variable type______ type______ goes out of scope |
@@ -51821,7 +52125,7 @@ | ||
51821 | 52125 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
51822 | 52126 | } |
51823 | 52127 | // ACCUMULATE ARGUMENTS - END |
51824 | - uint64_t return_to = 18446744073709549409LLU; | |
52128 | + uint64_t return_to = 18446744073709549396LLU; | |
51825 | 52129 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
51826 | 52130 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
51827 | 52131 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -51830,7 +52134,7 @@ | ||
51830 | 52134 | state.addr = 18446744073709551573LLU; // 999999999U''''''''''''''' |
51831 | 52135 | break; |
51832 | 52136 | } |
51833 | - case 18446744073709549409LLU: // 99999999bf''''''''''''''' | |
52137 | + case 18446744073709549396LLU: // 99999999bT''''''''''''''' | |
51834 | 52138 | { |
51835 | 52139 | (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type______ at 20 |
51836 | 52140 | // variable u64 mutable___ goes out of scope |
@@ -51842,10 +52146,10 @@ | ||
51842 | 52146 | // variable u64 id________ goes out of scope |
51843 | 52147 | // emitted destructur for type u64 |
51844 | 52148 | (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id________ at 17 |
51845 | - state.addr = 18446744073709549427LLU; // 99999999bx''''''''''''''' | |
52149 | + state.addr = 18446744073709549414LLU; // 99999999bk''''''''''''''' | |
51846 | 52150 | break; |
51847 | 52151 | } |
51848 | - case 18446744073709549428LLU: // 99999999by''''''''''''''' | |
52152 | + case 18446744073709549415LLU: // 99999999bl''''''''''''''' | |
51849 | 52153 | { |
51850 | 52154 | |
51851 | 52155 | *LOCAL_ACCESS(heap.data, 16LLU, 15LLU) = 842300673667104768; |
@@ -51856,11 +52160,11 @@ | ||
51856 | 52160 | LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
51857 | 52161 | } |
51858 | 52162 | *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 0LLU)); |
51859 | - state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549408LLU : 18446744073709549407LLU; | |
52163 | + state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549395LLU : 18446744073709549394LLU; | |
51860 | 52164 | (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 17 |
51861 | 52165 | break; |
51862 | 52166 | } |
51863 | - case 18446744073709549408LLU: // 99999999be''''''''''''''' | |
52167 | + case 18446744073709549395LLU: // 99999999bS''''''''''''''' | |
51864 | 52168 | { |
51865 | 52169 | { |
51866 | 52170 | uint64_t arg = 0; |
@@ -51887,7 +52191,7 @@ | ||
51887 | 52191 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
51888 | 52192 | } |
51889 | 52193 | // ACCUMULATE ARGUMENTS - END |
51890 | - uint64_t return_to = 18446744073709549405LLU; | |
52194 | + uint64_t return_to = 18446744073709549392LLU; | |
51891 | 52195 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
51892 | 52196 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
51893 | 52197 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -51896,7 +52200,7 @@ | ||
51896 | 52200 | state.addr = 861504796319285248LLU; // typeu64___ |
51897 | 52201 | break; |
51898 | 52202 | } |
51899 | - case 18446744073709549405LLU: // 99999999bb''''''''''''''' | |
52203 | + case 18446744073709549392LLU: // 99999999bP''''''''''''''' | |
51900 | 52204 | { |
51901 | 52205 | { |
51902 | 52206 | uint64_t arg = 0; |
@@ -51921,7 +52225,7 @@ | ||
51921 | 52225 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
51922 | 52226 | } |
51923 | 52227 | // ACCUMULATE ARGUMENTS - END |
51924 | - uint64_t return_to = 18446744073709549403LLU; | |
52228 | + uint64_t return_to = 18446744073709549390LLU; | |
51925 | 52229 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
51926 | 52230 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
51927 | 52231 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -51930,7 +52234,7 @@ | ||
51930 | 52234 | state.addr = 861504796319285248LLU; // typeu64___ |
51931 | 52235 | break; |
51932 | 52236 | } |
51933 | - case 18446744073709549403LLU: // 99999999b$''''''''''''''' | |
52237 | + case 18446744073709549390LLU: // 99999999bN''''''''''''''' | |
51934 | 52238 | { |
51935 | 52239 | { |
51936 | 52240 | uint64_t exchange = LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 23*/; |
@@ -51950,7 +52254,7 @@ | ||
51950 | 52254 | LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
51951 | 52255 | } |
51952 | 52256 | // ACCUMULATE ARGUMENTS - END |
51953 | - uint64_t return_to = 18446744073709549404LLU; | |
52257 | + uint64_t return_to = 18446744073709549391LLU; | |
51954 | 52258 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
51955 | 52259 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
51956 | 52260 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -51959,7 +52263,7 @@ | ||
51959 | 52263 | state.addr = 819859607768530944LLU; // resdest___ |
51960 | 52264 | break; |
51961 | 52265 | } |
51962 | - case 18446744073709549404LLU: // 99999999ba''''''''''''''' | |
52266 | + case 18446744073709549391LLU: // 99999999bO''''''''''''''' | |
51963 | 52267 | { |
51964 | 52268 | // ACCUMULATE ARGUMENTS - BEGIN |
51965 | 52269 | { |
@@ -51979,7 +52283,7 @@ | ||
51979 | 52283 | LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
51980 | 52284 | } |
51981 | 52285 | // ACCUMULATE ARGUMENTS - END |
51982 | - uint64_t return_to = 18446744073709549402LLU; | |
52286 | + uint64_t return_to = 18446744073709549389LLU; | |
51983 | 52287 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
51984 | 52288 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
51985 | 52289 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -51988,7 +52292,7 @@ | ||
51988 | 52292 | state.addr = 819857494882385920LLU; // res_u64___ |
51989 | 52293 | break; |
51990 | 52294 | } |
51991 | - case 18446744073709549402LLU: // 99999999bZ''''''''''''''' | |
52295 | + case 18446744073709549389LLU: // 99999999bM''''''''''''''' | |
51992 | 52296 | { |
51993 | 52297 | // ACCUMULATE ARGUMENTS - BEGIN |
51994 | 52298 | { |
@@ -51996,7 +52300,7 @@ | ||
51996 | 52300 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
51997 | 52301 | } |
51998 | 52302 | // ACCUMULATE ARGUMENTS - END |
51999 | - uint64_t return_to = 18446744073709549401LLU; | |
52303 | + uint64_t return_to = 18446744073709549388LLU; | |
52000 | 52304 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
52001 | 52305 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
52002 | 52306 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -52005,7 +52309,7 @@ | ||
52005 | 52309 | state.addr = 839519665163075584LLU; // skip______ |
52006 | 52310 | break; |
52007 | 52311 | } |
52008 | - case 18446744073709549401LLU: // 99999999bY''''''''''''''' | |
52312 | + case 18446744073709549388LLU: // 99999999bL''''''''''''''' | |
52009 | 52313 | { |
52010 | 52314 | matchid("(", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU))); |
52011 | 52315 | fprintf(stdout, "%s", "\n "); |
@@ -52031,7 +52335,7 @@ | ||
52031 | 52335 | LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
52032 | 52336 | } |
52033 | 52337 | // ACCUMULATE ARGUMENTS - END |
52034 | - uint64_t return_to = 18446744073709549400LLU; | |
52338 | + uint64_t return_to = 18446744073709549387LLU; | |
52035 | 52339 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)); |
52036 | 52340 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
52037 | 52341 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -52040,7 +52344,7 @@ | ||
52040 | 52344 | state.addr = 587881357514113024LLU; // emitpar___ |
52041 | 52345 | break; |
52042 | 52346 | } |
52043 | - case 18446744073709549400LLU: // 99999999bX''''''''''''''' | |
52347 | + case 18446744073709549387LLU: // 99999999bK''''''''''''''' | |
52044 | 52348 | { |
52045 | 52349 | fprintf(stdout, "%s", " = "); |
52046 | 52350 | // ACCUMULATE ARGUMENTS - BEGIN |
@@ -52049,7 +52353,7 @@ | ||
52049 | 52353 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
52050 | 52354 | } |
52051 | 52355 | // ACCUMULATE ARGUMENTS - END |
52052 | - uint64_t return_to = 18446744073709549399LLU; | |
52356 | + uint64_t return_to = 18446744073709549386LLU; | |
52053 | 52357 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
52054 | 52358 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
52055 | 52359 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -52058,7 +52362,7 @@ | ||
52058 | 52362 | state.addr = 839519665163075584LLU; // skip______ |
52059 | 52363 | break; |
52060 | 52364 | } |
52061 | - case 18446744073709549399LLU: // 99999999bW''''''''''''''' | |
52365 | + case 18446744073709549386LLU: // 99999999bJ''''''''''''''' | |
52062 | 52366 | { |
52063 | 52367 | |
52064 | 52368 | *LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU))); |
@@ -52080,7 +52384,7 @@ | ||
52080 | 52384 | LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
52081 | 52385 | } |
52082 | 52386 | // ACCUMULATE ARGUMENTS - END |
52083 | - uint64_t return_to = 18446744073709549398LLU; | |
52387 | + uint64_t return_to = 18446744073709549385LLU; | |
52084 | 52388 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
52085 | 52389 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
52086 | 52390 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -52089,7 +52393,7 @@ | ||
52089 | 52393 | state.addr = 23446349213393492LLU; // ASSERTINIT |
52090 | 52394 | break; |
52091 | 52395 | } |
52092 | - case 18446744073709549398LLU: // 99999999bV''''''''''''''' | |
52396 | + case 18446744073709549385LLU: // 99999999bI''''''''''''''' | |
52093 | 52397 | { |
52094 | 52398 | { |
52095 | 52399 | uint64_t arg = 0; |
@@ -52168,7 +52472,7 @@ | ||
52168 | 52472 | LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
52169 | 52473 | } |
52170 | 52474 | // ACCUMULATE ARGUMENTS - END |
52171 | - uint64_t return_to = 18446744073709549397LLU; | |
52475 | + uint64_t return_to = 18446744073709549384LLU; | |
52172 | 52476 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)); |
52173 | 52477 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
52174 | 52478 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -52177,7 +52481,7 @@ | ||
52177 | 52481 | state.addr = 293363126232490310LLU; // PROCVARREF |
52178 | 52482 | break; |
52179 | 52483 | } |
52180 | - case 18446744073709549397LLU: // 99999999bU''''''''''''''' | |
52484 | + case 18446744073709549384LLU: // 99999999bH''''''''''''''' | |
52181 | 52485 | { |
52182 | 52486 | // variable u64 initialize goes out of scope |
52183 | 52487 | // emitted destructur for type u64 |
@@ -52198,7 +52502,7 @@ | ||
52198 | 52502 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
52199 | 52503 | } |
52200 | 52504 | // ACCUMULATE ARGUMENTS - END |
52201 | - uint64_t return_to = 18446744073709549396LLU; | |
52505 | + uint64_t return_to = 18446744073709549383LLU; | |
52202 | 52506 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
52203 | 52507 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
52204 | 52508 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -52207,7 +52511,7 @@ | ||
52207 | 52511 | state.addr = 517555565476695680LLU; // assertu64_ |
52208 | 52512 | break; |
52209 | 52513 | } |
52210 | - case 18446744073709549396LLU: // 99999999bT''''''''''''''' | |
52514 | + case 18446744073709549383LLU: // 99999999bG''''''''''''''' | |
52211 | 52515 | { |
52212 | 52516 | // ACCUMULATE ARGUMENTS - BEGIN |
52213 | 52517 | { |
@@ -52215,7 +52519,7 @@ | ||
52215 | 52519 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
52216 | 52520 | } |
52217 | 52521 | // ACCUMULATE ARGUMENTS - END |
52218 | - uint64_t return_to = 18446744073709549395LLU; | |
52522 | + uint64_t return_to = 18446744073709549382LLU; | |
52219 | 52523 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
52220 | 52524 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
52221 | 52525 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -52224,7 +52528,7 @@ | ||
52224 | 52528 | state.addr = 839519665163075584LLU; // skip______ |
52225 | 52529 | break; |
52226 | 52530 | } |
52227 | - case 18446744073709549395LLU: // 99999999bS''''''''''''''' | |
52531 | + case 18446744073709549382LLU: // 99999999bF''''''''''''''' | |
52228 | 52532 | { |
52229 | 52533 | matchid(",", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU))); |
52230 | 52534 | fprintf(stdout, "%s", " - "); |
@@ -52234,7 +52538,7 @@ | ||
52234 | 52538 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
52235 | 52539 | } |
52236 | 52540 | // ACCUMULATE ARGUMENTS - END |
52237 | - uint64_t return_to = 18446744073709549394LLU; | |
52541 | + uint64_t return_to = 18446744073709549381LLU; | |
52238 | 52542 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
52239 | 52543 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
52240 | 52544 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -52243,7 +52547,7 @@ | ||
52243 | 52547 | state.addr = 839519665163075584LLU; // skip______ |
52244 | 52548 | break; |
52245 | 52549 | } |
52246 | - case 18446744073709549394LLU: // 99999999bR''''''''''''''' | |
52550 | + case 18446744073709549381LLU: // 99999999bE''''''''''''''' | |
52247 | 52551 | { |
52248 | 52552 | |
52249 | 52553 | *LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU))); |
@@ -52265,7 +52569,7 @@ | ||
52265 | 52569 | LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
52266 | 52570 | } |
52267 | 52571 | // ACCUMULATE ARGUMENTS - END |
52268 | - uint64_t return_to = 18446744073709549393LLU; | |
52572 | + uint64_t return_to = 18446744073709549380LLU; | |
52269 | 52573 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
52270 | 52574 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
52271 | 52575 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -52274,7 +52578,7 @@ | ||
52274 | 52578 | state.addr = 23446349213393492LLU; // ASSERTINIT |
52275 | 52579 | break; |
52276 | 52580 | } |
52277 | - case 18446744073709549393LLU: // 99999999bQ''''''''''''''' | |
52581 | + case 18446744073709549380LLU: // 99999999bD''''''''''''''' | |
52278 | 52582 | { |
52279 | 52583 | { |
52280 | 52584 | uint64_t arg = 0; |
@@ -52353,7 +52657,7 @@ | ||
52353 | 52657 | LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
52354 | 52658 | } |
52355 | 52659 | // ACCUMULATE ARGUMENTS - END |
52356 | - uint64_t return_to = 18446744073709549392LLU; | |
52660 | + uint64_t return_to = 18446744073709549379LLU; | |
52357 | 52661 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)); |
52358 | 52662 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
52359 | 52663 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -52362,7 +52666,7 @@ | ||
52362 | 52666 | state.addr = 293363126232490310LLU; // PROCVARREF |
52363 | 52667 | break; |
52364 | 52668 | } |
52365 | - case 18446744073709549392LLU: // 99999999bP''''''''''''''' | |
52669 | + case 18446744073709549379LLU: // 99999999bC''''''''''''''' | |
52366 | 52670 | { |
52367 | 52671 | // variable u64 initialize goes out of scope |
52368 | 52672 | // emitted destructur for type u64 |
@@ -52383,7 +52687,7 @@ | ||
52383 | 52687 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
52384 | 52688 | } |
52385 | 52689 | // ACCUMULATE ARGUMENTS - END |
52386 | - uint64_t return_to = 18446744073709549391LLU; | |
52690 | + uint64_t return_to = 18446744073709549378LLU; | |
52387 | 52691 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
52388 | 52692 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
52389 | 52693 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -52392,7 +52696,7 @@ | ||
52392 | 52696 | state.addr = 517555565476695680LLU; // assertu64_ |
52393 | 52697 | break; |
52394 | 52698 | } |
52395 | - case 18446744073709549391LLU: // 99999999bO''''''''''''''' | |
52699 | + case 18446744073709549378LLU: // 99999999bB''''''''''''''' | |
52396 | 52700 | { |
52397 | 52701 | // ACCUMULATE ARGUMENTS - BEGIN |
52398 | 52702 | { |
@@ -52400,7 +52704,7 @@ | ||
52400 | 52704 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
52401 | 52705 | } |
52402 | 52706 | // ACCUMULATE ARGUMENTS - END |
52403 | - uint64_t return_to = 18446744073709549390LLU; | |
52707 | + uint64_t return_to = 18446744073709549377LLU; | |
52404 | 52708 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
52405 | 52709 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
52406 | 52710 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -52409,7 +52713,7 @@ | ||
52409 | 52713 | state.addr = 839519665163075584LLU; // skip______ |
52410 | 52714 | break; |
52411 | 52715 | } |
52412 | - case 18446744073709549390LLU: // 99999999bN''''''''''''''' | |
52716 | + case 18446744073709549377LLU: // 99999999bA''''''''''''''' | |
52413 | 52717 | { |
52414 | 52718 | matchid(")", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU))); |
52415 | 52719 | fprintf(stdout, "%s", ";"); |
@@ -52421,7 +52725,7 @@ | ||
52421 | 52725 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
52422 | 52726 | } |
52423 | 52727 | // ACCUMULATE ARGUMENTS - END |
52424 | - uint64_t return_to = 18446744073709549389LLU; | |
52728 | + uint64_t return_to = 18446744073709549376LLU; | |
52425 | 52729 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
52426 | 52730 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
52427 | 52731 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -52430,7 +52734,7 @@ | ||
52430 | 52734 | state.addr = 18446744073709551534LLU; // 999999998s''''''''''''''' |
52431 | 52735 | break; |
52432 | 52736 | } |
52433 | - case 18446744073709549389LLU: // 99999999bM''''''''''''''' | |
52737 | + case 18446744073709549376LLU: // 99999999b_''''''''''''''' | |
52434 | 52738 | { |
52435 | 52739 | (void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference single____ at 21 |
52436 | 52740 | // variable type______ type______ goes out of scope |
@@ -52441,7 +52745,7 @@ | ||
52441 | 52745 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
52442 | 52746 | } |
52443 | 52747 | // ACCUMULATE ARGUMENTS - END |
52444 | - uint64_t return_to = 18446744073709549388LLU; | |
52748 | + uint64_t return_to = 18446744073709549375LLU; | |
52445 | 52749 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
52446 | 52750 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
52447 | 52751 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -52450,7 +52754,7 @@ | ||
52450 | 52754 | state.addr = 18446744073709551573LLU; // 999999999U''''''''''''''' |
52451 | 52755 | break; |
52452 | 52756 | } |
52453 | - case 18446744073709549388LLU: // 99999999bL''''''''''''''' | |
52757 | + case 18446744073709549375LLU: // 99999999a9''''''''''''''' | |
52454 | 52758 | { |
52455 | 52759 | (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type______ at 20 |
52456 | 52760 | // variable u64 mutable___ goes out of scope |
@@ -52462,10 +52766,10 @@ | ||
52462 | 52766 | // variable u64 id________ goes out of scope |
52463 | 52767 | // emitted destructur for type u64 |
52464 | 52768 | (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id________ at 17 |
52465 | - state.addr = 18446744073709549406LLU; // 99999999bc''''''''''''''' | |
52769 | + state.addr = 18446744073709549393LLU; // 99999999bQ''''''''''''''' | |
52466 | 52770 | break; |
52467 | 52771 | } |
52468 | - case 18446744073709549407LLU: // 99999999bd''''''''''''''' | |
52772 | + case 18446744073709549394LLU: // 99999999bR''''''''''''''' | |
52469 | 52773 | { |
52470 | 52774 | |
52471 | 52775 | *LOCAL_ACCESS(heap.data, 16LLU, 15LLU) = 734258263075323904; |
@@ -52476,11 +52780,11 @@ | ||
52476 | 52780 | LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
52477 | 52781 | } |
52478 | 52782 | *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 0LLU)); |
52479 | - state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549387LLU : 18446744073709549386LLU; | |
52783 | + state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549374LLU : 18446744073709549373LLU; | |
52480 | 52784 | (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 17 |
52481 | 52785 | break; |
52482 | 52786 | } |
52483 | - case 18446744073709549387LLU: // 99999999bK''''''''''''''' | |
52787 | + case 18446744073709549374LLU: // 99999999a8''''''''''''''' | |
52484 | 52788 | { |
52485 | 52789 | { |
52486 | 52790 | uint64_t arg = 0; |
@@ -52507,7 +52811,7 @@ | ||
52507 | 52811 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
52508 | 52812 | } |
52509 | 52813 | // ACCUMULATE ARGUMENTS - END |
52510 | - uint64_t return_to = 18446744073709549384LLU; | |
52814 | + uint64_t return_to = 18446744073709549371LLU; | |
52511 | 52815 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
52512 | 52816 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
52513 | 52817 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -52516,7 +52820,7 @@ | ||
52516 | 52820 | state.addr = 861504796319285248LLU; // typeu64___ |
52517 | 52821 | break; |
52518 | 52822 | } |
52519 | - case 18446744073709549384LLU: // 99999999bH''''''''''''''' | |
52823 | + case 18446744073709549371LLU: // 99999999a5''''''''''''''' | |
52520 | 52824 | { |
52521 | 52825 | { |
52522 | 52826 | uint64_t arg = 0; |
@@ -52541,7 +52845,7 @@ | ||
52541 | 52845 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
52542 | 52846 | } |
52543 | 52847 | // ACCUMULATE ARGUMENTS - END |
52544 | - uint64_t return_to = 18446744073709549382LLU; | |
52848 | + uint64_t return_to = 18446744073709549369LLU; | |
52545 | 52849 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
52546 | 52850 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
52547 | 52851 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -52550,7 +52854,7 @@ | ||
52550 | 52854 | state.addr = 861504796319285248LLU; // typeu64___ |
52551 | 52855 | break; |
52552 | 52856 | } |
52553 | - case 18446744073709549382LLU: // 99999999bF''''''''''''''' | |
52857 | + case 18446744073709549369LLU: // 99999999a3''''''''''''''' | |
52554 | 52858 | { |
52555 | 52859 | { |
52556 | 52860 | uint64_t exchange = LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 23*/; |
@@ -52570,7 +52874,7 @@ | ||
52570 | 52874 | LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
52571 | 52875 | } |
52572 | 52876 | // ACCUMULATE ARGUMENTS - END |
52573 | - uint64_t return_to = 18446744073709549383LLU; | |
52877 | + uint64_t return_to = 18446744073709549370LLU; | |
52574 | 52878 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
52575 | 52879 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
52576 | 52880 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -52579,7 +52883,7 @@ | ||
52579 | 52883 | state.addr = 819859607768530944LLU; // resdest___ |
52580 | 52884 | break; |
52581 | 52885 | } |
52582 | - case 18446744073709549383LLU: // 99999999bG''''''''''''''' | |
52886 | + case 18446744073709549370LLU: // 99999999a4''''''''''''''' | |
52583 | 52887 | { |
52584 | 52888 | // ACCUMULATE ARGUMENTS - BEGIN |
52585 | 52889 | { |
@@ -52599,7 +52903,7 @@ | ||
52599 | 52903 | LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
52600 | 52904 | } |
52601 | 52905 | // ACCUMULATE ARGUMENTS - END |
52602 | - uint64_t return_to = 18446744073709549381LLU; | |
52906 | + uint64_t return_to = 18446744073709549368LLU; | |
52603 | 52907 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
52604 | 52908 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
52605 | 52909 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -52608,7 +52912,7 @@ | ||
52608 | 52912 | state.addr = 819857494882385920LLU; // res_u64___ |
52609 | 52913 | break; |
52610 | 52914 | } |
52611 | - case 18446744073709549381LLU: // 99999999bE''''''''''''''' | |
52915 | + case 18446744073709549368LLU: // 99999999a2''''''''''''''' | |
52612 | 52916 | { |
52613 | 52917 | // ACCUMULATE ARGUMENTS - BEGIN |
52614 | 52918 | { |
@@ -52616,7 +52920,7 @@ | ||
52616 | 52920 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
52617 | 52921 | } |
52618 | 52922 | // ACCUMULATE ARGUMENTS - END |
52619 | - uint64_t return_to = 18446744073709549380LLU; | |
52923 | + uint64_t return_to = 18446744073709549367LLU; | |
52620 | 52924 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
52621 | 52925 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
52622 | 52926 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -52625,7 +52929,7 @@ | ||
52625 | 52929 | state.addr = 839519665163075584LLU; // skip______ |
52626 | 52930 | break; |
52627 | 52931 | } |
52628 | - case 18446744073709549380LLU: // 99999999bD''''''''''''''' | |
52932 | + case 18446744073709549367LLU: // 99999999a1''''''''''''''' | |
52629 | 52933 | { |
52630 | 52934 | matchid("(", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU))); |
52631 | 52935 | fprintf(stdout, "%s", "\n "); |
@@ -52651,7 +52955,7 @@ | ||
52651 | 52955 | LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
52652 | 52956 | } |
52653 | 52957 | // ACCUMULATE ARGUMENTS - END |
52654 | - uint64_t return_to = 18446744073709549379LLU; | |
52958 | + uint64_t return_to = 18446744073709549366LLU; | |
52655 | 52959 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)); |
52656 | 52960 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
52657 | 52961 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -52660,7 +52964,7 @@ | ||
52660 | 52964 | state.addr = 587881357514113024LLU; // emitpar___ |
52661 | 52965 | break; |
52662 | 52966 | } |
52663 | - case 18446744073709549379LLU: // 99999999bC''''''''''''''' | |
52967 | + case 18446744073709549366LLU: // 99999999a0''''''''''''''' | |
52664 | 52968 | { |
52665 | 52969 | fprintf(stdout, "%s", " = "); |
52666 | 52970 | // ACCUMULATE ARGUMENTS - BEGIN |
@@ -52669,7 +52973,7 @@ | ||
52669 | 52973 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
52670 | 52974 | } |
52671 | 52975 | // ACCUMULATE ARGUMENTS - END |
52672 | - uint64_t return_to = 18446744073709549378LLU; | |
52976 | + uint64_t return_to = 18446744073709549365LLU; | |
52673 | 52977 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
52674 | 52978 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
52675 | 52979 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -52678,7 +52982,7 @@ | ||
52678 | 52982 | state.addr = 839519665163075584LLU; // skip______ |
52679 | 52983 | break; |
52680 | 52984 | } |
52681 | - case 18446744073709549378LLU: // 99999999bB''''''''''''''' | |
52985 | + case 18446744073709549365LLU: // 99999999az''''''''''''''' | |
52682 | 52986 | { |
52683 | 52987 | |
52684 | 52988 | *LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU))); |
@@ -52700,7 +53004,7 @@ | ||
52700 | 53004 | LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
52701 | 53005 | } |
52702 | 53006 | // ACCUMULATE ARGUMENTS - END |
52703 | - uint64_t return_to = 18446744073709549377LLU; | |
53007 | + uint64_t return_to = 18446744073709549364LLU; | |
52704 | 53008 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
52705 | 53009 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
52706 | 53010 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -52709,7 +53013,7 @@ | ||
52709 | 53013 | state.addr = 23446349213393492LLU; // ASSERTINIT |
52710 | 53014 | break; |
52711 | 53015 | } |
52712 | - case 18446744073709549377LLU: // 99999999bA''''''''''''''' | |
53016 | + case 18446744073709549364LLU: // 99999999ay''''''''''''''' | |
52713 | 53017 | { |
52714 | 53018 | { |
52715 | 53019 | uint64_t arg = 0; |
@@ -52788,7 +53092,7 @@ | ||
52788 | 53092 | LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
52789 | 53093 | } |
52790 | 53094 | // ACCUMULATE ARGUMENTS - END |
52791 | - uint64_t return_to = 18446744073709549376LLU; | |
53095 | + uint64_t return_to = 18446744073709549363LLU; | |
52792 | 53096 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)); |
52793 | 53097 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
52794 | 53098 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -52797,7 +53101,7 @@ | ||
52797 | 53101 | state.addr = 293363126232490310LLU; // PROCVARREF |
52798 | 53102 | break; |
52799 | 53103 | } |
52800 | - case 18446744073709549376LLU: // 99999999b_''''''''''''''' | |
53104 | + case 18446744073709549363LLU: // 99999999ax''''''''''''''' | |
52801 | 53105 | { |
52802 | 53106 | // variable u64 initialize goes out of scope |
52803 | 53107 | // emitted destructur for type u64 |
@@ -52818,7 +53122,7 @@ | ||
52818 | 53122 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
52819 | 53123 | } |
52820 | 53124 | // ACCUMULATE ARGUMENTS - END |
52821 | - uint64_t return_to = 18446744073709549375LLU; | |
53125 | + uint64_t return_to = 18446744073709549362LLU; | |
52822 | 53126 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
52823 | 53127 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
52824 | 53128 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -52827,7 +53131,7 @@ | ||
52827 | 53131 | state.addr = 517555565476695680LLU; // assertu64_ |
52828 | 53132 | break; |
52829 | 53133 | } |
52830 | - case 18446744073709549375LLU: // 99999999a9''''''''''''''' | |
53134 | + case 18446744073709549362LLU: // 99999999aw''''''''''''''' | |
52831 | 53135 | { |
52832 | 53136 | // ACCUMULATE ARGUMENTS - BEGIN |
52833 | 53137 | { |
@@ -52835,7 +53139,7 @@ | ||
52835 | 53139 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
52836 | 53140 | } |
52837 | 53141 | // ACCUMULATE ARGUMENTS - END |
52838 | - uint64_t return_to = 18446744073709549374LLU; | |
53142 | + uint64_t return_to = 18446744073709549361LLU; | |
52839 | 53143 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
52840 | 53144 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
52841 | 53145 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -52844,7 +53148,7 @@ | ||
52844 | 53148 | state.addr = 839519665163075584LLU; // skip______ |
52845 | 53149 | break; |
52846 | 53150 | } |
52847 | - case 18446744073709549374LLU: // 99999999a8''''''''''''''' | |
53151 | + case 18446744073709549361LLU: // 99999999av''''''''''''''' | |
52848 | 53152 | { |
52849 | 53153 | matchid(",", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU))); |
52850 | 53154 | fprintf(stdout, "%s", " * "); |
@@ -52854,7 +53158,7 @@ | ||
52854 | 53158 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
52855 | 53159 | } |
52856 | 53160 | // ACCUMULATE ARGUMENTS - END |
52857 | - uint64_t return_to = 18446744073709549373LLU; | |
53161 | + uint64_t return_to = 18446744073709549360LLU; | |
52858 | 53162 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
52859 | 53163 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
52860 | 53164 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -52863,7 +53167,7 @@ | ||
52863 | 53167 | state.addr = 839519665163075584LLU; // skip______ |
52864 | 53168 | break; |
52865 | 53169 | } |
52866 | - case 18446744073709549373LLU: // 99999999a7''''''''''''''' | |
53170 | + case 18446744073709549360LLU: // 99999999au''''''''''''''' | |
52867 | 53171 | { |
52868 | 53172 | |
52869 | 53173 | *LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU))); |
@@ -52885,7 +53189,7 @@ | ||
52885 | 53189 | LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
52886 | 53190 | } |
52887 | 53191 | // ACCUMULATE ARGUMENTS - END |
52888 | - uint64_t return_to = 18446744073709549372LLU; | |
53192 | + uint64_t return_to = 18446744073709549359LLU; | |
52889 | 53193 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
52890 | 53194 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
52891 | 53195 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -52894,7 +53198,7 @@ | ||
52894 | 53198 | state.addr = 23446349213393492LLU; // ASSERTINIT |
52895 | 53199 | break; |
52896 | 53200 | } |
52897 | - case 18446744073709549372LLU: // 99999999a6''''''''''''''' | |
53201 | + case 18446744073709549359LLU: // 99999999at''''''''''''''' | |
52898 | 53202 | { |
52899 | 53203 | { |
52900 | 53204 | uint64_t arg = 0; |
@@ -52973,7 +53277,7 @@ | ||
52973 | 53277 | LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
52974 | 53278 | } |
52975 | 53279 | // ACCUMULATE ARGUMENTS - END |
52976 | - uint64_t return_to = 18446744073709549371LLU; | |
53280 | + uint64_t return_to = 18446744073709549358LLU; | |
52977 | 53281 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)); |
52978 | 53282 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
52979 | 53283 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -52982,7 +53286,7 @@ | ||
52982 | 53286 | state.addr = 293363126232490310LLU; // PROCVARREF |
52983 | 53287 | break; |
52984 | 53288 | } |
52985 | - case 18446744073709549371LLU: // 99999999a5''''''''''''''' | |
53289 | + case 18446744073709549358LLU: // 99999999as''''''''''''''' | |
52986 | 53290 | { |
52987 | 53291 | // variable u64 initialize goes out of scope |
52988 | 53292 | // emitted destructur for type u64 |
@@ -53003,7 +53307,7 @@ | ||
53003 | 53307 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
53004 | 53308 | } |
53005 | 53309 | // ACCUMULATE ARGUMENTS - END |
53006 | - uint64_t return_to = 18446744073709549370LLU; | |
53310 | + uint64_t return_to = 18446744073709549357LLU; | |
53007 | 53311 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
53008 | 53312 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
53009 | 53313 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -53012,7 +53316,7 @@ | ||
53012 | 53316 | state.addr = 517555565476695680LLU; // assertu64_ |
53013 | 53317 | break; |
53014 | 53318 | } |
53015 | - case 18446744073709549370LLU: // 99999999a4''''''''''''''' | |
53319 | + case 18446744073709549357LLU: // 99999999ar''''''''''''''' | |
53016 | 53320 | { |
53017 | 53321 | // ACCUMULATE ARGUMENTS - BEGIN |
53018 | 53322 | { |
@@ -53020,7 +53324,7 @@ | ||
53020 | 53324 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
53021 | 53325 | } |
53022 | 53326 | // ACCUMULATE ARGUMENTS - END |
53023 | - uint64_t return_to = 18446744073709549369LLU; | |
53327 | + uint64_t return_to = 18446744073709549356LLU; | |
53024 | 53328 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
53025 | 53329 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
53026 | 53330 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -53029,7 +53333,7 @@ | ||
53029 | 53333 | state.addr = 839519665163075584LLU; // skip______ |
53030 | 53334 | break; |
53031 | 53335 | } |
53032 | - case 18446744073709549369LLU: // 99999999a3''''''''''''''' | |
53336 | + case 18446744073709549356LLU: // 99999999aq''''''''''''''' | |
53033 | 53337 | { |
53034 | 53338 | matchid(")", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU))); |
53035 | 53339 | fprintf(stdout, "%s", ";"); |
@@ -53041,7 +53345,7 @@ | ||
53041 | 53345 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
53042 | 53346 | } |
53043 | 53347 | // ACCUMULATE ARGUMENTS - END |
53044 | - uint64_t return_to = 18446744073709549368LLU; | |
53348 | + uint64_t return_to = 18446744073709549355LLU; | |
53045 | 53349 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
53046 | 53350 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
53047 | 53351 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -53050,7 +53354,7 @@ | ||
53050 | 53354 | state.addr = 18446744073709551534LLU; // 999999998s''''''''''''''' |
53051 | 53355 | break; |
53052 | 53356 | } |
53053 | - case 18446744073709549368LLU: // 99999999a2''''''''''''''' | |
53357 | + case 18446744073709549355LLU: // 99999999ap''''''''''''''' | |
53054 | 53358 | { |
53055 | 53359 | (void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference single____ at 21 |
53056 | 53360 | // variable type______ type______ goes out of scope |
@@ -53061,7 +53365,7 @@ | ||
53061 | 53365 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
53062 | 53366 | } |
53063 | 53367 | // ACCUMULATE ARGUMENTS - END |
53064 | - uint64_t return_to = 18446744073709549367LLU; | |
53368 | + uint64_t return_to = 18446744073709549354LLU; | |
53065 | 53369 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
53066 | 53370 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
53067 | 53371 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -53070,7 +53374,7 @@ | ||
53070 | 53374 | state.addr = 18446744073709551573LLU; // 999999999U''''''''''''''' |
53071 | 53375 | break; |
53072 | 53376 | } |
53073 | - case 18446744073709549367LLU: // 99999999a1''''''''''''''' | |
53377 | + case 18446744073709549354LLU: // 99999999ao''''''''''''''' | |
53074 | 53378 | { |
53075 | 53379 | (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type______ at 20 |
53076 | 53380 | // variable u64 mutable___ goes out of scope |
@@ -53082,10 +53386,10 @@ | ||
53082 | 53386 | // variable u64 id________ goes out of scope |
53083 | 53387 | // emitted destructur for type u64 |
53084 | 53388 | (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id________ at 17 |
53085 | - state.addr = 18446744073709549385LLU; // 99999999bI''''''''''''''' | |
53389 | + state.addr = 18446744073709549372LLU; // 99999999a6''''''''''''''' | |
53086 | 53390 | break; |
53087 | 53391 | } |
53088 | - case 18446744073709549386LLU: // 99999999bJ''''''''''''''' | |
53392 | + case 18446744073709549373LLU: // 99999999a7''''''''''''''' | |
53089 | 53393 | { |
53090 | 53394 | |
53091 | 53395 | *LOCAL_ACCESS(heap.data, 16LLU, 15LLU) = 568794957234569216; |
@@ -53096,11 +53400,11 @@ | ||
53096 | 53400 | LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
53097 | 53401 | } |
53098 | 53402 | *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 0LLU)); |
53099 | - state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549366LLU : 18446744073709549365LLU; | |
53403 | + state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549353LLU : 18446744073709549352LLU; | |
53100 | 53404 | (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 17 |
53101 | 53405 | break; |
53102 | 53406 | } |
53103 | - case 18446744073709549366LLU: // 99999999a0''''''''''''''' | |
53407 | + case 18446744073709549353LLU: // 99999999an''''''''''''''' | |
53104 | 53408 | { |
53105 | 53409 | { |
53106 | 53410 | uint64_t arg = 0; |
@@ -53127,7 +53431,7 @@ | ||
53127 | 53431 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
53128 | 53432 | } |
53129 | 53433 | // ACCUMULATE ARGUMENTS - END |
53130 | - uint64_t return_to = 18446744073709549363LLU; | |
53434 | + uint64_t return_to = 18446744073709549350LLU; | |
53131 | 53435 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
53132 | 53436 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
53133 | 53437 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -53136,7 +53440,7 @@ | ||
53136 | 53440 | state.addr = 861504796319285248LLU; // typeu64___ |
53137 | 53441 | break; |
53138 | 53442 | } |
53139 | - case 18446744073709549363LLU: // 99999999ax''''''''''''''' | |
53443 | + case 18446744073709549350LLU: // 99999999ak''''''''''''''' | |
53140 | 53444 | { |
53141 | 53445 | { |
53142 | 53446 | uint64_t arg = 0; |
@@ -53161,7 +53465,7 @@ | ||
53161 | 53465 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
53162 | 53466 | } |
53163 | 53467 | // ACCUMULATE ARGUMENTS - END |
53164 | - uint64_t return_to = 18446744073709549361LLU; | |
53468 | + uint64_t return_to = 18446744073709549348LLU; | |
53165 | 53469 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
53166 | 53470 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
53167 | 53471 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -53170,7 +53474,7 @@ | ||
53170 | 53474 | state.addr = 861504796319285248LLU; // typeu64___ |
53171 | 53475 | break; |
53172 | 53476 | } |
53173 | - case 18446744073709549361LLU: // 99999999av''''''''''''''' | |
53477 | + case 18446744073709549348LLU: // 99999999ai''''''''''''''' | |
53174 | 53478 | { |
53175 | 53479 | { |
53176 | 53480 | uint64_t exchange = LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 23*/; |
@@ -53190,7 +53494,7 @@ | ||
53190 | 53494 | LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
53191 | 53495 | } |
53192 | 53496 | // ACCUMULATE ARGUMENTS - END |
53193 | - uint64_t return_to = 18446744073709549362LLU; | |
53497 | + uint64_t return_to = 18446744073709549349LLU; | |
53194 | 53498 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
53195 | 53499 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
53196 | 53500 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -53199,7 +53503,7 @@ | ||
53199 | 53503 | state.addr = 819859607768530944LLU; // resdest___ |
53200 | 53504 | break; |
53201 | 53505 | } |
53202 | - case 18446744073709549362LLU: // 99999999aw''''''''''''''' | |
53506 | + case 18446744073709549349LLU: // 99999999aj''''''''''''''' | |
53203 | 53507 | { |
53204 | 53508 | // ACCUMULATE ARGUMENTS - BEGIN |
53205 | 53509 | { |
@@ -53219,7 +53523,7 @@ | ||
53219 | 53523 | LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
53220 | 53524 | } |
53221 | 53525 | // ACCUMULATE ARGUMENTS - END |
53222 | - uint64_t return_to = 18446744073709549360LLU; | |
53526 | + uint64_t return_to = 18446744073709549347LLU; | |
53223 | 53527 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
53224 | 53528 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
53225 | 53529 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -53228,7 +53532,7 @@ | ||
53228 | 53532 | state.addr = 819857494882385920LLU; // res_u64___ |
53229 | 53533 | break; |
53230 | 53534 | } |
53231 | - case 18446744073709549360LLU: // 99999999au''''''''''''''' | |
53535 | + case 18446744073709549347LLU: // 99999999ah''''''''''''''' | |
53232 | 53536 | { |
53233 | 53537 | // ACCUMULATE ARGUMENTS - BEGIN |
53234 | 53538 | { |
@@ -53236,7 +53540,7 @@ | ||
53236 | 53540 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
53237 | 53541 | } |
53238 | 53542 | // ACCUMULATE ARGUMENTS - END |
53239 | - uint64_t return_to = 18446744073709549359LLU; | |
53543 | + uint64_t return_to = 18446744073709549346LLU; | |
53240 | 53544 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
53241 | 53545 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
53242 | 53546 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -53245,7 +53549,7 @@ | ||
53245 | 53549 | state.addr = 839519665163075584LLU; // skip______ |
53246 | 53550 | break; |
53247 | 53551 | } |
53248 | - case 18446744073709549359LLU: // 99999999at''''''''''''''' | |
53552 | + case 18446744073709549346LLU: // 99999999ag''''''''''''''' | |
53249 | 53553 | { |
53250 | 53554 | matchid("(", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU))); |
53251 | 53555 | fprintf(stdout, "%s", "\n "); |
@@ -53271,7 +53575,7 @@ | ||
53271 | 53575 | LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
53272 | 53576 | } |
53273 | 53577 | // ACCUMULATE ARGUMENTS - END |
53274 | - uint64_t return_to = 18446744073709549358LLU; | |
53578 | + uint64_t return_to = 18446744073709549345LLU; | |
53275 | 53579 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)); |
53276 | 53580 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
53277 | 53581 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -53280,7 +53584,7 @@ | ||
53280 | 53584 | state.addr = 587881357514113024LLU; // emitpar___ |
53281 | 53585 | break; |
53282 | 53586 | } |
53283 | - case 18446744073709549358LLU: // 99999999as''''''''''''''' | |
53587 | + case 18446744073709549345LLU: // 99999999af''''''''''''''' | |
53284 | 53588 | { |
53285 | 53589 | fprintf(stdout, "%s", " = "); |
53286 | 53590 | // ACCUMULATE ARGUMENTS - BEGIN |
@@ -53289,7 +53593,7 @@ | ||
53289 | 53593 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
53290 | 53594 | } |
53291 | 53595 | // ACCUMULATE ARGUMENTS - END |
53292 | - uint64_t return_to = 18446744073709549357LLU; | |
53596 | + uint64_t return_to = 18446744073709549344LLU; | |
53293 | 53597 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
53294 | 53598 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
53295 | 53599 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -53298,7 +53602,7 @@ | ||
53298 | 53602 | state.addr = 839519665163075584LLU; // skip______ |
53299 | 53603 | break; |
53300 | 53604 | } |
53301 | - case 18446744073709549357LLU: // 99999999ar''''''''''''''' | |
53605 | + case 18446744073709549344LLU: // 99999999ae''''''''''''''' | |
53302 | 53606 | { |
53303 | 53607 | |
53304 | 53608 | *LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU))); |
@@ -53320,7 +53624,7 @@ | ||
53320 | 53624 | LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
53321 | 53625 | } |
53322 | 53626 | // ACCUMULATE ARGUMENTS - END |
53323 | - uint64_t return_to = 18446744073709549356LLU; | |
53627 | + uint64_t return_to = 18446744073709549343LLU; | |
53324 | 53628 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
53325 | 53629 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
53326 | 53630 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -53329,7 +53633,7 @@ | ||
53329 | 53633 | state.addr = 23446349213393492LLU; // ASSERTINIT |
53330 | 53634 | break; |
53331 | 53635 | } |
53332 | - case 18446744073709549356LLU: // 99999999aq''''''''''''''' | |
53636 | + case 18446744073709549343LLU: // 99999999ad''''''''''''''' | |
53333 | 53637 | { |
53334 | 53638 | { |
53335 | 53639 | uint64_t arg = 0; |
@@ -53408,7 +53712,7 @@ | ||
53408 | 53712 | LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
53409 | 53713 | } |
53410 | 53714 | // ACCUMULATE ARGUMENTS - END |
53411 | - uint64_t return_to = 18446744073709549355LLU; | |
53715 | + uint64_t return_to = 18446744073709549342LLU; | |
53412 | 53716 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)); |
53413 | 53717 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
53414 | 53718 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -53417,7 +53721,7 @@ | ||
53417 | 53721 | state.addr = 293363126232490310LLU; // PROCVARREF |
53418 | 53722 | break; |
53419 | 53723 | } |
53420 | - case 18446744073709549355LLU: // 99999999ap''''''''''''''' | |
53724 | + case 18446744073709549342LLU: // 99999999ac''''''''''''''' | |
53421 | 53725 | { |
53422 | 53726 | // variable u64 initialize goes out of scope |
53423 | 53727 | // emitted destructur for type u64 |
@@ -53438,7 +53742,7 @@ | ||
53438 | 53742 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
53439 | 53743 | } |
53440 | 53744 | // ACCUMULATE ARGUMENTS - END |
53441 | - uint64_t return_to = 18446744073709549354LLU; | |
53745 | + uint64_t return_to = 18446744073709549341LLU; | |
53442 | 53746 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
53443 | 53747 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
53444 | 53748 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -53447,7 +53751,7 @@ | ||
53447 | 53751 | state.addr = 517555565476695680LLU; // assertu64_ |
53448 | 53752 | break; |
53449 | 53753 | } |
53450 | - case 18446744073709549354LLU: // 99999999ao''''''''''''''' | |
53754 | + case 18446744073709549341LLU: // 99999999ab''''''''''''''' | |
53451 | 53755 | { |
53452 | 53756 | // ACCUMULATE ARGUMENTS - BEGIN |
53453 | 53757 | { |
@@ -53455,7 +53759,7 @@ | ||
53455 | 53759 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
53456 | 53760 | } |
53457 | 53761 | // ACCUMULATE ARGUMENTS - END |
53458 | - uint64_t return_to = 18446744073709549353LLU; | |
53762 | + uint64_t return_to = 18446744073709549340LLU; | |
53459 | 53763 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
53460 | 53764 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
53461 | 53765 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -53464,7 +53768,7 @@ | ||
53464 | 53768 | state.addr = 839519665163075584LLU; // skip______ |
53465 | 53769 | break; |
53466 | 53770 | } |
53467 | - case 18446744073709549353LLU: // 99999999an''''''''''''''' | |
53771 | + case 18446744073709549340LLU: // 99999999aa''''''''''''''' | |
53468 | 53772 | { |
53469 | 53773 | matchid(",", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU))); |
53470 | 53774 | fprintf(stdout, "%s", " / "); |
@@ -53474,7 +53778,7 @@ | ||
53474 | 53778 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
53475 | 53779 | } |
53476 | 53780 | // ACCUMULATE ARGUMENTS - END |
53477 | - uint64_t return_to = 18446744073709549352LLU; | |
53781 | + uint64_t return_to = 18446744073709549339LLU; | |
53478 | 53782 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
53479 | 53783 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
53480 | 53784 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -53483,7 +53787,7 @@ | ||
53483 | 53787 | state.addr = 839519665163075584LLU; // skip______ |
53484 | 53788 | break; |
53485 | 53789 | } |
53486 | - case 18446744073709549352LLU: // 99999999am''''''''''''''' | |
53790 | + case 18446744073709549339LLU: // 99999999a$''''''''''''''' | |
53487 | 53791 | { |
53488 | 53792 | |
53489 | 53793 | *LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU))); |
@@ -53505,7 +53809,7 @@ | ||
53505 | 53809 | LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
53506 | 53810 | } |
53507 | 53811 | // ACCUMULATE ARGUMENTS - END |
53508 | - uint64_t return_to = 18446744073709549351LLU; | |
53812 | + uint64_t return_to = 18446744073709549338LLU; | |
53509 | 53813 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
53510 | 53814 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
53511 | 53815 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -53514,7 +53818,7 @@ | ||
53514 | 53818 | state.addr = 23446349213393492LLU; // ASSERTINIT |
53515 | 53819 | break; |
53516 | 53820 | } |
53517 | - case 18446744073709549351LLU: // 99999999al''''''''''''''' | |
53821 | + case 18446744073709549338LLU: // 99999999aZ''''''''''''''' | |
53518 | 53822 | { |
53519 | 53823 | { |
53520 | 53824 | uint64_t arg = 0; |
@@ -53593,7 +53897,7 @@ | ||
53593 | 53897 | LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
53594 | 53898 | } |
53595 | 53899 | // ACCUMULATE ARGUMENTS - END |
53596 | - uint64_t return_to = 18446744073709549350LLU; | |
53900 | + uint64_t return_to = 18446744073709549337LLU; | |
53597 | 53901 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)); |
53598 | 53902 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
53599 | 53903 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -53602,7 +53906,7 @@ | ||
53602 | 53906 | state.addr = 293363126232490310LLU; // PROCVARREF |
53603 | 53907 | break; |
53604 | 53908 | } |
53605 | - case 18446744073709549350LLU: // 99999999ak''''''''''''''' | |
53909 | + case 18446744073709549337LLU: // 99999999aY''''''''''''''' | |
53606 | 53910 | { |
53607 | 53911 | // variable u64 initialize goes out of scope |
53608 | 53912 | // emitted destructur for type u64 |
@@ -53623,7 +53927,7 @@ | ||
53623 | 53927 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
53624 | 53928 | } |
53625 | 53929 | // ACCUMULATE ARGUMENTS - END |
53626 | - uint64_t return_to = 18446744073709549349LLU; | |
53930 | + uint64_t return_to = 18446744073709549336LLU; | |
53627 | 53931 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
53628 | 53932 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
53629 | 53933 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -53632,7 +53936,7 @@ | ||
53632 | 53936 | state.addr = 517555565476695680LLU; // assertu64_ |
53633 | 53937 | break; |
53634 | 53938 | } |
53635 | - case 18446744073709549349LLU: // 99999999aj''''''''''''''' | |
53939 | + case 18446744073709549336LLU: // 99999999aX''''''''''''''' | |
53636 | 53940 | { |
53637 | 53941 | // ACCUMULATE ARGUMENTS - BEGIN |
53638 | 53942 | { |
@@ -53640,7 +53944,7 @@ | ||
53640 | 53944 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
53641 | 53945 | } |
53642 | 53946 | // ACCUMULATE ARGUMENTS - END |
53643 | - uint64_t return_to = 18446744073709549348LLU; | |
53947 | + uint64_t return_to = 18446744073709549335LLU; | |
53644 | 53948 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
53645 | 53949 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
53646 | 53950 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -53649,7 +53953,7 @@ | ||
53649 | 53953 | state.addr = 839519665163075584LLU; // skip______ |
53650 | 53954 | break; |
53651 | 53955 | } |
53652 | - case 18446744073709549348LLU: // 99999999ai''''''''''''''' | |
53956 | + case 18446744073709549335LLU: // 99999999aW''''''''''''''' | |
53653 | 53957 | { |
53654 | 53958 | matchid(")", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU))); |
53655 | 53959 | fprintf(stdout, "%s", ";"); |
@@ -53661,7 +53965,7 @@ | ||
53661 | 53965 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
53662 | 53966 | } |
53663 | 53967 | // ACCUMULATE ARGUMENTS - END |
53664 | - uint64_t return_to = 18446744073709549347LLU; | |
53968 | + uint64_t return_to = 18446744073709549334LLU; | |
53665 | 53969 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
53666 | 53970 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
53667 | 53971 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -53670,7 +53974,7 @@ | ||
53670 | 53974 | state.addr = 18446744073709551534LLU; // 999999998s''''''''''''''' |
53671 | 53975 | break; |
53672 | 53976 | } |
53673 | - case 18446744073709549347LLU: // 99999999ah''''''''''''''' | |
53977 | + case 18446744073709549334LLU: // 99999999aV''''''''''''''' | |
53674 | 53978 | { |
53675 | 53979 | (void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference single____ at 21 |
53676 | 53980 | // variable type______ type______ goes out of scope |
@@ -53681,7 +53985,7 @@ | ||
53681 | 53985 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
53682 | 53986 | } |
53683 | 53987 | // ACCUMULATE ARGUMENTS - END |
53684 | - uint64_t return_to = 18446744073709549346LLU; | |
53988 | + uint64_t return_to = 18446744073709549333LLU; | |
53685 | 53989 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
53686 | 53990 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
53687 | 53991 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -53690,7 +53994,7 @@ | ||
53690 | 53994 | state.addr = 18446744073709551573LLU; // 999999999U''''''''''''''' |
53691 | 53995 | break; |
53692 | 53996 | } |
53693 | - case 18446744073709549346LLU: // 99999999ag''''''''''''''' | |
53997 | + case 18446744073709549333LLU: // 99999999aU''''''''''''''' | |
53694 | 53998 | { |
53695 | 53999 | (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type______ at 20 |
53696 | 54000 | // variable u64 mutable___ goes out of scope |
@@ -53702,10 +54006,10 @@ | ||
53702 | 54006 | // variable u64 id________ goes out of scope |
53703 | 54007 | // emitted destructur for type u64 |
53704 | 54008 | (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id________ at 17 |
53705 | - state.addr = 18446744073709549364LLU; // 99999999ay''''''''''''''' | |
54009 | + state.addr = 18446744073709549351LLU; // 99999999al''''''''''''''' | |
53706 | 54010 | break; |
53707 | 54011 | } |
53708 | - case 18446744073709549365LLU: // 99999999az''''''''''''''' | |
54012 | + case 18446744073709549352LLU: // 99999999am''''''''''''''' | |
53709 | 54013 | { |
53710 | 54014 | |
53711 | 54015 | *LOCAL_ACCESS(heap.data, 16LLU, 15LLU) = 732534228842971136; |
@@ -53716,11 +54020,11 @@ | ||
53716 | 54020 | LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
53717 | 54021 | } |
53718 | 54022 | *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 0LLU)); |
53719 | - state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549345LLU : 18446744073709549344LLU; | |
54023 | + state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549332LLU : 18446744073709549331LLU; | |
53720 | 54024 | (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 17 |
53721 | 54025 | break; |
53722 | 54026 | } |
53723 | - case 18446744073709549345LLU: // 99999999af''''''''''''''' | |
54027 | + case 18446744073709549332LLU: // 99999999aT''''''''''''''' | |
53724 | 54028 | { |
53725 | 54029 | { |
53726 | 54030 | uint64_t arg = 0; |
@@ -53747,7 +54051,7 @@ | ||
53747 | 54051 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
53748 | 54052 | } |
53749 | 54053 | // ACCUMULATE ARGUMENTS - END |
53750 | - uint64_t return_to = 18446744073709549342LLU; | |
54054 | + uint64_t return_to = 18446744073709549329LLU; | |
53751 | 54055 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
53752 | 54056 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
53753 | 54057 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -53756,7 +54060,7 @@ | ||
53756 | 54060 | state.addr = 861504796319285248LLU; // typeu64___ |
53757 | 54061 | break; |
53758 | 54062 | } |
53759 | - case 18446744073709549342LLU: // 99999999ac''''''''''''''' | |
54063 | + case 18446744073709549329LLU: // 99999999aQ''''''''''''''' | |
53760 | 54064 | { |
53761 | 54065 | { |
53762 | 54066 | uint64_t arg = 0; |
@@ -53781,7 +54085,7 @@ | ||
53781 | 54085 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
53782 | 54086 | } |
53783 | 54087 | // ACCUMULATE ARGUMENTS - END |
53784 | - uint64_t return_to = 18446744073709549340LLU; | |
54088 | + uint64_t return_to = 18446744073709549327LLU; | |
53785 | 54089 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
53786 | 54090 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
53787 | 54091 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -53790,7 +54094,7 @@ | ||
53790 | 54094 | state.addr = 861504796319285248LLU; // typeu64___ |
53791 | 54095 | break; |
53792 | 54096 | } |
53793 | - case 18446744073709549340LLU: // 99999999aa''''''''''''''' | |
54097 | + case 18446744073709549327LLU: // 99999999aO''''''''''''''' | |
53794 | 54098 | { |
53795 | 54099 | { |
53796 | 54100 | uint64_t exchange = LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 23*/; |
@@ -53810,7 +54114,7 @@ | ||
53810 | 54114 | LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
53811 | 54115 | } |
53812 | 54116 | // ACCUMULATE ARGUMENTS - END |
53813 | - uint64_t return_to = 18446744073709549341LLU; | |
54117 | + uint64_t return_to = 18446744073709549328LLU; | |
53814 | 54118 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
53815 | 54119 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
53816 | 54120 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -53819,7 +54123,7 @@ | ||
53819 | 54123 | state.addr = 819859607768530944LLU; // resdest___ |
53820 | 54124 | break; |
53821 | 54125 | } |
53822 | - case 18446744073709549341LLU: // 99999999ab''''''''''''''' | |
54126 | + case 18446744073709549328LLU: // 99999999aP''''''''''''''' | |
53823 | 54127 | { |
53824 | 54128 | // ACCUMULATE ARGUMENTS - BEGIN |
53825 | 54129 | { |
@@ -53839,7 +54143,7 @@ | ||
53839 | 54143 | LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
53840 | 54144 | } |
53841 | 54145 | // ACCUMULATE ARGUMENTS - END |
53842 | - uint64_t return_to = 18446744073709549339LLU; | |
54146 | + uint64_t return_to = 18446744073709549326LLU; | |
53843 | 54147 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
53844 | 54148 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
53845 | 54149 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -53848,7 +54152,7 @@ | ||
53848 | 54152 | state.addr = 819857494882385920LLU; // res_u64___ |
53849 | 54153 | break; |
53850 | 54154 | } |
53851 | - case 18446744073709549339LLU: // 99999999a$''''''''''''''' | |
54155 | + case 18446744073709549326LLU: // 99999999aN''''''''''''''' | |
53852 | 54156 | { |
53853 | 54157 | // ACCUMULATE ARGUMENTS - BEGIN |
53854 | 54158 | { |
@@ -53856,7 +54160,7 @@ | ||
53856 | 54160 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
53857 | 54161 | } |
53858 | 54162 | // ACCUMULATE ARGUMENTS - END |
53859 | - uint64_t return_to = 18446744073709549338LLU; | |
54163 | + uint64_t return_to = 18446744073709549325LLU; | |
53860 | 54164 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
53861 | 54165 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
53862 | 54166 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -53865,7 +54169,7 @@ | ||
53865 | 54169 | state.addr = 839519665163075584LLU; // skip______ |
53866 | 54170 | break; |
53867 | 54171 | } |
53868 | - case 18446744073709549338LLU: // 99999999aZ''''''''''''''' | |
54172 | + case 18446744073709549325LLU: // 99999999aM''''''''''''''' | |
53869 | 54173 | { |
53870 | 54174 | matchid("(", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU))); |
53871 | 54175 | fprintf(stdout, "%s", "\n "); |
@@ -53891,7 +54195,7 @@ | ||
53891 | 54195 | LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
53892 | 54196 | } |
53893 | 54197 | // ACCUMULATE ARGUMENTS - END |
53894 | - uint64_t return_to = 18446744073709549337LLU; | |
54198 | + uint64_t return_to = 18446744073709549324LLU; | |
53895 | 54199 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)); |
53896 | 54200 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
53897 | 54201 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -53900,7 +54204,7 @@ | ||
53900 | 54204 | state.addr = 587881357514113024LLU; // emitpar___ |
53901 | 54205 | break; |
53902 | 54206 | } |
53903 | - case 18446744073709549337LLU: // 99999999aY''''''''''''''' | |
54207 | + case 18446744073709549324LLU: // 99999999aL''''''''''''''' | |
53904 | 54208 | { |
53905 | 54209 | fprintf(stdout, "%s", " = "); |
53906 | 54210 | // ACCUMULATE ARGUMENTS - BEGIN |
@@ -53909,7 +54213,7 @@ | ||
53909 | 54213 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
53910 | 54214 | } |
53911 | 54215 | // ACCUMULATE ARGUMENTS - END |
53912 | - uint64_t return_to = 18446744073709549336LLU; | |
54216 | + uint64_t return_to = 18446744073709549323LLU; | |
53913 | 54217 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
53914 | 54218 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
53915 | 54219 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -53918,7 +54222,7 @@ | ||
53918 | 54222 | state.addr = 839519665163075584LLU; // skip______ |
53919 | 54223 | break; |
53920 | 54224 | } |
53921 | - case 18446744073709549336LLU: // 99999999aX''''''''''''''' | |
54225 | + case 18446744073709549323LLU: // 99999999aK''''''''''''''' | |
53922 | 54226 | { |
53923 | 54227 | |
53924 | 54228 | *LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU))); |
@@ -53940,7 +54244,7 @@ | ||
53940 | 54244 | LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
53941 | 54245 | } |
53942 | 54246 | // ACCUMULATE ARGUMENTS - END |
53943 | - uint64_t return_to = 18446744073709549335LLU; | |
54247 | + uint64_t return_to = 18446744073709549322LLU; | |
53944 | 54248 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
53945 | 54249 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
53946 | 54250 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -53949,7 +54253,7 @@ | ||
53949 | 54253 | state.addr = 23446349213393492LLU; // ASSERTINIT |
53950 | 54254 | break; |
53951 | 54255 | } |
53952 | - case 18446744073709549335LLU: // 99999999aW''''''''''''''' | |
54256 | + case 18446744073709549322LLU: // 99999999aJ''''''''''''''' | |
53953 | 54257 | { |
53954 | 54258 | { |
53955 | 54259 | uint64_t arg = 0; |
@@ -54028,7 +54332,7 @@ | ||
54028 | 54332 | LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
54029 | 54333 | } |
54030 | 54334 | // ACCUMULATE ARGUMENTS - END |
54031 | - uint64_t return_to = 18446744073709549334LLU; | |
54335 | + uint64_t return_to = 18446744073709549321LLU; | |
54032 | 54336 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)); |
54033 | 54337 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
54034 | 54338 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -54037,7 +54341,7 @@ | ||
54037 | 54341 | state.addr = 293363126232490310LLU; // PROCVARREF |
54038 | 54342 | break; |
54039 | 54343 | } |
54040 | - case 18446744073709549334LLU: // 99999999aV''''''''''''''' | |
54344 | + case 18446744073709549321LLU: // 99999999aI''''''''''''''' | |
54041 | 54345 | { |
54042 | 54346 | // variable u64 initialize goes out of scope |
54043 | 54347 | // emitted destructur for type u64 |
@@ -54058,7 +54362,7 @@ | ||
54058 | 54362 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
54059 | 54363 | } |
54060 | 54364 | // ACCUMULATE ARGUMENTS - END |
54061 | - uint64_t return_to = 18446744073709549333LLU; | |
54365 | + uint64_t return_to = 18446744073709549320LLU; | |
54062 | 54366 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
54063 | 54367 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
54064 | 54368 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -54067,7 +54371,7 @@ | ||
54067 | 54371 | state.addr = 517555565476695680LLU; // assertu64_ |
54068 | 54372 | break; |
54069 | 54373 | } |
54070 | - case 18446744073709549333LLU: // 99999999aU''''''''''''''' | |
54374 | + case 18446744073709549320LLU: // 99999999aH''''''''''''''' | |
54071 | 54375 | { |
54072 | 54376 | // ACCUMULATE ARGUMENTS - BEGIN |
54073 | 54377 | { |
@@ -54075,7 +54379,7 @@ | ||
54075 | 54379 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
54076 | 54380 | } |
54077 | 54381 | // ACCUMULATE ARGUMENTS - END |
54078 | - uint64_t return_to = 18446744073709549332LLU; | |
54382 | + uint64_t return_to = 18446744073709549319LLU; | |
54079 | 54383 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
54080 | 54384 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
54081 | 54385 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -54084,7 +54388,7 @@ | ||
54084 | 54388 | state.addr = 839519665163075584LLU; // skip______ |
54085 | 54389 | break; |
54086 | 54390 | } |
54087 | - case 18446744073709549332LLU: // 99999999aT''''''''''''''' | |
54391 | + case 18446744073709549319LLU: // 99999999aG''''''''''''''' | |
54088 | 54392 | { |
54089 | 54393 | matchid(",", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU))); |
54090 | 54394 | fprintf(stdout, "%s", " % "); |
@@ -54094,7 +54398,7 @@ | ||
54094 | 54398 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
54095 | 54399 | } |
54096 | 54400 | // ACCUMULATE ARGUMENTS - END |
54097 | - uint64_t return_to = 18446744073709549331LLU; | |
54401 | + uint64_t return_to = 18446744073709549318LLU; | |
54098 | 54402 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
54099 | 54403 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
54100 | 54404 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -54103,7 +54407,7 @@ | ||
54103 | 54407 | state.addr = 839519665163075584LLU; // skip______ |
54104 | 54408 | break; |
54105 | 54409 | } |
54106 | - case 18446744073709549331LLU: // 99999999aS''''''''''''''' | |
54410 | + case 18446744073709549318LLU: // 99999999aF''''''''''''''' | |
54107 | 54411 | { |
54108 | 54412 | |
54109 | 54413 | *LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU))); |
@@ -54125,7 +54429,7 @@ | ||
54125 | 54429 | LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
54126 | 54430 | } |
54127 | 54431 | // ACCUMULATE ARGUMENTS - END |
54128 | - uint64_t return_to = 18446744073709549330LLU; | |
54432 | + uint64_t return_to = 18446744073709549317LLU; | |
54129 | 54433 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
54130 | 54434 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
54131 | 54435 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -54134,7 +54438,7 @@ | ||
54134 | 54438 | state.addr = 23446349213393492LLU; // ASSERTINIT |
54135 | 54439 | break; |
54136 | 54440 | } |
54137 | - case 18446744073709549330LLU: // 99999999aR''''''''''''''' | |
54441 | + case 18446744073709549317LLU: // 99999999aE''''''''''''''' | |
54138 | 54442 | { |
54139 | 54443 | { |
54140 | 54444 | uint64_t arg = 0; |
@@ -54213,7 +54517,7 @@ | ||
54213 | 54517 | LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
54214 | 54518 | } |
54215 | 54519 | // ACCUMULATE ARGUMENTS - END |
54216 | - uint64_t return_to = 18446744073709549329LLU; | |
54520 | + uint64_t return_to = 18446744073709549316LLU; | |
54217 | 54521 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)); |
54218 | 54522 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
54219 | 54523 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -54222,7 +54526,7 @@ | ||
54222 | 54526 | state.addr = 293363126232490310LLU; // PROCVARREF |
54223 | 54527 | break; |
54224 | 54528 | } |
54225 | - case 18446744073709549329LLU: // 99999999aQ''''''''''''''' | |
54529 | + case 18446744073709549316LLU: // 99999999aD''''''''''''''' | |
54226 | 54530 | { |
54227 | 54531 | // variable u64 initialize goes out of scope |
54228 | 54532 | // emitted destructur for type u64 |
@@ -54243,7 +54547,7 @@ | ||
54243 | 54547 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
54244 | 54548 | } |
54245 | 54549 | // ACCUMULATE ARGUMENTS - END |
54246 | - uint64_t return_to = 18446744073709549328LLU; | |
54550 | + uint64_t return_to = 18446744073709549315LLU; | |
54247 | 54551 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
54248 | 54552 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
54249 | 54553 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -54252,7 +54556,7 @@ | ||
54252 | 54556 | state.addr = 517555565476695680LLU; // assertu64_ |
54253 | 54557 | break; |
54254 | 54558 | } |
54255 | - case 18446744073709549328LLU: // 99999999aP''''''''''''''' | |
54559 | + case 18446744073709549315LLU: // 99999999aC''''''''''''''' | |
54256 | 54560 | { |
54257 | 54561 | // ACCUMULATE ARGUMENTS - BEGIN |
54258 | 54562 | { |
@@ -54260,7 +54564,7 @@ | ||
54260 | 54564 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
54261 | 54565 | } |
54262 | 54566 | // ACCUMULATE ARGUMENTS - END |
54263 | - uint64_t return_to = 18446744073709549327LLU; | |
54567 | + uint64_t return_to = 18446744073709549314LLU; | |
54264 | 54568 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
54265 | 54569 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
54266 | 54570 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -54269,7 +54573,7 @@ | ||
54269 | 54573 | state.addr = 839519665163075584LLU; // skip______ |
54270 | 54574 | break; |
54271 | 54575 | } |
54272 | - case 18446744073709549327LLU: // 99999999aO''''''''''''''' | |
54576 | + case 18446744073709549314LLU: // 99999999aB''''''''''''''' | |
54273 | 54577 | { |
54274 | 54578 | matchid(")", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU))); |
54275 | 54579 | fprintf(stdout, "%s", ";"); |
@@ -54281,7 +54585,7 @@ | ||
54281 | 54585 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
54282 | 54586 | } |
54283 | 54587 | // ACCUMULATE ARGUMENTS - END |
54284 | - uint64_t return_to = 18446744073709549326LLU; | |
54588 | + uint64_t return_to = 18446744073709549313LLU; | |
54285 | 54589 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
54286 | 54590 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
54287 | 54591 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -54290,7 +54594,7 @@ | ||
54290 | 54594 | state.addr = 18446744073709551534LLU; // 999999998s''''''''''''''' |
54291 | 54595 | break; |
54292 | 54596 | } |
54293 | - case 18446744073709549326LLU: // 99999999aN''''''''''''''' | |
54597 | + case 18446744073709549313LLU: // 99999999aA''''''''''''''' | |
54294 | 54598 | { |
54295 | 54599 | (void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference single____ at 21 |
54296 | 54600 | // variable type______ type______ goes out of scope |
@@ -54301,7 +54605,7 @@ | ||
54301 | 54605 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
54302 | 54606 | } |
54303 | 54607 | // ACCUMULATE ARGUMENTS - END |
54304 | - uint64_t return_to = 18446744073709549325LLU; | |
54608 | + uint64_t return_to = 18446744073709549312LLU; | |
54305 | 54609 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
54306 | 54610 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
54307 | 54611 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -54310,7 +54614,7 @@ | ||
54310 | 54614 | state.addr = 18446744073709551573LLU; // 999999999U''''''''''''''' |
54311 | 54615 | break; |
54312 | 54616 | } |
54313 | - case 18446744073709549325LLU: // 99999999aM''''''''''''''' | |
54617 | + case 18446744073709549312LLU: // 99999999a_''''''''''''''' | |
54314 | 54618 | { |
54315 | 54619 | (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type______ at 20 |
54316 | 54620 | // variable u64 mutable___ goes out of scope |
@@ -54322,10 +54626,10 @@ | ||
54322 | 54626 | // variable u64 id________ goes out of scope |
54323 | 54627 | // emitted destructur for type u64 |
54324 | 54628 | (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id________ at 17 |
54325 | - state.addr = 18446744073709549343LLU; // 99999999ad''''''''''''''' | |
54629 | + state.addr = 18446744073709549330LLU; // 99999999aR''''''''''''''' | |
54326 | 54630 | break; |
54327 | 54631 | } |
54328 | - case 18446744073709549344LLU: // 99999999ae''''''''''''''' | |
54632 | + case 18446744073709549331LLU: // 99999999aS''''''''''''''' | |
54329 | 54633 | { |
54330 | 54634 | |
54331 | 54635 | *LOCAL_ACCESS(heap.data, 16LLU, 15LLU) = 589056757511225344; |
@@ -54336,11 +54640,11 @@ | ||
54336 | 54640 | LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
54337 | 54641 | } |
54338 | 54642 | *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 0LLU)); |
54339 | - state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549324LLU : 18446744073709549323LLU; | |
54643 | + state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549311LLU : 18446744073709549310LLU; | |
54340 | 54644 | (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 17 |
54341 | 54645 | break; |
54342 | 54646 | } |
54343 | - case 18446744073709549324LLU: // 99999999aL''''''''''''''' | |
54647 | + case 18446744073709549311LLU: // 99999999$9''''''''''''''' | |
54344 | 54648 | { |
54345 | 54649 | { |
54346 | 54650 | uint64_t arg = 0; |
@@ -54367,7 +54671,7 @@ | ||
54367 | 54671 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
54368 | 54672 | } |
54369 | 54673 | // ACCUMULATE ARGUMENTS - END |
54370 | - uint64_t return_to = 18446744073709549321LLU; | |
54674 | + uint64_t return_to = 18446744073709549308LLU; | |
54371 | 54675 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
54372 | 54676 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
54373 | 54677 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -54376,7 +54680,7 @@ | ||
54376 | 54680 | state.addr = 861504796319285248LLU; // typeu64___ |
54377 | 54681 | break; |
54378 | 54682 | } |
54379 | - case 18446744073709549321LLU: // 99999999aI''''''''''''''' | |
54683 | + case 18446744073709549308LLU: // 99999999$6''''''''''''''' | |
54380 | 54684 | { |
54381 | 54685 | { |
54382 | 54686 | uint64_t arg = 0; |
@@ -54401,7 +54705,7 @@ | ||
54401 | 54705 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
54402 | 54706 | } |
54403 | 54707 | // ACCUMULATE ARGUMENTS - END |
54404 | - uint64_t return_to = 18446744073709549319LLU; | |
54708 | + uint64_t return_to = 18446744073709549306LLU; | |
54405 | 54709 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
54406 | 54710 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
54407 | 54711 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -54410,7 +54714,7 @@ | ||
54410 | 54714 | state.addr = 861504796319285248LLU; // typeu64___ |
54411 | 54715 | break; |
54412 | 54716 | } |
54413 | - case 18446744073709549319LLU: // 99999999aG''''''''''''''' | |
54717 | + case 18446744073709549306LLU: // 99999999$4''''''''''''''' | |
54414 | 54718 | { |
54415 | 54719 | { |
54416 | 54720 | uint64_t exchange = LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 23*/; |
@@ -54430,7 +54734,7 @@ | ||
54430 | 54734 | LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
54431 | 54735 | } |
54432 | 54736 | // ACCUMULATE ARGUMENTS - END |
54433 | - uint64_t return_to = 18446744073709549320LLU; | |
54737 | + uint64_t return_to = 18446744073709549307LLU; | |
54434 | 54738 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
54435 | 54739 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
54436 | 54740 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -54439,7 +54743,7 @@ | ||
54439 | 54743 | state.addr = 819859607768530944LLU; // resdest___ |
54440 | 54744 | break; |
54441 | 54745 | } |
54442 | - case 18446744073709549320LLU: // 99999999aH''''''''''''''' | |
54746 | + case 18446744073709549307LLU: // 99999999$5''''''''''''''' | |
54443 | 54747 | { |
54444 | 54748 | // ACCUMULATE ARGUMENTS - BEGIN |
54445 | 54749 | { |
@@ -54459,7 +54763,7 @@ | ||
54459 | 54763 | LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
54460 | 54764 | } |
54461 | 54765 | // ACCUMULATE ARGUMENTS - END |
54462 | - uint64_t return_to = 18446744073709549318LLU; | |
54766 | + uint64_t return_to = 18446744073709549305LLU; | |
54463 | 54767 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
54464 | 54768 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
54465 | 54769 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -54468,7 +54772,7 @@ | ||
54468 | 54772 | state.addr = 819857494882385920LLU; // res_u64___ |
54469 | 54773 | break; |
54470 | 54774 | } |
54471 | - case 18446744073709549318LLU: // 99999999aF''''''''''''''' | |
54775 | + case 18446744073709549305LLU: // 99999999$3''''''''''''''' | |
54472 | 54776 | { |
54473 | 54777 | // ACCUMULATE ARGUMENTS - BEGIN |
54474 | 54778 | { |
@@ -54476,7 +54780,7 @@ | ||
54476 | 54780 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
54477 | 54781 | } |
54478 | 54782 | // ACCUMULATE ARGUMENTS - END |
54479 | - uint64_t return_to = 18446744073709549317LLU; | |
54783 | + uint64_t return_to = 18446744073709549304LLU; | |
54480 | 54784 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
54481 | 54785 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
54482 | 54786 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -54485,7 +54789,7 @@ | ||
54485 | 54789 | state.addr = 839519665163075584LLU; // skip______ |
54486 | 54790 | break; |
54487 | 54791 | } |
54488 | - case 18446744073709549317LLU: // 99999999aE''''''''''''''' | |
54792 | + case 18446744073709549304LLU: // 99999999$2''''''''''''''' | |
54489 | 54793 | { |
54490 | 54794 | matchid("(", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU))); |
54491 | 54795 | fprintf(stdout, "%s", "\n "); |
@@ -54511,7 +54815,7 @@ | ||
54511 | 54815 | LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
54512 | 54816 | } |
54513 | 54817 | // ACCUMULATE ARGUMENTS - END |
54514 | - uint64_t return_to = 18446744073709549316LLU; | |
54818 | + uint64_t return_to = 18446744073709549303LLU; | |
54515 | 54819 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)); |
54516 | 54820 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
54517 | 54821 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -54520,7 +54824,7 @@ | ||
54520 | 54824 | state.addr = 587881357514113024LLU; // emitpar___ |
54521 | 54825 | break; |
54522 | 54826 | } |
54523 | - case 18446744073709549316LLU: // 99999999aD''''''''''''''' | |
54827 | + case 18446744073709549303LLU: // 99999999$1''''''''''''''' | |
54524 | 54828 | { |
54525 | 54829 | fprintf(stdout, "%s", " = "); |
54526 | 54830 | // ACCUMULATE ARGUMENTS - BEGIN |
@@ -54529,7 +54833,7 @@ | ||
54529 | 54833 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
54530 | 54834 | } |
54531 | 54835 | // ACCUMULATE ARGUMENTS - END |
54532 | - uint64_t return_to = 18446744073709549315LLU; | |
54836 | + uint64_t return_to = 18446744073709549302LLU; | |
54533 | 54837 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
54534 | 54838 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
54535 | 54839 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -54538,7 +54842,7 @@ | ||
54538 | 54842 | state.addr = 839519665163075584LLU; // skip______ |
54539 | 54843 | break; |
54540 | 54844 | } |
54541 | - case 18446744073709549315LLU: // 99999999aC''''''''''''''' | |
54845 | + case 18446744073709549302LLU: // 99999999$0''''''''''''''' | |
54542 | 54846 | { |
54543 | 54847 | |
54544 | 54848 | *LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU))); |
@@ -54560,7 +54864,7 @@ | ||
54560 | 54864 | LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
54561 | 54865 | } |
54562 | 54866 | // ACCUMULATE ARGUMENTS - END |
54563 | - uint64_t return_to = 18446744073709549314LLU; | |
54867 | + uint64_t return_to = 18446744073709549301LLU; | |
54564 | 54868 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
54565 | 54869 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
54566 | 54870 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -54569,7 +54873,7 @@ | ||
54569 | 54873 | state.addr = 23446349213393492LLU; // ASSERTINIT |
54570 | 54874 | break; |
54571 | 54875 | } |
54572 | - case 18446744073709549314LLU: // 99999999aB''''''''''''''' | |
54876 | + case 18446744073709549301LLU: // 99999999$z''''''''''''''' | |
54573 | 54877 | { |
54574 | 54878 | { |
54575 | 54879 | uint64_t arg = 0; |
@@ -54648,7 +54952,7 @@ | ||
54648 | 54952 | LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
54649 | 54953 | } |
54650 | 54954 | // ACCUMULATE ARGUMENTS - END |
54651 | - uint64_t return_to = 18446744073709549313LLU; | |
54955 | + uint64_t return_to = 18446744073709549300LLU; | |
54652 | 54956 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)); |
54653 | 54957 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
54654 | 54958 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -54657,7 +54961,7 @@ | ||
54657 | 54961 | state.addr = 293363126232490310LLU; // PROCVARREF |
54658 | 54962 | break; |
54659 | 54963 | } |
54660 | - case 18446744073709549313LLU: // 99999999aA''''''''''''''' | |
54964 | + case 18446744073709549300LLU: // 99999999$y''''''''''''''' | |
54661 | 54965 | { |
54662 | 54966 | // variable u64 initialize goes out of scope |
54663 | 54967 | // emitted destructur for type u64 |
@@ -54678,7 +54982,7 @@ | ||
54678 | 54982 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
54679 | 54983 | } |
54680 | 54984 | // ACCUMULATE ARGUMENTS - END |
54681 | - uint64_t return_to = 18446744073709549312LLU; | |
54985 | + uint64_t return_to = 18446744073709549299LLU; | |
54682 | 54986 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
54683 | 54987 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
54684 | 54988 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -54687,7 +54991,7 @@ | ||
54687 | 54991 | state.addr = 517555565476695680LLU; // assertu64_ |
54688 | 54992 | break; |
54689 | 54993 | } |
54690 | - case 18446744073709549312LLU: // 99999999a_''''''''''''''' | |
54994 | + case 18446744073709549299LLU: // 99999999$x''''''''''''''' | |
54691 | 54995 | { |
54692 | 54996 | // ACCUMULATE ARGUMENTS - BEGIN |
54693 | 54997 | { |
@@ -54695,7 +54999,7 @@ | ||
54695 | 54999 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
54696 | 55000 | } |
54697 | 55001 | // ACCUMULATE ARGUMENTS - END |
54698 | - uint64_t return_to = 18446744073709549311LLU; | |
55002 | + uint64_t return_to = 18446744073709549298LLU; | |
54699 | 55003 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
54700 | 55004 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
54701 | 55005 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -54704,7 +55008,7 @@ | ||
54704 | 55008 | state.addr = 839519665163075584LLU; // skip______ |
54705 | 55009 | break; |
54706 | 55010 | } |
54707 | - case 18446744073709549311LLU: // 99999999$9''''''''''''''' | |
55011 | + case 18446744073709549298LLU: // 99999999$w''''''''''''''' | |
54708 | 55012 | { |
54709 | 55013 | matchid(",", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU))); |
54710 | 55014 | fprintf(stdout, "%s", " == "); |
@@ -54714,7 +55018,7 @@ | ||
54714 | 55018 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
54715 | 55019 | } |
54716 | 55020 | // ACCUMULATE ARGUMENTS - END |
54717 | - uint64_t return_to = 18446744073709549310LLU; | |
55021 | + uint64_t return_to = 18446744073709549297LLU; | |
54718 | 55022 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
54719 | 55023 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
54720 | 55024 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -54723,7 +55027,7 @@ | ||
54723 | 55027 | state.addr = 839519665163075584LLU; // skip______ |
54724 | 55028 | break; |
54725 | 55029 | } |
54726 | - case 18446744073709549310LLU: // 99999999$8''''''''''''''' | |
55030 | + case 18446744073709549297LLU: // 99999999$v''''''''''''''' | |
54727 | 55031 | { |
54728 | 55032 | |
54729 | 55033 | *LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU))); |
@@ -54745,7 +55049,7 @@ | ||
54745 | 55049 | LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
54746 | 55050 | } |
54747 | 55051 | // ACCUMULATE ARGUMENTS - END |
54748 | - uint64_t return_to = 18446744073709549309LLU; | |
55052 | + uint64_t return_to = 18446744073709549296LLU; | |
54749 | 55053 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
54750 | 55054 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
54751 | 55055 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -54754,7 +55058,7 @@ | ||
54754 | 55058 | state.addr = 23446349213393492LLU; // ASSERTINIT |
54755 | 55059 | break; |
54756 | 55060 | } |
54757 | - case 18446744073709549309LLU: // 99999999$7''''''''''''''' | |
55061 | + case 18446744073709549296LLU: // 99999999$u''''''''''''''' | |
54758 | 55062 | { |
54759 | 55063 | { |
54760 | 55064 | uint64_t arg = 0; |
@@ -54833,7 +55137,7 @@ | ||
54833 | 55137 | LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
54834 | 55138 | } |
54835 | 55139 | // ACCUMULATE ARGUMENTS - END |
54836 | - uint64_t return_to = 18446744073709549308LLU; | |
55140 | + uint64_t return_to = 18446744073709549295LLU; | |
54837 | 55141 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)); |
54838 | 55142 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
54839 | 55143 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -54842,7 +55146,7 @@ | ||
54842 | 55146 | state.addr = 293363126232490310LLU; // PROCVARREF |
54843 | 55147 | break; |
54844 | 55148 | } |
54845 | - case 18446744073709549308LLU: // 99999999$6''''''''''''''' | |
55149 | + case 18446744073709549295LLU: // 99999999$t''''''''''''''' | |
54846 | 55150 | { |
54847 | 55151 | // variable u64 initialize goes out of scope |
54848 | 55152 | // emitted destructur for type u64 |
@@ -54863,7 +55167,7 @@ | ||
54863 | 55167 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
54864 | 55168 | } |
54865 | 55169 | // ACCUMULATE ARGUMENTS - END |
54866 | - uint64_t return_to = 18446744073709549307LLU; | |
55170 | + uint64_t return_to = 18446744073709549294LLU; | |
54867 | 55171 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
54868 | 55172 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
54869 | 55173 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -54872,7 +55176,7 @@ | ||
54872 | 55176 | state.addr = 517555565476695680LLU; // assertu64_ |
54873 | 55177 | break; |
54874 | 55178 | } |
54875 | - case 18446744073709549307LLU: // 99999999$5''''''''''''''' | |
55179 | + case 18446744073709549294LLU: // 99999999$s''''''''''''''' | |
54876 | 55180 | { |
54877 | 55181 | // ACCUMULATE ARGUMENTS - BEGIN |
54878 | 55182 | { |
@@ -54880,7 +55184,7 @@ | ||
54880 | 55184 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
54881 | 55185 | } |
54882 | 55186 | // ACCUMULATE ARGUMENTS - END |
54883 | - uint64_t return_to = 18446744073709549306LLU; | |
55187 | + uint64_t return_to = 18446744073709549293LLU; | |
54884 | 55188 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
54885 | 55189 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
54886 | 55190 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -54889,7 +55193,7 @@ | ||
54889 | 55193 | state.addr = 839519665163075584LLU; // skip______ |
54890 | 55194 | break; |
54891 | 55195 | } |
54892 | - case 18446744073709549306LLU: // 99999999$4''''''''''''''' | |
55196 | + case 18446744073709549293LLU: // 99999999$r''''''''''''''' | |
54893 | 55197 | { |
54894 | 55198 | matchid(")", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU))); |
54895 | 55199 | fprintf(stdout, "%s", ";"); |
@@ -54901,7 +55205,7 @@ | ||
54901 | 55205 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
54902 | 55206 | } |
54903 | 55207 | // ACCUMULATE ARGUMENTS - END |
54904 | - uint64_t return_to = 18446744073709549305LLU; | |
55208 | + uint64_t return_to = 18446744073709549292LLU; | |
54905 | 55209 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
54906 | 55210 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
54907 | 55211 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -54910,7 +55214,7 @@ | ||
54910 | 55214 | state.addr = 18446744073709551534LLU; // 999999998s''''''''''''''' |
54911 | 55215 | break; |
54912 | 55216 | } |
54913 | - case 18446744073709549305LLU: // 99999999$3''''''''''''''' | |
55217 | + case 18446744073709549292LLU: // 99999999$q''''''''''''''' | |
54914 | 55218 | { |
54915 | 55219 | (void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference single____ at 21 |
54916 | 55220 | // variable type______ type______ goes out of scope |
@@ -54921,7 +55225,7 @@ | ||
54921 | 55225 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
54922 | 55226 | } |
54923 | 55227 | // ACCUMULATE ARGUMENTS - END |
54924 | - uint64_t return_to = 18446744073709549304LLU; | |
55228 | + uint64_t return_to = 18446744073709549291LLU; | |
54925 | 55229 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
54926 | 55230 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
54927 | 55231 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -54930,7 +55234,7 @@ | ||
54930 | 55234 | state.addr = 18446744073709551573LLU; // 999999999U''''''''''''''' |
54931 | 55235 | break; |
54932 | 55236 | } |
54933 | - case 18446744073709549304LLU: // 99999999$2''''''''''''''' | |
55237 | + case 18446744073709549291LLU: // 99999999$p''''''''''''''' | |
54934 | 55238 | { |
54935 | 55239 | (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type______ at 20 |
54936 | 55240 | // variable u64 mutable___ goes out of scope |
@@ -54942,10 +55246,10 @@ | ||
54942 | 55246 | // variable u64 id________ goes out of scope |
54943 | 55247 | // emitted destructur for type u64 |
54944 | 55248 | (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id________ at 17 |
54945 | - state.addr = 18446744073709549322LLU; // 99999999aJ''''''''''''''' | |
55249 | + state.addr = 18446744073709549309LLU; // 99999999$7''''''''''''''' | |
54946 | 55250 | break; |
54947 | 55251 | } |
54948 | - case 18446744073709549323LLU: // 99999999aK''''''''''''''' | |
55252 | + case 18446744073709549310LLU: // 99999999$8''''''''''''''' | |
54949 | 55253 | { |
54950 | 55254 | |
54951 | 55255 | *LOCAL_ACCESS(heap.data, 16LLU, 15LLU) = 747791052189990912; |
@@ -54956,11 +55260,11 @@ | ||
54956 | 55260 | LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
54957 | 55261 | } |
54958 | 55262 | *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 0LLU)); |
54959 | - state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549303LLU : 18446744073709549302LLU; | |
55263 | + state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549290LLU : 18446744073709549289LLU; | |
54960 | 55264 | (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 17 |
54961 | 55265 | break; |
54962 | 55266 | } |
54963 | - case 18446744073709549303LLU: // 99999999$1''''''''''''''' | |
55267 | + case 18446744073709549290LLU: // 99999999$o''''''''''''''' | |
54964 | 55268 | { |
54965 | 55269 | { |
54966 | 55270 | uint64_t arg = 0; |
@@ -54987,7 +55291,7 @@ | ||
54987 | 55291 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
54988 | 55292 | } |
54989 | 55293 | // ACCUMULATE ARGUMENTS - END |
54990 | - uint64_t return_to = 18446744073709549300LLU; | |
55294 | + uint64_t return_to = 18446744073709549287LLU; | |
54991 | 55295 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
54992 | 55296 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
54993 | 55297 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -54996,7 +55300,7 @@ | ||
54996 | 55300 | state.addr = 861504796319285248LLU; // typeu64___ |
54997 | 55301 | break; |
54998 | 55302 | } |
54999 | - case 18446744073709549300LLU: // 99999999$y''''''''''''''' | |
55303 | + case 18446744073709549287LLU: // 99999999$l''''''''''''''' | |
55000 | 55304 | { |
55001 | 55305 | { |
55002 | 55306 | uint64_t arg = 0; |
@@ -55021,7 +55325,7 @@ | ||
55021 | 55325 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
55022 | 55326 | } |
55023 | 55327 | // ACCUMULATE ARGUMENTS - END |
55024 | - uint64_t return_to = 18446744073709549298LLU; | |
55328 | + uint64_t return_to = 18446744073709549285LLU; | |
55025 | 55329 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
55026 | 55330 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
55027 | 55331 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -55030,7 +55334,7 @@ | ||
55030 | 55334 | state.addr = 861504796319285248LLU; // typeu64___ |
55031 | 55335 | break; |
55032 | 55336 | } |
55033 | - case 18446744073709549298LLU: // 99999999$w''''''''''''''' | |
55337 | + case 18446744073709549285LLU: // 99999999$j''''''''''''''' | |
55034 | 55338 | { |
55035 | 55339 | { |
55036 | 55340 | uint64_t exchange = LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 23*/; |
@@ -55050,7 +55354,7 @@ | ||
55050 | 55354 | LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
55051 | 55355 | } |
55052 | 55356 | // ACCUMULATE ARGUMENTS - END |
55053 | - uint64_t return_to = 18446744073709549299LLU; | |
55357 | + uint64_t return_to = 18446744073709549286LLU; | |
55054 | 55358 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
55055 | 55359 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
55056 | 55360 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -55059,7 +55363,7 @@ | ||
55059 | 55363 | state.addr = 819859607768530944LLU; // resdest___ |
55060 | 55364 | break; |
55061 | 55365 | } |
55062 | - case 18446744073709549299LLU: // 99999999$x''''''''''''''' | |
55366 | + case 18446744073709549286LLU: // 99999999$k''''''''''''''' | |
55063 | 55367 | { |
55064 | 55368 | // ACCUMULATE ARGUMENTS - BEGIN |
55065 | 55369 | { |
@@ -55079,7 +55383,7 @@ | ||
55079 | 55383 | LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
55080 | 55384 | } |
55081 | 55385 | // ACCUMULATE ARGUMENTS - END |
55082 | - uint64_t return_to = 18446744073709549297LLU; | |
55386 | + uint64_t return_to = 18446744073709549284LLU; | |
55083 | 55387 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
55084 | 55388 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
55085 | 55389 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -55088,7 +55392,7 @@ | ||
55088 | 55392 | state.addr = 819857494882385920LLU; // res_u64___ |
55089 | 55393 | break; |
55090 | 55394 | } |
55091 | - case 18446744073709549297LLU: // 99999999$v''''''''''''''' | |
55395 | + case 18446744073709549284LLU: // 99999999$i''''''''''''''' | |
55092 | 55396 | { |
55093 | 55397 | // ACCUMULATE ARGUMENTS - BEGIN |
55094 | 55398 | { |
@@ -55096,7 +55400,7 @@ | ||
55096 | 55400 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
55097 | 55401 | } |
55098 | 55402 | // ACCUMULATE ARGUMENTS - END |
55099 | - uint64_t return_to = 18446744073709549296LLU; | |
55403 | + uint64_t return_to = 18446744073709549283LLU; | |
55100 | 55404 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
55101 | 55405 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
55102 | 55406 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -55105,7 +55409,7 @@ | ||
55105 | 55409 | state.addr = 839519665163075584LLU; // skip______ |
55106 | 55410 | break; |
55107 | 55411 | } |
55108 | - case 18446744073709549296LLU: // 99999999$u''''''''''''''' | |
55412 | + case 18446744073709549283LLU: // 99999999$h''''''''''''''' | |
55109 | 55413 | { |
55110 | 55414 | matchid("(", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU))); |
55111 | 55415 | fprintf(stdout, "%s", "\n "); |
@@ -55131,7 +55435,7 @@ | ||
55131 | 55435 | LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
55132 | 55436 | } |
55133 | 55437 | // ACCUMULATE ARGUMENTS - END |
55134 | - uint64_t return_to = 18446744073709549295LLU; | |
55438 | + uint64_t return_to = 18446744073709549282LLU; | |
55135 | 55439 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)); |
55136 | 55440 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
55137 | 55441 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -55140,7 +55444,7 @@ | ||
55140 | 55444 | state.addr = 587881357514113024LLU; // emitpar___ |
55141 | 55445 | break; |
55142 | 55446 | } |
55143 | - case 18446744073709549295LLU: // 99999999$t''''''''''''''' | |
55447 | + case 18446744073709549282LLU: // 99999999$g''''''''''''''' | |
55144 | 55448 | { |
55145 | 55449 | fprintf(stdout, "%s", " = "); |
55146 | 55450 | // ACCUMULATE ARGUMENTS - BEGIN |
@@ -55149,7 +55453,7 @@ | ||
55149 | 55453 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
55150 | 55454 | } |
55151 | 55455 | // ACCUMULATE ARGUMENTS - END |
55152 | - uint64_t return_to = 18446744073709549294LLU; | |
55456 | + uint64_t return_to = 18446744073709549281LLU; | |
55153 | 55457 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
55154 | 55458 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
55155 | 55459 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -55158,7 +55462,7 @@ | ||
55158 | 55462 | state.addr = 839519665163075584LLU; // skip______ |
55159 | 55463 | break; |
55160 | 55464 | } |
55161 | - case 18446744073709549294LLU: // 99999999$s''''''''''''''' | |
55465 | + case 18446744073709549281LLU: // 99999999$f''''''''''''''' | |
55162 | 55466 | { |
55163 | 55467 | |
55164 | 55468 | *LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU))); |
@@ -55180,7 +55484,7 @@ | ||
55180 | 55484 | LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
55181 | 55485 | } |
55182 | 55486 | // ACCUMULATE ARGUMENTS - END |
55183 | - uint64_t return_to = 18446744073709549293LLU; | |
55487 | + uint64_t return_to = 18446744073709549280LLU; | |
55184 | 55488 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
55185 | 55489 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
55186 | 55490 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -55189,7 +55493,7 @@ | ||
55189 | 55493 | state.addr = 23446349213393492LLU; // ASSERTINIT |
55190 | 55494 | break; |
55191 | 55495 | } |
55192 | - case 18446744073709549293LLU: // 99999999$r''''''''''''''' | |
55496 | + case 18446744073709549280LLU: // 99999999$e''''''''''''''' | |
55193 | 55497 | { |
55194 | 55498 | { |
55195 | 55499 | uint64_t arg = 0; |
@@ -55268,7 +55572,7 @@ | ||
55268 | 55572 | LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
55269 | 55573 | } |
55270 | 55574 | // ACCUMULATE ARGUMENTS - END |
55271 | - uint64_t return_to = 18446744073709549292LLU; | |
55575 | + uint64_t return_to = 18446744073709549279LLU; | |
55272 | 55576 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)); |
55273 | 55577 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
55274 | 55578 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -55277,7 +55581,7 @@ | ||
55277 | 55581 | state.addr = 293363126232490310LLU; // PROCVARREF |
55278 | 55582 | break; |
55279 | 55583 | } |
55280 | - case 18446744073709549292LLU: // 99999999$q''''''''''''''' | |
55584 | + case 18446744073709549279LLU: // 99999999$d''''''''''''''' | |
55281 | 55585 | { |
55282 | 55586 | // variable u64 initialize goes out of scope |
55283 | 55587 | // emitted destructur for type u64 |
@@ -55298,7 +55602,7 @@ | ||
55298 | 55602 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
55299 | 55603 | } |
55300 | 55604 | // ACCUMULATE ARGUMENTS - END |
55301 | - uint64_t return_to = 18446744073709549291LLU; | |
55605 | + uint64_t return_to = 18446744073709549278LLU; | |
55302 | 55606 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
55303 | 55607 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
55304 | 55608 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -55307,7 +55611,7 @@ | ||
55307 | 55611 | state.addr = 517555565476695680LLU; // assertu64_ |
55308 | 55612 | break; |
55309 | 55613 | } |
55310 | - case 18446744073709549291LLU: // 99999999$p''''''''''''''' | |
55614 | + case 18446744073709549278LLU: // 99999999$c''''''''''''''' | |
55311 | 55615 | { |
55312 | 55616 | // ACCUMULATE ARGUMENTS - BEGIN |
55313 | 55617 | { |
@@ -55315,7 +55619,7 @@ | ||
55315 | 55619 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
55316 | 55620 | } |
55317 | 55621 | // ACCUMULATE ARGUMENTS - END |
55318 | - uint64_t return_to = 18446744073709549290LLU; | |
55622 | + uint64_t return_to = 18446744073709549277LLU; | |
55319 | 55623 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
55320 | 55624 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
55321 | 55625 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -55324,7 +55628,7 @@ | ||
55324 | 55628 | state.addr = 839519665163075584LLU; // skip______ |
55325 | 55629 | break; |
55326 | 55630 | } |
55327 | - case 18446744073709549290LLU: // 99999999$o''''''''''''''' | |
55631 | + case 18446744073709549277LLU: // 99999999$b''''''''''''''' | |
55328 | 55632 | { |
55329 | 55633 | matchid(",", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU))); |
55330 | 55634 | fprintf(stdout, "%s", " != "); |
@@ -55334,7 +55638,7 @@ | ||
55334 | 55638 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
55335 | 55639 | } |
55336 | 55640 | // ACCUMULATE ARGUMENTS - END |
55337 | - uint64_t return_to = 18446744073709549289LLU; | |
55641 | + uint64_t return_to = 18446744073709549276LLU; | |
55338 | 55642 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
55339 | 55643 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
55340 | 55644 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -55343,7 +55647,7 @@ | ||
55343 | 55647 | state.addr = 839519665163075584LLU; // skip______ |
55344 | 55648 | break; |
55345 | 55649 | } |
55346 | - case 18446744073709549289LLU: // 99999999$n''''''''''''''' | |
55650 | + case 18446744073709549276LLU: // 99999999$a''''''''''''''' | |
55347 | 55651 | { |
55348 | 55652 | |
55349 | 55653 | *LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU))); |
@@ -55365,7 +55669,7 @@ | ||
55365 | 55669 | LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
55366 | 55670 | } |
55367 | 55671 | // ACCUMULATE ARGUMENTS - END |
55368 | - uint64_t return_to = 18446744073709549288LLU; | |
55672 | + uint64_t return_to = 18446744073709549275LLU; | |
55369 | 55673 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
55370 | 55674 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
55371 | 55675 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -55374,7 +55678,7 @@ | ||
55374 | 55678 | state.addr = 23446349213393492LLU; // ASSERTINIT |
55375 | 55679 | break; |
55376 | 55680 | } |
55377 | - case 18446744073709549288LLU: // 99999999$m''''''''''''''' | |
55681 | + case 18446744073709549275LLU: // 99999999$$''''''''''''''' | |
55378 | 55682 | { |
55379 | 55683 | { |
55380 | 55684 | uint64_t arg = 0; |
@@ -55453,7 +55757,7 @@ | ||
55453 | 55757 | LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
55454 | 55758 | } |
55455 | 55759 | // ACCUMULATE ARGUMENTS - END |
55456 | - uint64_t return_to = 18446744073709549287LLU; | |
55760 | + uint64_t return_to = 18446744073709549274LLU; | |
55457 | 55761 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)); |
55458 | 55762 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
55459 | 55763 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -55462,7 +55766,7 @@ | ||
55462 | 55766 | state.addr = 293363126232490310LLU; // PROCVARREF |
55463 | 55767 | break; |
55464 | 55768 | } |
55465 | - case 18446744073709549287LLU: // 99999999$l''''''''''''''' | |
55769 | + case 18446744073709549274LLU: // 99999999$Z''''''''''''''' | |
55466 | 55770 | { |
55467 | 55771 | // variable u64 initialize goes out of scope |
55468 | 55772 | // emitted destructur for type u64 |
@@ -55483,7 +55787,7 @@ | ||
55483 | 55787 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
55484 | 55788 | } |
55485 | 55789 | // ACCUMULATE ARGUMENTS - END |
55486 | - uint64_t return_to = 18446744073709549286LLU; | |
55790 | + uint64_t return_to = 18446744073709549273LLU; | |
55487 | 55791 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
55488 | 55792 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
55489 | 55793 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -55492,7 +55796,7 @@ | ||
55492 | 55796 | state.addr = 517555565476695680LLU; // assertu64_ |
55493 | 55797 | break; |
55494 | 55798 | } |
55495 | - case 18446744073709549286LLU: // 99999999$k''''''''''''''' | |
55799 | + case 18446744073709549273LLU: // 99999999$Y''''''''''''''' | |
55496 | 55800 | { |
55497 | 55801 | // ACCUMULATE ARGUMENTS - BEGIN |
55498 | 55802 | { |
@@ -55500,7 +55804,7 @@ | ||
55500 | 55804 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
55501 | 55805 | } |
55502 | 55806 | // ACCUMULATE ARGUMENTS - END |
55503 | - uint64_t return_to = 18446744073709549285LLU; | |
55807 | + uint64_t return_to = 18446744073709549272LLU; | |
55504 | 55808 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
55505 | 55809 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
55506 | 55810 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -55509,7 +55813,7 @@ | ||
55509 | 55813 | state.addr = 839519665163075584LLU; // skip______ |
55510 | 55814 | break; |
55511 | 55815 | } |
55512 | - case 18446744073709549285LLU: // 99999999$j''''''''''''''' | |
55816 | + case 18446744073709549272LLU: // 99999999$X''''''''''''''' | |
55513 | 55817 | { |
55514 | 55818 | matchid(")", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU))); |
55515 | 55819 | fprintf(stdout, "%s", ";"); |
@@ -55521,7 +55825,7 @@ | ||
55521 | 55825 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
55522 | 55826 | } |
55523 | 55827 | // ACCUMULATE ARGUMENTS - END |
55524 | - uint64_t return_to = 18446744073709549284LLU; | |
55828 | + uint64_t return_to = 18446744073709549271LLU; | |
55525 | 55829 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
55526 | 55830 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
55527 | 55831 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -55530,7 +55834,7 @@ | ||
55530 | 55834 | state.addr = 18446744073709551534LLU; // 999999998s''''''''''''''' |
55531 | 55835 | break; |
55532 | 55836 | } |
55533 | - case 18446744073709549284LLU: // 99999999$i''''''''''''''' | |
55837 | + case 18446744073709549271LLU: // 99999999$W''''''''''''''' | |
55534 | 55838 | { |
55535 | 55839 | (void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference single____ at 21 |
55536 | 55840 | // variable type______ type______ goes out of scope |
@@ -55541,7 +55845,7 @@ | ||
55541 | 55845 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
55542 | 55846 | } |
55543 | 55847 | // ACCUMULATE ARGUMENTS - END |
55544 | - uint64_t return_to = 18446744073709549283LLU; | |
55848 | + uint64_t return_to = 18446744073709549270LLU; | |
55545 | 55849 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
55546 | 55850 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
55547 | 55851 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -55550,7 +55854,7 @@ | ||
55550 | 55854 | state.addr = 18446744073709551573LLU; // 999999999U''''''''''''''' |
55551 | 55855 | break; |
55552 | 55856 | } |
55553 | - case 18446744073709549283LLU: // 99999999$h''''''''''''''' | |
55857 | + case 18446744073709549270LLU: // 99999999$V''''''''''''''' | |
55554 | 55858 | { |
55555 | 55859 | (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type______ at 20 |
55556 | 55860 | // variable u64 mutable___ goes out of scope |
@@ -55562,10 +55866,10 @@ | ||
55562 | 55866 | // variable u64 id________ goes out of scope |
55563 | 55867 | // emitted destructur for type u64 |
55564 | 55868 | (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id________ at 17 |
55565 | - state.addr = 18446744073709549301LLU; // 99999999$z''''''''''''''' | |
55869 | + state.addr = 18446744073709549288LLU; // 99999999$m''''''''''''''' | |
55566 | 55870 | break; |
55567 | 55871 | } |
55568 | - case 18446744073709549302LLU: // 99999999$0''''''''''''''' | |
55872 | + case 18446744073709549289LLU: // 99999999$n''''''''''''''' | |
55569 | 55873 | { |
55570 | 55874 | |
55571 | 55875 | *LOCAL_ACCESS(heap.data, 16LLU, 15LLU) = 621690262623617024; |
@@ -55576,11 +55880,11 @@ | ||
55576 | 55880 | LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
55577 | 55881 | } |
55578 | 55882 | *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 0LLU)); |
55579 | - state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549282LLU : 18446744073709549281LLU; | |
55883 | + state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549269LLU : 18446744073709549268LLU; | |
55580 | 55884 | (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 17 |
55581 | 55885 | break; |
55582 | 55886 | } |
55583 | - case 18446744073709549282LLU: // 99999999$g''''''''''''''' | |
55887 | + case 18446744073709549269LLU: // 99999999$U''''''''''''''' | |
55584 | 55888 | { |
55585 | 55889 | { |
55586 | 55890 | uint64_t arg = 0; |
@@ -55607,7 +55911,7 @@ | ||
55607 | 55911 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
55608 | 55912 | } |
55609 | 55913 | // ACCUMULATE ARGUMENTS - END |
55610 | - uint64_t return_to = 18446744073709549279LLU; | |
55914 | + uint64_t return_to = 18446744073709549266LLU; | |
55611 | 55915 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
55612 | 55916 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
55613 | 55917 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -55616,7 +55920,7 @@ | ||
55616 | 55920 | state.addr = 861504796319285248LLU; // typeu64___ |
55617 | 55921 | break; |
55618 | 55922 | } |
55619 | - case 18446744073709549279LLU: // 99999999$d''''''''''''''' | |
55923 | + case 18446744073709549266LLU: // 99999999$R''''''''''''''' | |
55620 | 55924 | { |
55621 | 55925 | { |
55622 | 55926 | uint64_t arg = 0; |
@@ -55641,7 +55945,7 @@ | ||
55641 | 55945 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
55642 | 55946 | } |
55643 | 55947 | // ACCUMULATE ARGUMENTS - END |
55644 | - uint64_t return_to = 18446744073709549277LLU; | |
55948 | + uint64_t return_to = 18446744073709549264LLU; | |
55645 | 55949 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
55646 | 55950 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
55647 | 55951 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -55650,7 +55954,7 @@ | ||
55650 | 55954 | state.addr = 861504796319285248LLU; // typeu64___ |
55651 | 55955 | break; |
55652 | 55956 | } |
55653 | - case 18446744073709549277LLU: // 99999999$b''''''''''''''' | |
55957 | + case 18446744073709549264LLU: // 99999999$P''''''''''''''' | |
55654 | 55958 | { |
55655 | 55959 | { |
55656 | 55960 | uint64_t exchange = LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 23*/; |
@@ -55670,7 +55974,7 @@ | ||
55670 | 55974 | LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
55671 | 55975 | } |
55672 | 55976 | // ACCUMULATE ARGUMENTS - END |
55673 | - uint64_t return_to = 18446744073709549278LLU; | |
55977 | + uint64_t return_to = 18446744073709549265LLU; | |
55674 | 55978 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
55675 | 55979 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
55676 | 55980 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -55679,7 +55983,7 @@ | ||
55679 | 55983 | state.addr = 819859607768530944LLU; // resdest___ |
55680 | 55984 | break; |
55681 | 55985 | } |
55682 | - case 18446744073709549278LLU: // 99999999$c''''''''''''''' | |
55986 | + case 18446744073709549265LLU: // 99999999$Q''''''''''''''' | |
55683 | 55987 | { |
55684 | 55988 | // ACCUMULATE ARGUMENTS - BEGIN |
55685 | 55989 | { |
@@ -55699,7 +56003,7 @@ | ||
55699 | 56003 | LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
55700 | 56004 | } |
55701 | 56005 | // ACCUMULATE ARGUMENTS - END |
55702 | - uint64_t return_to = 18446744073709549276LLU; | |
56006 | + uint64_t return_to = 18446744073709549263LLU; | |
55703 | 56007 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
55704 | 56008 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
55705 | 56009 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -55708,7 +56012,7 @@ | ||
55708 | 56012 | state.addr = 819857494882385920LLU; // res_u64___ |
55709 | 56013 | break; |
55710 | 56014 | } |
55711 | - case 18446744073709549276LLU: // 99999999$a''''''''''''''' | |
56015 | + case 18446744073709549263LLU: // 99999999$O''''''''''''''' | |
55712 | 56016 | { |
55713 | 56017 | // ACCUMULATE ARGUMENTS - BEGIN |
55714 | 56018 | { |
@@ -55716,7 +56020,7 @@ | ||
55716 | 56020 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
55717 | 56021 | } |
55718 | 56022 | // ACCUMULATE ARGUMENTS - END |
55719 | - uint64_t return_to = 18446744073709549275LLU; | |
56023 | + uint64_t return_to = 18446744073709549262LLU; | |
55720 | 56024 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
55721 | 56025 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
55722 | 56026 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -55725,7 +56029,7 @@ | ||
55725 | 56029 | state.addr = 839519665163075584LLU; // skip______ |
55726 | 56030 | break; |
55727 | 56031 | } |
55728 | - case 18446744073709549275LLU: // 99999999$$''''''''''''''' | |
56032 | + case 18446744073709549262LLU: // 99999999$N''''''''''''''' | |
55729 | 56033 | { |
55730 | 56034 | matchid("(", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU))); |
55731 | 56035 | fprintf(stdout, "%s", "\n "); |
@@ -55751,7 +56055,7 @@ | ||
55751 | 56055 | LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
55752 | 56056 | } |
55753 | 56057 | // ACCUMULATE ARGUMENTS - END |
55754 | - uint64_t return_to = 18446744073709549274LLU; | |
56058 | + uint64_t return_to = 18446744073709549261LLU; | |
55755 | 56059 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)); |
55756 | 56060 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
55757 | 56061 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -55760,7 +56064,7 @@ | ||
55760 | 56064 | state.addr = 587881357514113024LLU; // emitpar___ |
55761 | 56065 | break; |
55762 | 56066 | } |
55763 | - case 18446744073709549274LLU: // 99999999$Z''''''''''''''' | |
56067 | + case 18446744073709549261LLU: // 99999999$M''''''''''''''' | |
55764 | 56068 | { |
55765 | 56069 | fprintf(stdout, "%s", " = "); |
55766 | 56070 | // ACCUMULATE ARGUMENTS - BEGIN |
@@ -55769,7 +56073,7 @@ | ||
55769 | 56073 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
55770 | 56074 | } |
55771 | 56075 | // ACCUMULATE ARGUMENTS - END |
55772 | - uint64_t return_to = 18446744073709549273LLU; | |
56076 | + uint64_t return_to = 18446744073709549260LLU; | |
55773 | 56077 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
55774 | 56078 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
55775 | 56079 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -55778,7 +56082,7 @@ | ||
55778 | 56082 | state.addr = 839519665163075584LLU; // skip______ |
55779 | 56083 | break; |
55780 | 56084 | } |
55781 | - case 18446744073709549273LLU: // 99999999$Y''''''''''''''' | |
56085 | + case 18446744073709549260LLU: // 99999999$L''''''''''''''' | |
55782 | 56086 | { |
55783 | 56087 | |
55784 | 56088 | *LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU))); |
@@ -55800,7 +56104,7 @@ | ||
55800 | 56104 | LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
55801 | 56105 | } |
55802 | 56106 | // ACCUMULATE ARGUMENTS - END |
55803 | - uint64_t return_to = 18446744073709549272LLU; | |
56107 | + uint64_t return_to = 18446744073709549259LLU; | |
55804 | 56108 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
55805 | 56109 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
55806 | 56110 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -55809,7 +56113,7 @@ | ||
55809 | 56113 | state.addr = 23446349213393492LLU; // ASSERTINIT |
55810 | 56114 | break; |
55811 | 56115 | } |
55812 | - case 18446744073709549272LLU: // 99999999$X''''''''''''''' | |
56116 | + case 18446744073709549259LLU: // 99999999$K''''''''''''''' | |
55813 | 56117 | { |
55814 | 56118 | { |
55815 | 56119 | uint64_t arg = 0; |
@@ -55888,7 +56192,7 @@ | ||
55888 | 56192 | LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
55889 | 56193 | } |
55890 | 56194 | // ACCUMULATE ARGUMENTS - END |
55891 | - uint64_t return_to = 18446744073709549271LLU; | |
56195 | + uint64_t return_to = 18446744073709549258LLU; | |
55892 | 56196 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)); |
55893 | 56197 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
55894 | 56198 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -55897,7 +56201,7 @@ | ||
55897 | 56201 | state.addr = 293363126232490310LLU; // PROCVARREF |
55898 | 56202 | break; |
55899 | 56203 | } |
55900 | - case 18446744073709549271LLU: // 99999999$W''''''''''''''' | |
56204 | + case 18446744073709549258LLU: // 99999999$J''''''''''''''' | |
55901 | 56205 | { |
55902 | 56206 | // variable u64 initialize goes out of scope |
55903 | 56207 | // emitted destructur for type u64 |
@@ -55918,7 +56222,7 @@ | ||
55918 | 56222 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
55919 | 56223 | } |
55920 | 56224 | // ACCUMULATE ARGUMENTS - END |
55921 | - uint64_t return_to = 18446744073709549270LLU; | |
56225 | + uint64_t return_to = 18446744073709549257LLU; | |
55922 | 56226 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
55923 | 56227 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
55924 | 56228 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -55927,7 +56231,7 @@ | ||
55927 | 56231 | state.addr = 517555565476695680LLU; // assertu64_ |
55928 | 56232 | break; |
55929 | 56233 | } |
55930 | - case 18446744073709549270LLU: // 99999999$V''''''''''''''' | |
56234 | + case 18446744073709549257LLU: // 99999999$I''''''''''''''' | |
55931 | 56235 | { |
55932 | 56236 | // ACCUMULATE ARGUMENTS - BEGIN |
55933 | 56237 | { |
@@ -55935,7 +56239,7 @@ | ||
55935 | 56239 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
55936 | 56240 | } |
55937 | 56241 | // ACCUMULATE ARGUMENTS - END |
55938 | - uint64_t return_to = 18446744073709549269LLU; | |
56242 | + uint64_t return_to = 18446744073709549256LLU; | |
55939 | 56243 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
55940 | 56244 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
55941 | 56245 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -55944,7 +56248,7 @@ | ||
55944 | 56248 | state.addr = 839519665163075584LLU; // skip______ |
55945 | 56249 | break; |
55946 | 56250 | } |
55947 | - case 18446744073709549269LLU: // 99999999$U''''''''''''''' | |
56251 | + case 18446744073709549256LLU: // 99999999$H''''''''''''''' | |
55948 | 56252 | { |
55949 | 56253 | matchid(",", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU))); |
55950 | 56254 | fprintf(stdout, "%s", " >= "); |
@@ -55954,7 +56258,7 @@ | ||
55954 | 56258 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
55955 | 56259 | } |
55956 | 56260 | // ACCUMULATE ARGUMENTS - END |
55957 | - uint64_t return_to = 18446744073709549268LLU; | |
56261 | + uint64_t return_to = 18446744073709549255LLU; | |
55958 | 56262 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
55959 | 56263 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
55960 | 56264 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -55963,7 +56267,7 @@ | ||
55963 | 56267 | state.addr = 839519665163075584LLU; // skip______ |
55964 | 56268 | break; |
55965 | 56269 | } |
55966 | - case 18446744073709549268LLU: // 99999999$T''''''''''''''' | |
56270 | + case 18446744073709549255LLU: // 99999999$G''''''''''''''' | |
55967 | 56271 | { |
55968 | 56272 | |
55969 | 56273 | *LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU))); |
@@ -55985,7 +56289,7 @@ | ||
55985 | 56289 | LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
55986 | 56290 | } |
55987 | 56291 | // ACCUMULATE ARGUMENTS - END |
55988 | - uint64_t return_to = 18446744073709549267LLU; | |
56292 | + uint64_t return_to = 18446744073709549254LLU; | |
55989 | 56293 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
55990 | 56294 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
55991 | 56295 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -55994,7 +56298,7 @@ | ||
55994 | 56298 | state.addr = 23446349213393492LLU; // ASSERTINIT |
55995 | 56299 | break; |
55996 | 56300 | } |
55997 | - case 18446744073709549267LLU: // 99999999$S''''''''''''''' | |
56301 | + case 18446744073709549254LLU: // 99999999$F''''''''''''''' | |
55998 | 56302 | { |
55999 | 56303 | { |
56000 | 56304 | uint64_t arg = 0; |
@@ -56073,7 +56377,7 @@ | ||
56073 | 56377 | LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
56074 | 56378 | } |
56075 | 56379 | // ACCUMULATE ARGUMENTS - END |
56076 | - uint64_t return_to = 18446744073709549266LLU; | |
56380 | + uint64_t return_to = 18446744073709549253LLU; | |
56077 | 56381 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)); |
56078 | 56382 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
56079 | 56383 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -56082,7 +56386,7 @@ | ||
56082 | 56386 | state.addr = 293363126232490310LLU; // PROCVARREF |
56083 | 56387 | break; |
56084 | 56388 | } |
56085 | - case 18446744073709549266LLU: // 99999999$R''''''''''''''' | |
56389 | + case 18446744073709549253LLU: // 99999999$E''''''''''''''' | |
56086 | 56390 | { |
56087 | 56391 | // variable u64 initialize goes out of scope |
56088 | 56392 | // emitted destructur for type u64 |
@@ -56103,7 +56407,7 @@ | ||
56103 | 56407 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
56104 | 56408 | } |
56105 | 56409 | // ACCUMULATE ARGUMENTS - END |
56106 | - uint64_t return_to = 18446744073709549265LLU; | |
56410 | + uint64_t return_to = 18446744073709549252LLU; | |
56107 | 56411 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
56108 | 56412 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
56109 | 56413 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -56112,7 +56416,7 @@ | ||
56112 | 56416 | state.addr = 517555565476695680LLU; // assertu64_ |
56113 | 56417 | break; |
56114 | 56418 | } |
56115 | - case 18446744073709549265LLU: // 99999999$Q''''''''''''''' | |
56419 | + case 18446744073709549252LLU: // 99999999$D''''''''''''''' | |
56116 | 56420 | { |
56117 | 56421 | // ACCUMULATE ARGUMENTS - BEGIN |
56118 | 56422 | { |
@@ -56120,7 +56424,7 @@ | ||
56120 | 56424 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
56121 | 56425 | } |
56122 | 56426 | // ACCUMULATE ARGUMENTS - END |
56123 | - uint64_t return_to = 18446744073709549264LLU; | |
56427 | + uint64_t return_to = 18446744073709549251LLU; | |
56124 | 56428 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
56125 | 56429 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
56126 | 56430 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -56129,7 +56433,7 @@ | ||
56129 | 56433 | state.addr = 839519665163075584LLU; // skip______ |
56130 | 56434 | break; |
56131 | 56435 | } |
56132 | - case 18446744073709549264LLU: // 99999999$P''''''''''''''' | |
56436 | + case 18446744073709549251LLU: // 99999999$C''''''''''''''' | |
56133 | 56437 | { |
56134 | 56438 | matchid(")", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU))); |
56135 | 56439 | fprintf(stdout, "%s", ";"); |
@@ -56141,7 +56445,7 @@ | ||
56141 | 56445 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
56142 | 56446 | } |
56143 | 56447 | // ACCUMULATE ARGUMENTS - END |
56144 | - uint64_t return_to = 18446744073709549263LLU; | |
56448 | + uint64_t return_to = 18446744073709549250LLU; | |
56145 | 56449 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
56146 | 56450 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
56147 | 56451 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -56150,7 +56454,7 @@ | ||
56150 | 56454 | state.addr = 18446744073709551534LLU; // 999999998s''''''''''''''' |
56151 | 56455 | break; |
56152 | 56456 | } |
56153 | - case 18446744073709549263LLU: // 99999999$O''''''''''''''' | |
56457 | + case 18446744073709549250LLU: // 99999999$B''''''''''''''' | |
56154 | 56458 | { |
56155 | 56459 | (void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference single____ at 21 |
56156 | 56460 | // variable type______ type______ goes out of scope |
@@ -56161,7 +56465,7 @@ | ||
56161 | 56465 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
56162 | 56466 | } |
56163 | 56467 | // ACCUMULATE ARGUMENTS - END |
56164 | - uint64_t return_to = 18446744073709549262LLU; | |
56468 | + uint64_t return_to = 18446744073709549249LLU; | |
56165 | 56469 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
56166 | 56470 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
56167 | 56471 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -56170,7 +56474,7 @@ | ||
56170 | 56474 | state.addr = 18446744073709551573LLU; // 999999999U''''''''''''''' |
56171 | 56475 | break; |
56172 | 56476 | } |
56173 | - case 18446744073709549262LLU: // 99999999$N''''''''''''''' | |
56477 | + case 18446744073709549249LLU: // 99999999$A''''''''''''''' | |
56174 | 56478 | { |
56175 | 56479 | (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type______ at 20 |
56176 | 56480 | // variable u64 mutable___ goes out of scope |
@@ -56182,10 +56486,10 @@ | ||
56182 | 56486 | // variable u64 id________ goes out of scope |
56183 | 56487 | // emitted destructur for type u64 |
56184 | 56488 | (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id________ at 17 |
56185 | - state.addr = 18446744073709549280LLU; // 99999999$e''''''''''''''' | |
56489 | + state.addr = 18446744073709549267LLU; // 99999999$S''''''''''''''' | |
56186 | 56490 | break; |
56187 | 56491 | } |
56188 | - case 18446744073709549281LLU: // 99999999$f''''''''''''''' | |
56492 | + case 18446744073709549268LLU: // 99999999$T''''''''''''''' | |
56189 | 56493 | { |
56190 | 56494 | |
56191 | 56495 | *LOCAL_ACCESS(heap.data, 16LLU, 15LLU) = 625916785320787968; |
@@ -56196,11 +56500,11 @@ | ||
56196 | 56500 | LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
56197 | 56501 | } |
56198 | 56502 | *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 0LLU)); |
56199 | - state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549261LLU : 18446744073709549260LLU; | |
56503 | + state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549248LLU : 18446744073709549247LLU; | |
56200 | 56504 | (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 17 |
56201 | 56505 | break; |
56202 | 56506 | } |
56203 | - case 18446744073709549261LLU: // 99999999$M''''''''''''''' | |
56507 | + case 18446744073709549248LLU: // 99999999$_''''''''''''''' | |
56204 | 56508 | { |
56205 | 56509 | { |
56206 | 56510 | uint64_t arg = 0; |
@@ -56227,7 +56531,7 @@ | ||
56227 | 56531 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
56228 | 56532 | } |
56229 | 56533 | // ACCUMULATE ARGUMENTS - END |
56230 | - uint64_t return_to = 18446744073709549258LLU; | |
56534 | + uint64_t return_to = 18446744073709549245LLU; | |
56231 | 56535 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
56232 | 56536 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
56233 | 56537 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -56236,7 +56540,7 @@ | ||
56236 | 56540 | state.addr = 861504796319285248LLU; // typeu64___ |
56237 | 56541 | break; |
56238 | 56542 | } |
56239 | - case 18446744073709549258LLU: // 99999999$J''''''''''''''' | |
56543 | + case 18446744073709549245LLU: // 99999999Z7''''''''''''''' | |
56240 | 56544 | { |
56241 | 56545 | { |
56242 | 56546 | uint64_t arg = 0; |
@@ -56261,7 +56565,7 @@ | ||
56261 | 56565 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
56262 | 56566 | } |
56263 | 56567 | // ACCUMULATE ARGUMENTS - END |
56264 | - uint64_t return_to = 18446744073709549256LLU; | |
56568 | + uint64_t return_to = 18446744073709549243LLU; | |
56265 | 56569 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
56266 | 56570 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
56267 | 56571 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -56270,7 +56574,7 @@ | ||
56270 | 56574 | state.addr = 861504796319285248LLU; // typeu64___ |
56271 | 56575 | break; |
56272 | 56576 | } |
56273 | - case 18446744073709549256LLU: // 99999999$H''''''''''''''' | |
56577 | + case 18446744073709549243LLU: // 99999999Z5''''''''''''''' | |
56274 | 56578 | { |
56275 | 56579 | { |
56276 | 56580 | uint64_t exchange = LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 23*/; |
@@ -56290,7 +56594,7 @@ | ||
56290 | 56594 | LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
56291 | 56595 | } |
56292 | 56596 | // ACCUMULATE ARGUMENTS - END |
56293 | - uint64_t return_to = 18446744073709549257LLU; | |
56597 | + uint64_t return_to = 18446744073709549244LLU; | |
56294 | 56598 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
56295 | 56599 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
56296 | 56600 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -56299,7 +56603,7 @@ | ||
56299 | 56603 | state.addr = 819859607768530944LLU; // resdest___ |
56300 | 56604 | break; |
56301 | 56605 | } |
56302 | - case 18446744073709549257LLU: // 99999999$I''''''''''''''' | |
56606 | + case 18446744073709549244LLU: // 99999999Z6''''''''''''''' | |
56303 | 56607 | { |
56304 | 56608 | // ACCUMULATE ARGUMENTS - BEGIN |
56305 | 56609 | { |
@@ -56319,7 +56623,7 @@ | ||
56319 | 56623 | LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
56320 | 56624 | } |
56321 | 56625 | // ACCUMULATE ARGUMENTS - END |
56322 | - uint64_t return_to = 18446744073709549255LLU; | |
56626 | + uint64_t return_to = 18446744073709549242LLU; | |
56323 | 56627 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
56324 | 56628 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
56325 | 56629 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -56328,7 +56632,7 @@ | ||
56328 | 56632 | state.addr = 819857494882385920LLU; // res_u64___ |
56329 | 56633 | break; |
56330 | 56634 | } |
56331 | - case 18446744073709549255LLU: // 99999999$G''''''''''''''' | |
56635 | + case 18446744073709549242LLU: // 99999999Z4''''''''''''''' | |
56332 | 56636 | { |
56333 | 56637 | // ACCUMULATE ARGUMENTS - BEGIN |
56334 | 56638 | { |
@@ -56336,7 +56640,7 @@ | ||
56336 | 56640 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
56337 | 56641 | } |
56338 | 56642 | // ACCUMULATE ARGUMENTS - END |
56339 | - uint64_t return_to = 18446744073709549254LLU; | |
56643 | + uint64_t return_to = 18446744073709549241LLU; | |
56340 | 56644 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
56341 | 56645 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
56342 | 56646 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -56345,7 +56649,7 @@ | ||
56345 | 56649 | state.addr = 839519665163075584LLU; // skip______ |
56346 | 56650 | break; |
56347 | 56651 | } |
56348 | - case 18446744073709549254LLU: // 99999999$F''''''''''''''' | |
56652 | + case 18446744073709549241LLU: // 99999999Z3''''''''''''''' | |
56349 | 56653 | { |
56350 | 56654 | matchid("(", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU))); |
56351 | 56655 | fprintf(stdout, "%s", "\n "); |
@@ -56371,7 +56675,7 @@ | ||
56371 | 56675 | LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
56372 | 56676 | } |
56373 | 56677 | // ACCUMULATE ARGUMENTS - END |
56374 | - uint64_t return_to = 18446744073709549253LLU; | |
56678 | + uint64_t return_to = 18446744073709549240LLU; | |
56375 | 56679 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)); |
56376 | 56680 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
56377 | 56681 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -56380,7 +56684,7 @@ | ||
56380 | 56684 | state.addr = 587881357514113024LLU; // emitpar___ |
56381 | 56685 | break; |
56382 | 56686 | } |
56383 | - case 18446744073709549253LLU: // 99999999$E''''''''''''''' | |
56687 | + case 18446744073709549240LLU: // 99999999Z2''''''''''''''' | |
56384 | 56688 | { |
56385 | 56689 | fprintf(stdout, "%s", " = "); |
56386 | 56690 | // ACCUMULATE ARGUMENTS - BEGIN |
@@ -56389,7 +56693,7 @@ | ||
56389 | 56693 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
56390 | 56694 | } |
56391 | 56695 | // ACCUMULATE ARGUMENTS - END |
56392 | - uint64_t return_to = 18446744073709549252LLU; | |
56696 | + uint64_t return_to = 18446744073709549239LLU; | |
56393 | 56697 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
56394 | 56698 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
56395 | 56699 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -56398,7 +56702,7 @@ | ||
56398 | 56702 | state.addr = 839519665163075584LLU; // skip______ |
56399 | 56703 | break; |
56400 | 56704 | } |
56401 | - case 18446744073709549252LLU: // 99999999$D''''''''''''''' | |
56705 | + case 18446744073709549239LLU: // 99999999Z1''''''''''''''' | |
56402 | 56706 | { |
56403 | 56707 | |
56404 | 56708 | *LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU))); |
@@ -56420,7 +56724,7 @@ | ||
56420 | 56724 | LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
56421 | 56725 | } |
56422 | 56726 | // ACCUMULATE ARGUMENTS - END |
56423 | - uint64_t return_to = 18446744073709549251LLU; | |
56727 | + uint64_t return_to = 18446744073709549238LLU; | |
56424 | 56728 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
56425 | 56729 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
56426 | 56730 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -56429,7 +56733,7 @@ | ||
56429 | 56733 | state.addr = 23446349213393492LLU; // ASSERTINIT |
56430 | 56734 | break; |
56431 | 56735 | } |
56432 | - case 18446744073709549251LLU: // 99999999$C''''''''''''''' | |
56736 | + case 18446744073709549238LLU: // 99999999Z0''''''''''''''' | |
56433 | 56737 | { |
56434 | 56738 | { |
56435 | 56739 | uint64_t arg = 0; |
@@ -56508,7 +56812,7 @@ | ||
56508 | 56812 | LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
56509 | 56813 | } |
56510 | 56814 | // ACCUMULATE ARGUMENTS - END |
56511 | - uint64_t return_to = 18446744073709549250LLU; | |
56815 | + uint64_t return_to = 18446744073709549237LLU; | |
56512 | 56816 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)); |
56513 | 56817 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
56514 | 56818 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -56517,7 +56821,7 @@ | ||
56517 | 56821 | state.addr = 293363126232490310LLU; // PROCVARREF |
56518 | 56822 | break; |
56519 | 56823 | } |
56520 | - case 18446744073709549250LLU: // 99999999$B''''''''''''''' | |
56824 | + case 18446744073709549237LLU: // 99999999Zz''''''''''''''' | |
56521 | 56825 | { |
56522 | 56826 | // variable u64 initialize goes out of scope |
56523 | 56827 | // emitted destructur for type u64 |
@@ -56538,7 +56842,7 @@ | ||
56538 | 56842 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
56539 | 56843 | } |
56540 | 56844 | // ACCUMULATE ARGUMENTS - END |
56541 | - uint64_t return_to = 18446744073709549249LLU; | |
56845 | + uint64_t return_to = 18446744073709549236LLU; | |
56542 | 56846 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
56543 | 56847 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
56544 | 56848 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -56547,7 +56851,7 @@ | ||
56547 | 56851 | state.addr = 517555565476695680LLU; // assertu64_ |
56548 | 56852 | break; |
56549 | 56853 | } |
56550 | - case 18446744073709549249LLU: // 99999999$A''''''''''''''' | |
56854 | + case 18446744073709549236LLU: // 99999999Zy''''''''''''''' | |
56551 | 56855 | { |
56552 | 56856 | // ACCUMULATE ARGUMENTS - BEGIN |
56553 | 56857 | { |
@@ -56555,7 +56859,7 @@ | ||
56555 | 56859 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
56556 | 56860 | } |
56557 | 56861 | // ACCUMULATE ARGUMENTS - END |
56558 | - uint64_t return_to = 18446744073709549248LLU; | |
56862 | + uint64_t return_to = 18446744073709549235LLU; | |
56559 | 56863 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
56560 | 56864 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
56561 | 56865 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -56564,7 +56868,7 @@ | ||
56564 | 56868 | state.addr = 839519665163075584LLU; // skip______ |
56565 | 56869 | break; |
56566 | 56870 | } |
56567 | - case 18446744073709549248LLU: // 99999999$_''''''''''''''' | |
56871 | + case 18446744073709549235LLU: // 99999999Zx''''''''''''''' | |
56568 | 56872 | { |
56569 | 56873 | matchid(",", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU))); |
56570 | 56874 | fprintf(stdout, "%s", " > "); |
@@ -56574,7 +56878,7 @@ | ||
56574 | 56878 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
56575 | 56879 | } |
56576 | 56880 | // ACCUMULATE ARGUMENTS - END |
56577 | - uint64_t return_to = 18446744073709549247LLU; | |
56881 | + uint64_t return_to = 18446744073709549234LLU; | |
56578 | 56882 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
56579 | 56883 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
56580 | 56884 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -56583,7 +56887,7 @@ | ||
56583 | 56887 | state.addr = 839519665163075584LLU; // skip______ |
56584 | 56888 | break; |
56585 | 56889 | } |
56586 | - case 18446744073709549247LLU: // 99999999Z9''''''''''''''' | |
56890 | + case 18446744073709549234LLU: // 99999999Zw''''''''''''''' | |
56587 | 56891 | { |
56588 | 56892 | |
56589 | 56893 | *LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU))); |
@@ -56605,7 +56909,7 @@ | ||
56605 | 56909 | LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
56606 | 56910 | } |
56607 | 56911 | // ACCUMULATE ARGUMENTS - END |
56608 | - uint64_t return_to = 18446744073709549246LLU; | |
56912 | + uint64_t return_to = 18446744073709549233LLU; | |
56609 | 56913 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
56610 | 56914 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
56611 | 56915 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -56614,7 +56918,7 @@ | ||
56614 | 56918 | state.addr = 23446349213393492LLU; // ASSERTINIT |
56615 | 56919 | break; |
56616 | 56920 | } |
56617 | - case 18446744073709549246LLU: // 99999999Z8''''''''''''''' | |
56921 | + case 18446744073709549233LLU: // 99999999Zv''''''''''''''' | |
56618 | 56922 | { |
56619 | 56923 | { |
56620 | 56924 | uint64_t arg = 0; |
@@ -56693,7 +56997,7 @@ | ||
56693 | 56997 | LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
56694 | 56998 | } |
56695 | 56999 | // ACCUMULATE ARGUMENTS - END |
56696 | - uint64_t return_to = 18446744073709549245LLU; | |
57000 | + uint64_t return_to = 18446744073709549232LLU; | |
56697 | 57001 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)); |
56698 | 57002 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
56699 | 57003 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -56702,7 +57006,7 @@ | ||
56702 | 57006 | state.addr = 293363126232490310LLU; // PROCVARREF |
56703 | 57007 | break; |
56704 | 57008 | } |
56705 | - case 18446744073709549245LLU: // 99999999Z7''''''''''''''' | |
57009 | + case 18446744073709549232LLU: // 99999999Zu''''''''''''''' | |
56706 | 57010 | { |
56707 | 57011 | // variable u64 initialize goes out of scope |
56708 | 57012 | // emitted destructur for type u64 |
@@ -56723,7 +57027,7 @@ | ||
56723 | 57027 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
56724 | 57028 | } |
56725 | 57029 | // ACCUMULATE ARGUMENTS - END |
56726 | - uint64_t return_to = 18446744073709549244LLU; | |
57030 | + uint64_t return_to = 18446744073709549231LLU; | |
56727 | 57031 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
56728 | 57032 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
56729 | 57033 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -56732,7 +57036,7 @@ | ||
56732 | 57036 | state.addr = 517555565476695680LLU; // assertu64_ |
56733 | 57037 | break; |
56734 | 57038 | } |
56735 | - case 18446744073709549244LLU: // 99999999Z6''''''''''''''' | |
57039 | + case 18446744073709549231LLU: // 99999999Zt''''''''''''''' | |
56736 | 57040 | { |
56737 | 57041 | // ACCUMULATE ARGUMENTS - BEGIN |
56738 | 57042 | { |
@@ -56740,7 +57044,7 @@ | ||
56740 | 57044 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
56741 | 57045 | } |
56742 | 57046 | // ACCUMULATE ARGUMENTS - END |
56743 | - uint64_t return_to = 18446744073709549243LLU; | |
57047 | + uint64_t return_to = 18446744073709549230LLU; | |
56744 | 57048 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
56745 | 57049 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
56746 | 57050 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -56749,7 +57053,7 @@ | ||
56749 | 57053 | state.addr = 839519665163075584LLU; // skip______ |
56750 | 57054 | break; |
56751 | 57055 | } |
56752 | - case 18446744073709549243LLU: // 99999999Z5''''''''''''''' | |
57056 | + case 18446744073709549230LLU: // 99999999Zs''''''''''''''' | |
56753 | 57057 | { |
56754 | 57058 | matchid(")", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU))); |
56755 | 57059 | fprintf(stdout, "%s", ";"); |
@@ -56761,7 +57065,7 @@ | ||
56761 | 57065 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
56762 | 57066 | } |
56763 | 57067 | // ACCUMULATE ARGUMENTS - END |
56764 | - uint64_t return_to = 18446744073709549242LLU; | |
57068 | + uint64_t return_to = 18446744073709549229LLU; | |
56765 | 57069 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
56766 | 57070 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
56767 | 57071 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -56770,7 +57074,7 @@ | ||
56770 | 57074 | state.addr = 18446744073709551534LLU; // 999999998s''''''''''''''' |
56771 | 57075 | break; |
56772 | 57076 | } |
56773 | - case 18446744073709549242LLU: // 99999999Z4''''''''''''''' | |
57077 | + case 18446744073709549229LLU: // 99999999Zr''''''''''''''' | |
56774 | 57078 | { |
56775 | 57079 | (void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference single____ at 21 |
56776 | 57080 | // variable type______ type______ goes out of scope |
@@ -56781,7 +57085,7 @@ | ||
56781 | 57085 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
56782 | 57086 | } |
56783 | 57087 | // ACCUMULATE ARGUMENTS - END |
56784 | - uint64_t return_to = 18446744073709549241LLU; | |
57088 | + uint64_t return_to = 18446744073709549228LLU; | |
56785 | 57089 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
56786 | 57090 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
56787 | 57091 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -56790,7 +57094,7 @@ | ||
56790 | 57094 | state.addr = 18446744073709551573LLU; // 999999999U''''''''''''''' |
56791 | 57095 | break; |
56792 | 57096 | } |
56793 | - case 18446744073709549241LLU: // 99999999Z3''''''''''''''' | |
57097 | + case 18446744073709549228LLU: // 99999999Zq''''''''''''''' | |
56794 | 57098 | { |
56795 | 57099 | (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type______ at 20 |
56796 | 57100 | // variable u64 mutable___ goes out of scope |
@@ -56802,10 +57106,10 @@ | ||
56802 | 57106 | // variable u64 id________ goes out of scope |
56803 | 57107 | // emitted destructur for type u64 |
56804 | 57108 | (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id________ at 17 |
56805 | - state.addr = 18446744073709549259LLU; // 99999999$K''''''''''''''' | |
57109 | + state.addr = 18446744073709549246LLU; // 99999999Z8''''''''''''''' | |
56806 | 57110 | break; |
56807 | 57111 | } |
56808 | - case 18446744073709549260LLU: // 99999999$L''''''''''''''' | |
57112 | + case 18446744073709549247LLU: // 99999999Z9''''''''''''''' | |
56809 | 57113 | { |
56810 | 57114 | |
56811 | 57115 | *LOCAL_ACCESS(heap.data, 16LLU, 15LLU) = 711762255171026944; |
@@ -56816,11 +57120,11 @@ | ||
56816 | 57120 | LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
56817 | 57121 | } |
56818 | 57122 | *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 0LLU)); |
56819 | - state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549240LLU : 18446744073709549239LLU; | |
57123 | + state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549227LLU : 18446744073709549226LLU; | |
56820 | 57124 | (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 17 |
56821 | 57125 | break; |
56822 | 57126 | } |
56823 | - case 18446744073709549240LLU: // 99999999Z2''''''''''''''' | |
57127 | + case 18446744073709549227LLU: // 99999999Zp''''''''''''''' | |
56824 | 57128 | { |
56825 | 57129 | { |
56826 | 57130 | uint64_t arg = 0; |
@@ -56847,7 +57151,7 @@ | ||
56847 | 57151 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
56848 | 57152 | } |
56849 | 57153 | // ACCUMULATE ARGUMENTS - END |
56850 | - uint64_t return_to = 18446744073709549237LLU; | |
57154 | + uint64_t return_to = 18446744073709549224LLU; | |
56851 | 57155 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
56852 | 57156 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
56853 | 57157 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -56856,7 +57160,7 @@ | ||
56856 | 57160 | state.addr = 861504796319285248LLU; // typeu64___ |
56857 | 57161 | break; |
56858 | 57162 | } |
56859 | - case 18446744073709549237LLU: // 99999999Zz''''''''''''''' | |
57163 | + case 18446744073709549224LLU: // 99999999Zm''''''''''''''' | |
56860 | 57164 | { |
56861 | 57165 | { |
56862 | 57166 | uint64_t arg = 0; |
@@ -56881,7 +57185,7 @@ | ||
56881 | 57185 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
56882 | 57186 | } |
56883 | 57187 | // ACCUMULATE ARGUMENTS - END |
56884 | - uint64_t return_to = 18446744073709549235LLU; | |
57188 | + uint64_t return_to = 18446744073709549222LLU; | |
56885 | 57189 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
56886 | 57190 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
56887 | 57191 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -56890,7 +57194,7 @@ | ||
56890 | 57194 | state.addr = 861504796319285248LLU; // typeu64___ |
56891 | 57195 | break; |
56892 | 57196 | } |
56893 | - case 18446744073709549235LLU: // 99999999Zx''''''''''''''' | |
57197 | + case 18446744073709549222LLU: // 99999999Zk''''''''''''''' | |
56894 | 57198 | { |
56895 | 57199 | { |
56896 | 57200 | uint64_t exchange = LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 23*/; |
@@ -56910,7 +57214,7 @@ | ||
56910 | 57214 | LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
56911 | 57215 | } |
56912 | 57216 | // ACCUMULATE ARGUMENTS - END |
56913 | - uint64_t return_to = 18446744073709549236LLU; | |
57217 | + uint64_t return_to = 18446744073709549223LLU; | |
56914 | 57218 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
56915 | 57219 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
56916 | 57220 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -56919,7 +57223,7 @@ | ||
56919 | 57223 | state.addr = 819859607768530944LLU; // resdest___ |
56920 | 57224 | break; |
56921 | 57225 | } |
56922 | - case 18446744073709549236LLU: // 99999999Zy''''''''''''''' | |
57226 | + case 18446744073709549223LLU: // 99999999Zl''''''''''''''' | |
56923 | 57227 | { |
56924 | 57228 | // ACCUMULATE ARGUMENTS - BEGIN |
56925 | 57229 | { |
@@ -56939,7 +57243,7 @@ | ||
56939 | 57243 | LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
56940 | 57244 | } |
56941 | 57245 | // ACCUMULATE ARGUMENTS - END |
56942 | - uint64_t return_to = 18446744073709549234LLU; | |
57246 | + uint64_t return_to = 18446744073709549221LLU; | |
56943 | 57247 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
56944 | 57248 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
56945 | 57249 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -56948,7 +57252,7 @@ | ||
56948 | 57252 | state.addr = 819857494882385920LLU; // res_u64___ |
56949 | 57253 | break; |
56950 | 57254 | } |
56951 | - case 18446744073709549234LLU: // 99999999Zw''''''''''''''' | |
57255 | + case 18446744073709549221LLU: // 99999999Zj''''''''''''''' | |
56952 | 57256 | { |
56953 | 57257 | // ACCUMULATE ARGUMENTS - BEGIN |
56954 | 57258 | { |
@@ -56956,7 +57260,7 @@ | ||
56956 | 57260 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
56957 | 57261 | } |
56958 | 57262 | // ACCUMULATE ARGUMENTS - END |
56959 | - uint64_t return_to = 18446744073709549233LLU; | |
57263 | + uint64_t return_to = 18446744073709549220LLU; | |
56960 | 57264 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
56961 | 57265 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
56962 | 57266 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -56965,7 +57269,7 @@ | ||
56965 | 57269 | state.addr = 839519665163075584LLU; // skip______ |
56966 | 57270 | break; |
56967 | 57271 | } |
56968 | - case 18446744073709549233LLU: // 99999999Zv''''''''''''''' | |
57272 | + case 18446744073709549220LLU: // 99999999Zi''''''''''''''' | |
56969 | 57273 | { |
56970 | 57274 | matchid("(", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU))); |
56971 | 57275 | fprintf(stdout, "%s", "\n "); |
@@ -56991,7 +57295,7 @@ | ||
56991 | 57295 | LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
56992 | 57296 | } |
56993 | 57297 | // ACCUMULATE ARGUMENTS - END |
56994 | - uint64_t return_to = 18446744073709549232LLU; | |
57298 | + uint64_t return_to = 18446744073709549219LLU; | |
56995 | 57299 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)); |
56996 | 57300 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
56997 | 57301 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -57000,7 +57304,7 @@ | ||
57000 | 57304 | state.addr = 587881357514113024LLU; // emitpar___ |
57001 | 57305 | break; |
57002 | 57306 | } |
57003 | - case 18446744073709549232LLU: // 99999999Zu''''''''''''''' | |
57307 | + case 18446744073709549219LLU: // 99999999Zh''''''''''''''' | |
57004 | 57308 | { |
57005 | 57309 | fprintf(stdout, "%s", " = "); |
57006 | 57310 | // ACCUMULATE ARGUMENTS - BEGIN |
@@ -57009,7 +57313,7 @@ | ||
57009 | 57313 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
57010 | 57314 | } |
57011 | 57315 | // ACCUMULATE ARGUMENTS - END |
57012 | - uint64_t return_to = 18446744073709549231LLU; | |
57316 | + uint64_t return_to = 18446744073709549218LLU; | |
57013 | 57317 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
57014 | 57318 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
57015 | 57319 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -57018,7 +57322,7 @@ | ||
57018 | 57322 | state.addr = 839519665163075584LLU; // skip______ |
57019 | 57323 | break; |
57020 | 57324 | } |
57021 | - case 18446744073709549231LLU: // 99999999Zt''''''''''''''' | |
57325 | + case 18446744073709549218LLU: // 99999999Zg''''''''''''''' | |
57022 | 57326 | { |
57023 | 57327 | |
57024 | 57328 | *LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU))); |
@@ -57040,7 +57344,7 @@ | ||
57040 | 57344 | LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
57041 | 57345 | } |
57042 | 57346 | // ACCUMULATE ARGUMENTS - END |
57043 | - uint64_t return_to = 18446744073709549230LLU; | |
57347 | + uint64_t return_to = 18446744073709549217LLU; | |
57044 | 57348 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
57045 | 57349 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
57046 | 57350 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -57049,7 +57353,7 @@ | ||
57049 | 57353 | state.addr = 23446349213393492LLU; // ASSERTINIT |
57050 | 57354 | break; |
57051 | 57355 | } |
57052 | - case 18446744073709549230LLU: // 99999999Zs''''''''''''''' | |
57356 | + case 18446744073709549217LLU: // 99999999Zf''''''''''''''' | |
57053 | 57357 | { |
57054 | 57358 | { |
57055 | 57359 | uint64_t arg = 0; |
@@ -57128,7 +57432,7 @@ | ||
57128 | 57432 | LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
57129 | 57433 | } |
57130 | 57434 | // ACCUMULATE ARGUMENTS - END |
57131 | - uint64_t return_to = 18446744073709549229LLU; | |
57435 | + uint64_t return_to = 18446744073709549216LLU; | |
57132 | 57436 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)); |
57133 | 57437 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
57134 | 57438 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -57137,7 +57441,7 @@ | ||
57137 | 57441 | state.addr = 293363126232490310LLU; // PROCVARREF |
57138 | 57442 | break; |
57139 | 57443 | } |
57140 | - case 18446744073709549229LLU: // 99999999Zr''''''''''''''' | |
57444 | + case 18446744073709549216LLU: // 99999999Ze''''''''''''''' | |
57141 | 57445 | { |
57142 | 57446 | // variable u64 initialize goes out of scope |
57143 | 57447 | // emitted destructur for type u64 |
@@ -57158,7 +57462,7 @@ | ||
57158 | 57462 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
57159 | 57463 | } |
57160 | 57464 | // ACCUMULATE ARGUMENTS - END |
57161 | - uint64_t return_to = 18446744073709549228LLU; | |
57465 | + uint64_t return_to = 18446744073709549215LLU; | |
57162 | 57466 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
57163 | 57467 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
57164 | 57468 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -57167,7 +57471,7 @@ | ||
57167 | 57471 | state.addr = 517555565476695680LLU; // assertu64_ |
57168 | 57472 | break; |
57169 | 57473 | } |
57170 | - case 18446744073709549228LLU: // 99999999Zq''''''''''''''' | |
57474 | + case 18446744073709549215LLU: // 99999999Zd''''''''''''''' | |
57171 | 57475 | { |
57172 | 57476 | // ACCUMULATE ARGUMENTS - BEGIN |
57173 | 57477 | { |
@@ -57175,7 +57479,7 @@ | ||
57175 | 57479 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
57176 | 57480 | } |
57177 | 57481 | // ACCUMULATE ARGUMENTS - END |
57178 | - uint64_t return_to = 18446744073709549227LLU; | |
57482 | + uint64_t return_to = 18446744073709549214LLU; | |
57179 | 57483 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
57180 | 57484 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
57181 | 57485 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -57184,7 +57488,7 @@ | ||
57184 | 57488 | state.addr = 839519665163075584LLU; // skip______ |
57185 | 57489 | break; |
57186 | 57490 | } |
57187 | - case 18446744073709549227LLU: // 99999999Zp''''''''''''''' | |
57491 | + case 18446744073709549214LLU: // 99999999Zc''''''''''''''' | |
57188 | 57492 | { |
57189 | 57493 | matchid(",", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU))); |
57190 | 57494 | fprintf(stdout, "%s", " <= "); |
@@ -57194,7 +57498,7 @@ | ||
57194 | 57498 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
57195 | 57499 | } |
57196 | 57500 | // ACCUMULATE ARGUMENTS - END |
57197 | - uint64_t return_to = 18446744073709549226LLU; | |
57501 | + uint64_t return_to = 18446744073709549213LLU; | |
57198 | 57502 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
57199 | 57503 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
57200 | 57504 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -57203,7 +57507,7 @@ | ||
57203 | 57507 | state.addr = 839519665163075584LLU; // skip______ |
57204 | 57508 | break; |
57205 | 57509 | } |
57206 | - case 18446744073709549226LLU: // 99999999Zo''''''''''''''' | |
57510 | + case 18446744073709549213LLU: // 99999999Zb''''''''''''''' | |
57207 | 57511 | { |
57208 | 57512 | |
57209 | 57513 | *LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU))); |
@@ -57225,7 +57529,7 @@ | ||
57225 | 57529 | LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
57226 | 57530 | } |
57227 | 57531 | // ACCUMULATE ARGUMENTS - END |
57228 | - uint64_t return_to = 18446744073709549225LLU; | |
57532 | + uint64_t return_to = 18446744073709549212LLU; | |
57229 | 57533 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
57230 | 57534 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
57231 | 57535 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -57234,7 +57538,7 @@ | ||
57234 | 57538 | state.addr = 23446349213393492LLU; // ASSERTINIT |
57235 | 57539 | break; |
57236 | 57540 | } |
57237 | - case 18446744073709549225LLU: // 99999999Zn''''''''''''''' | |
57541 | + case 18446744073709549212LLU: // 99999999Za''''''''''''''' | |
57238 | 57542 | { |
57239 | 57543 | { |
57240 | 57544 | uint64_t arg = 0; |
@@ -57313,7 +57617,7 @@ | ||
57313 | 57617 | LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
57314 | 57618 | } |
57315 | 57619 | // ACCUMULATE ARGUMENTS - END |
57316 | - uint64_t return_to = 18446744073709549224LLU; | |
57620 | + uint64_t return_to = 18446744073709549211LLU; | |
57317 | 57621 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)); |
57318 | 57622 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
57319 | 57623 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -57322,7 +57626,7 @@ | ||
57322 | 57626 | state.addr = 293363126232490310LLU; // PROCVARREF |
57323 | 57627 | break; |
57324 | 57628 | } |
57325 | - case 18446744073709549224LLU: // 99999999Zm''''''''''''''' | |
57629 | + case 18446744073709549211LLU: // 99999999Z$''''''''''''''' | |
57326 | 57630 | { |
57327 | 57631 | // variable u64 initialize goes out of scope |
57328 | 57632 | // emitted destructur for type u64 |
@@ -57343,7 +57647,7 @@ | ||
57343 | 57647 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
57344 | 57648 | } |
57345 | 57649 | // ACCUMULATE ARGUMENTS - END |
57346 | - uint64_t return_to = 18446744073709549223LLU; | |
57650 | + uint64_t return_to = 18446744073709549210LLU; | |
57347 | 57651 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
57348 | 57652 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
57349 | 57653 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -57352,7 +57656,7 @@ | ||
57352 | 57656 | state.addr = 517555565476695680LLU; // assertu64_ |
57353 | 57657 | break; |
57354 | 57658 | } |
57355 | - case 18446744073709549223LLU: // 99999999Zl''''''''''''''' | |
57659 | + case 18446744073709549210LLU: // 99999999ZZ''''''''''''''' | |
57356 | 57660 | { |
57357 | 57661 | // ACCUMULATE ARGUMENTS - BEGIN |
57358 | 57662 | { |
@@ -57360,7 +57664,7 @@ | ||
57360 | 57664 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
57361 | 57665 | } |
57362 | 57666 | // ACCUMULATE ARGUMENTS - END |
57363 | - uint64_t return_to = 18446744073709549222LLU; | |
57667 | + uint64_t return_to = 18446744073709549209LLU; | |
57364 | 57668 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
57365 | 57669 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
57366 | 57670 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -57369,7 +57673,7 @@ | ||
57369 | 57673 | state.addr = 839519665163075584LLU; // skip______ |
57370 | 57674 | break; |
57371 | 57675 | } |
57372 | - case 18446744073709549222LLU: // 99999999Zk''''''''''''''' | |
57676 | + case 18446744073709549209LLU: // 99999999ZY''''''''''''''' | |
57373 | 57677 | { |
57374 | 57678 | matchid(")", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU))); |
57375 | 57679 | fprintf(stdout, "%s", ";"); |
@@ -57381,7 +57685,7 @@ | ||
57381 | 57685 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
57382 | 57686 | } |
57383 | 57687 | // ACCUMULATE ARGUMENTS - END |
57384 | - uint64_t return_to = 18446744073709549221LLU; | |
57688 | + uint64_t return_to = 18446744073709549208LLU; | |
57385 | 57689 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
57386 | 57690 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
57387 | 57691 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -57390,7 +57694,7 @@ | ||
57390 | 57694 | state.addr = 18446744073709551534LLU; // 999999998s''''''''''''''' |
57391 | 57695 | break; |
57392 | 57696 | } |
57393 | - case 18446744073709549221LLU: // 99999999Zj''''''''''''''' | |
57697 | + case 18446744073709549208LLU: // 99999999ZX''''''''''''''' | |
57394 | 57698 | { |
57395 | 57699 | (void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference single____ at 21 |
57396 | 57700 | // variable type______ type______ goes out of scope |
@@ -57401,7 +57705,7 @@ | ||
57401 | 57705 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
57402 | 57706 | } |
57403 | 57707 | // ACCUMULATE ARGUMENTS - END |
57404 | - uint64_t return_to = 18446744073709549220LLU; | |
57708 | + uint64_t return_to = 18446744073709549207LLU; | |
57405 | 57709 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
57406 | 57710 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
57407 | 57711 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -57410,7 +57714,7 @@ | ||
57410 | 57714 | state.addr = 18446744073709551573LLU; // 999999999U''''''''''''''' |
57411 | 57715 | break; |
57412 | 57716 | } |
57413 | - case 18446744073709549220LLU: // 99999999Zi''''''''''''''' | |
57717 | + case 18446744073709549207LLU: // 99999999ZW''''''''''''''' | |
57414 | 57718 | { |
57415 | 57719 | (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type______ at 20 |
57416 | 57720 | // variable u64 mutable___ goes out of scope |
@@ -57422,10 +57726,10 @@ | ||
57422 | 57726 | // variable u64 id________ goes out of scope |
57423 | 57727 | // emitted destructur for type u64 |
57424 | 57728 | (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id________ at 17 |
57425 | - state.addr = 18446744073709549238LLU; // 99999999Z0''''''''''''''' | |
57729 | + state.addr = 18446744073709549225LLU; // 99999999Zn''''''''''''''' | |
57426 | 57730 | break; |
57427 | 57731 | } |
57428 | - case 18446744073709549239LLU: // 99999999Z1''''''''''''''' | |
57732 | + case 18446744073709549226LLU: // 99999999Zo''''''''''''''' | |
57429 | 57733 | { |
57430 | 57734 | |
57431 | 57735 | *LOCAL_ACCESS(heap.data, 16LLU, 15LLU) = 715711700937998336; |
@@ -57436,11 +57740,11 @@ | ||
57436 | 57740 | LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
57437 | 57741 | } |
57438 | 57742 | *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 0LLU)); |
57439 | - state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549219LLU : 18446744073709549218LLU; | |
57743 | + state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549206LLU : 18446744073709549205LLU; | |
57440 | 57744 | (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 17 |
57441 | 57745 | break; |
57442 | 57746 | } |
57443 | - case 18446744073709549219LLU: // 99999999Zh''''''''''''''' | |
57747 | + case 18446744073709549206LLU: // 99999999ZV''''''''''''''' | |
57444 | 57748 | { |
57445 | 57749 | { |
57446 | 57750 | uint64_t arg = 0; |
@@ -57467,7 +57771,7 @@ | ||
57467 | 57771 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
57468 | 57772 | } |
57469 | 57773 | // ACCUMULATE ARGUMENTS - END |
57470 | - uint64_t return_to = 18446744073709549216LLU; | |
57774 | + uint64_t return_to = 18446744073709549203LLU; | |
57471 | 57775 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
57472 | 57776 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
57473 | 57777 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -57476,7 +57780,7 @@ | ||
57476 | 57780 | state.addr = 861504796319285248LLU; // typeu64___ |
57477 | 57781 | break; |
57478 | 57782 | } |
57479 | - case 18446744073709549216LLU: // 99999999Ze''''''''''''''' | |
57783 | + case 18446744073709549203LLU: // 99999999ZS''''''''''''''' | |
57480 | 57784 | { |
57481 | 57785 | { |
57482 | 57786 | uint64_t arg = 0; |
@@ -57501,7 +57805,7 @@ | ||
57501 | 57805 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
57502 | 57806 | } |
57503 | 57807 | // ACCUMULATE ARGUMENTS - END |
57504 | - uint64_t return_to = 18446744073709549214LLU; | |
57808 | + uint64_t return_to = 18446744073709549201LLU; | |
57505 | 57809 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
57506 | 57810 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
57507 | 57811 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -57510,7 +57814,7 @@ | ||
57510 | 57814 | state.addr = 861504796319285248LLU; // typeu64___ |
57511 | 57815 | break; |
57512 | 57816 | } |
57513 | - case 18446744073709549214LLU: // 99999999Zc''''''''''''''' | |
57817 | + case 18446744073709549201LLU: // 99999999ZQ''''''''''''''' | |
57514 | 57818 | { |
57515 | 57819 | { |
57516 | 57820 | uint64_t exchange = LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 23*/; |
@@ -57530,7 +57834,7 @@ | ||
57530 | 57834 | LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
57531 | 57835 | } |
57532 | 57836 | // ACCUMULATE ARGUMENTS - END |
57533 | - uint64_t return_to = 18446744073709549215LLU; | |
57837 | + uint64_t return_to = 18446744073709549202LLU; | |
57534 | 57838 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
57535 | 57839 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
57536 | 57840 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -57539,7 +57843,7 @@ | ||
57539 | 57843 | state.addr = 819859607768530944LLU; // resdest___ |
57540 | 57844 | break; |
57541 | 57845 | } |
57542 | - case 18446744073709549215LLU: // 99999999Zd''''''''''''''' | |
57846 | + case 18446744073709549202LLU: // 99999999ZR''''''''''''''' | |
57543 | 57847 | { |
57544 | 57848 | // ACCUMULATE ARGUMENTS - BEGIN |
57545 | 57849 | { |
@@ -57559,7 +57863,7 @@ | ||
57559 | 57863 | LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
57560 | 57864 | } |
57561 | 57865 | // ACCUMULATE ARGUMENTS - END |
57562 | - uint64_t return_to = 18446744073709549213LLU; | |
57866 | + uint64_t return_to = 18446744073709549200LLU; | |
57563 | 57867 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
57564 | 57868 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
57565 | 57869 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -57568,7 +57872,7 @@ | ||
57568 | 57872 | state.addr = 819857494882385920LLU; // res_u64___ |
57569 | 57873 | break; |
57570 | 57874 | } |
57571 | - case 18446744073709549213LLU: // 99999999Zb''''''''''''''' | |
57875 | + case 18446744073709549200LLU: // 99999999ZP''''''''''''''' | |
57572 | 57876 | { |
57573 | 57877 | // ACCUMULATE ARGUMENTS - BEGIN |
57574 | 57878 | { |
@@ -57576,7 +57880,7 @@ | ||
57576 | 57880 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
57577 | 57881 | } |
57578 | 57882 | // ACCUMULATE ARGUMENTS - END |
57579 | - uint64_t return_to = 18446744073709549212LLU; | |
57883 | + uint64_t return_to = 18446744073709549199LLU; | |
57580 | 57884 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
57581 | 57885 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
57582 | 57886 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -57585,7 +57889,7 @@ | ||
57585 | 57889 | state.addr = 839519665163075584LLU; // skip______ |
57586 | 57890 | break; |
57587 | 57891 | } |
57588 | - case 18446744073709549212LLU: // 99999999Za''''''''''''''' | |
57892 | + case 18446744073709549199LLU: // 99999999ZO''''''''''''''' | |
57589 | 57893 | { |
57590 | 57894 | matchid("(", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU))); |
57591 | 57895 | fprintf(stdout, "%s", "\n "); |
@@ -57611,7 +57915,7 @@ | ||
57611 | 57915 | LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
57612 | 57916 | } |
57613 | 57917 | // ACCUMULATE ARGUMENTS - END |
57614 | - uint64_t return_to = 18446744073709549211LLU; | |
57918 | + uint64_t return_to = 18446744073709549198LLU; | |
57615 | 57919 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)); |
57616 | 57920 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
57617 | 57921 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -57620,7 +57924,7 @@ | ||
57620 | 57924 | state.addr = 587881357514113024LLU; // emitpar___ |
57621 | 57925 | break; |
57622 | 57926 | } |
57623 | - case 18446744073709549211LLU: // 99999999Z$''''''''''''''' | |
57927 | + case 18446744073709549198LLU: // 99999999ZN''''''''''''''' | |
57624 | 57928 | { |
57625 | 57929 | fprintf(stdout, "%s", " = "); |
57626 | 57930 | // ACCUMULATE ARGUMENTS - BEGIN |
@@ -57629,7 +57933,7 @@ | ||
57629 | 57933 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
57630 | 57934 | } |
57631 | 57935 | // ACCUMULATE ARGUMENTS - END |
57632 | - uint64_t return_to = 18446744073709549210LLU; | |
57936 | + uint64_t return_to = 18446744073709549197LLU; | |
57633 | 57937 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
57634 | 57938 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
57635 | 57939 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -57638,7 +57942,7 @@ | ||
57638 | 57942 | state.addr = 839519665163075584LLU; // skip______ |
57639 | 57943 | break; |
57640 | 57944 | } |
57641 | - case 18446744073709549210LLU: // 99999999ZZ''''''''''''''' | |
57945 | + case 18446744073709549197LLU: // 99999999ZM''''''''''''''' | |
57642 | 57946 | { |
57643 | 57947 | |
57644 | 57948 | *LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU))); |
@@ -57660,7 +57964,7 @@ | ||
57660 | 57964 | LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
57661 | 57965 | } |
57662 | 57966 | // ACCUMULATE ARGUMENTS - END |
57663 | - uint64_t return_to = 18446744073709549209LLU; | |
57967 | + uint64_t return_to = 18446744073709549196LLU; | |
57664 | 57968 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
57665 | 57969 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
57666 | 57970 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -57669,7 +57973,7 @@ | ||
57669 | 57973 | state.addr = 23446349213393492LLU; // ASSERTINIT |
57670 | 57974 | break; |
57671 | 57975 | } |
57672 | - case 18446744073709549209LLU: // 99999999ZY''''''''''''''' | |
57976 | + case 18446744073709549196LLU: // 99999999ZL''''''''''''''' | |
57673 | 57977 | { |
57674 | 57978 | { |
57675 | 57979 | uint64_t arg = 0; |
@@ -57748,7 +58052,7 @@ | ||
57748 | 58052 | LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
57749 | 58053 | } |
57750 | 58054 | // ACCUMULATE ARGUMENTS - END |
57751 | - uint64_t return_to = 18446744073709549208LLU; | |
58055 | + uint64_t return_to = 18446744073709549195LLU; | |
57752 | 58056 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)); |
57753 | 58057 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
57754 | 58058 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -57757,7 +58061,7 @@ | ||
57757 | 58061 | state.addr = 293363126232490310LLU; // PROCVARREF |
57758 | 58062 | break; |
57759 | 58063 | } |
57760 | - case 18446744073709549208LLU: // 99999999ZX''''''''''''''' | |
58064 | + case 18446744073709549195LLU: // 99999999ZK''''''''''''''' | |
57761 | 58065 | { |
57762 | 58066 | // variable u64 initialize goes out of scope |
57763 | 58067 | // emitted destructur for type u64 |
@@ -57778,7 +58082,7 @@ | ||
57778 | 58082 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
57779 | 58083 | } |
57780 | 58084 | // ACCUMULATE ARGUMENTS - END |
57781 | - uint64_t return_to = 18446744073709549207LLU; | |
58085 | + uint64_t return_to = 18446744073709549194LLU; | |
57782 | 58086 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
57783 | 58087 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
57784 | 58088 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -57787,7 +58091,7 @@ | ||
57787 | 58091 | state.addr = 517555565476695680LLU; // assertu64_ |
57788 | 58092 | break; |
57789 | 58093 | } |
57790 | - case 18446744073709549207LLU: // 99999999ZW''''''''''''''' | |
58094 | + case 18446744073709549194LLU: // 99999999ZJ''''''''''''''' | |
57791 | 58095 | { |
57792 | 58096 | // ACCUMULATE ARGUMENTS - BEGIN |
57793 | 58097 | { |
@@ -57795,7 +58099,7 @@ | ||
57795 | 58099 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
57796 | 58100 | } |
57797 | 58101 | // ACCUMULATE ARGUMENTS - END |
57798 | - uint64_t return_to = 18446744073709549206LLU; | |
58102 | + uint64_t return_to = 18446744073709549193LLU; | |
57799 | 58103 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
57800 | 58104 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
57801 | 58105 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -57804,7 +58108,7 @@ | ||
57804 | 58108 | state.addr = 839519665163075584LLU; // skip______ |
57805 | 58109 | break; |
57806 | 58110 | } |
57807 | - case 18446744073709549206LLU: // 99999999ZV''''''''''''''' | |
58111 | + case 18446744073709549193LLU: // 99999999ZI''''''''''''''' | |
57808 | 58112 | { |
57809 | 58113 | matchid(",", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU))); |
57810 | 58114 | fprintf(stdout, "%s", " < "); |
@@ -57814,7 +58118,7 @@ | ||
57814 | 58118 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
57815 | 58119 | } |
57816 | 58120 | // ACCUMULATE ARGUMENTS - END |
57817 | - uint64_t return_to = 18446744073709549205LLU; | |
58121 | + uint64_t return_to = 18446744073709549192LLU; | |
57818 | 58122 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
57819 | 58123 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
57820 | 58124 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -57823,7 +58127,7 @@ | ||
57823 | 58127 | state.addr = 839519665163075584LLU; // skip______ |
57824 | 58128 | break; |
57825 | 58129 | } |
57826 | - case 18446744073709549205LLU: // 99999999ZU''''''''''''''' | |
58130 | + case 18446744073709549192LLU: // 99999999ZH''''''''''''''' | |
57827 | 58131 | { |
57828 | 58132 | |
57829 | 58133 | *LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU))); |
@@ -57845,7 +58149,7 @@ | ||
57845 | 58149 | LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
57846 | 58150 | } |
57847 | 58151 | // ACCUMULATE ARGUMENTS - END |
57848 | - uint64_t return_to = 18446744073709549204LLU; | |
58152 | + uint64_t return_to = 18446744073709549191LLU; | |
57849 | 58153 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
57850 | 58154 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
57851 | 58155 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -57854,7 +58158,7 @@ | ||
57854 | 58158 | state.addr = 23446349213393492LLU; // ASSERTINIT |
57855 | 58159 | break; |
57856 | 58160 | } |
57857 | - case 18446744073709549204LLU: // 99999999ZT''''''''''''''' | |
58161 | + case 18446744073709549191LLU: // 99999999ZG''''''''''''''' | |
57858 | 58162 | { |
57859 | 58163 | { |
57860 | 58164 | uint64_t arg = 0; |
@@ -57933,7 +58237,7 @@ | ||
57933 | 58237 | LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
57934 | 58238 | } |
57935 | 58239 | // ACCUMULATE ARGUMENTS - END |
57936 | - uint64_t return_to = 18446744073709549203LLU; | |
58240 | + uint64_t return_to = 18446744073709549190LLU; | |
57937 | 58241 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)); |
57938 | 58242 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
57939 | 58243 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -57942,7 +58246,7 @@ | ||
57942 | 58246 | state.addr = 293363126232490310LLU; // PROCVARREF |
57943 | 58247 | break; |
57944 | 58248 | } |
57945 | - case 18446744073709549203LLU: // 99999999ZS''''''''''''''' | |
58249 | + case 18446744073709549190LLU: // 99999999ZF''''''''''''''' | |
57946 | 58250 | { |
57947 | 58251 | // variable u64 initialize goes out of scope |
57948 | 58252 | // emitted destructur for type u64 |
@@ -57963,7 +58267,7 @@ | ||
57963 | 58267 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
57964 | 58268 | } |
57965 | 58269 | // ACCUMULATE ARGUMENTS - END |
57966 | - uint64_t return_to = 18446744073709549202LLU; | |
58270 | + uint64_t return_to = 18446744073709549189LLU; | |
57967 | 58271 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
57968 | 58272 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
57969 | 58273 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -57972,7 +58276,7 @@ | ||
57972 | 58276 | state.addr = 517555565476695680LLU; // assertu64_ |
57973 | 58277 | break; |
57974 | 58278 | } |
57975 | - case 18446744073709549202LLU: // 99999999ZR''''''''''''''' | |
58279 | + case 18446744073709549189LLU: // 99999999ZE''''''''''''''' | |
57976 | 58280 | { |
57977 | 58281 | // ACCUMULATE ARGUMENTS - BEGIN |
57978 | 58282 | { |
@@ -57980,7 +58284,7 @@ | ||
57980 | 58284 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
57981 | 58285 | } |
57982 | 58286 | // ACCUMULATE ARGUMENTS - END |
57983 | - uint64_t return_to = 18446744073709549201LLU; | |
58287 | + uint64_t return_to = 18446744073709549188LLU; | |
57984 | 58288 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
57985 | 58289 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
57986 | 58290 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -57989,7 +58293,7 @@ | ||
57989 | 58293 | state.addr = 839519665163075584LLU; // skip______ |
57990 | 58294 | break; |
57991 | 58295 | } |
57992 | - case 18446744073709549201LLU: // 99999999ZQ''''''''''''''' | |
58296 | + case 18446744073709549188LLU: // 99999999ZD''''''''''''''' | |
57993 | 58297 | { |
57994 | 58298 | matchid(")", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU))); |
57995 | 58299 | fprintf(stdout, "%s", ";"); |
@@ -58001,7 +58305,7 @@ | ||
58001 | 58305 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
58002 | 58306 | } |
58003 | 58307 | // ACCUMULATE ARGUMENTS - END |
58004 | - uint64_t return_to = 18446744073709549200LLU; | |
58308 | + uint64_t return_to = 18446744073709549187LLU; | |
58005 | 58309 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
58006 | 58310 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
58007 | 58311 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -58010,7 +58314,7 @@ | ||
58010 | 58314 | state.addr = 18446744073709551534LLU; // 999999998s''''''''''''''' |
58011 | 58315 | break; |
58012 | 58316 | } |
58013 | - case 18446744073709549200LLU: // 99999999ZP''''''''''''''' | |
58317 | + case 18446744073709549187LLU: // 99999999ZC''''''''''''''' | |
58014 | 58318 | { |
58015 | 58319 | (void)LOCAL_POP_MOVE(&heap, 21LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference single____ at 21 |
58016 | 58320 | // variable type______ type______ goes out of scope |
@@ -58021,7 +58325,7 @@ | ||
58021 | 58325 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
58022 | 58326 | } |
58023 | 58327 | // ACCUMULATE ARGUMENTS - END |
58024 | - uint64_t return_to = 18446744073709549199LLU; | |
58328 | + uint64_t return_to = 18446744073709549186LLU; | |
58025 | 58329 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
58026 | 58330 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
58027 | 58331 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -58030,7 +58334,7 @@ | ||
58030 | 58334 | state.addr = 18446744073709551573LLU; // 999999999U''''''''''''''' |
58031 | 58335 | break; |
58032 | 58336 | } |
58033 | - case 18446744073709549199LLU: // 99999999ZO''''''''''''''' | |
58337 | + case 18446744073709549186LLU: // 99999999ZB''''''''''''''' | |
58034 | 58338 | { |
58035 | 58339 | (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type______ at 20 |
58036 | 58340 | // variable u64 mutable___ goes out of scope |
@@ -58042,10 +58346,10 @@ | ||
58042 | 58346 | // variable u64 id________ goes out of scope |
58043 | 58347 | // emitted destructur for type u64 |
58044 | 58348 | (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id________ at 17 |
58045 | - state.addr = 18446744073709549217LLU; // 99999999Zf''''''''''''''' | |
58349 | + state.addr = 18446744073709549204LLU; // 99999999ZT''''''''''''''' | |
58046 | 58350 | break; |
58047 | 58351 | } |
58048 | - case 18446744073709549218LLU: // 99999999Zg''''''''''''''' | |
58352 | + case 18446744073709549205LLU: // 99999999ZU''''''''''''''' | |
58049 | 58353 | { |
58050 | 58354 | |
58051 | 58355 | *LOCAL_ACCESS(heap.data, 16LLU, 15LLU) = 728681540099244032; |
@@ -58056,11 +58360,11 @@ | ||
58056 | 58360 | LOCAL_PUSH_MOVE(&heap, 16, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
58057 | 58361 | } |
58058 | 58362 | *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) = /*builtin___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 0LLU)); |
58059 | - state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549198LLU : 18446744073709549197LLU; | |
58363 | + state.addr = *LOCAL_ACCESS(heap.data, 17LLU, 16LLU) ? 18446744073709549185LLU : 18446744073709549184LLU; | |
58060 | 58364 | (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 17 |
58061 | 58365 | break; |
58062 | 58366 | } |
58063 | - case 18446744073709549198LLU: // 99999999ZN''''''''''''''' | |
58367 | + case 18446744073709549185LLU: // 99999999ZA''''''''''''''' | |
58064 | 58368 | { |
58065 | 58369 | { |
58066 | 58370 | uint64_t arg = 0; |
@@ -58087,7 +58391,7 @@ | ||
58087 | 58391 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
58088 | 58392 | } |
58089 | 58393 | // ACCUMULATE ARGUMENTS - END |
58090 | - uint64_t return_to = 18446744073709549195LLU; | |
58394 | + uint64_t return_to = 18446744073709549182LLU; | |
58091 | 58395 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
58092 | 58396 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
58093 | 58397 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -58096,7 +58400,7 @@ | ||
58096 | 58400 | state.addr = 861504796319285248LLU; // typeu64___ |
58097 | 58401 | break; |
58098 | 58402 | } |
58099 | - case 18446744073709549195LLU: // 99999999ZK''''''''''''''' | |
58403 | + case 18446744073709549182LLU: // 99999999Y8''''''''''''''' | |
58100 | 58404 | { |
58101 | 58405 | { |
58102 | 58406 | uint64_t arg = 0; |
@@ -58121,7 +58425,7 @@ | ||
58121 | 58425 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
58122 | 58426 | } |
58123 | 58427 | // ACCUMULATE ARGUMENTS - END |
58124 | - uint64_t return_to = 18446744073709549193LLU; | |
58428 | + uint64_t return_to = 18446744073709549180LLU; | |
58125 | 58429 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
58126 | 58430 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
58127 | 58431 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -58130,7 +58434,7 @@ | ||
58130 | 58434 | state.addr = 861504796319285248LLU; // typeu64___ |
58131 | 58435 | break; |
58132 | 58436 | } |
58133 | - case 18446744073709549193LLU: // 99999999ZI''''''''''''''' | |
58437 | + case 18446744073709549180LLU: // 99999999Y6''''''''''''''' | |
58134 | 58438 | { |
58135 | 58439 | { |
58136 | 58440 | uint64_t exchange = LOCAL_POP_MOVE(&heap, 23LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 23*/; |
@@ -58150,7 +58454,7 @@ | ||
58150 | 58454 | LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
58151 | 58455 | } |
58152 | 58456 | // ACCUMULATE ARGUMENTS - END |
58153 | - uint64_t return_to = 18446744073709549194LLU; | |
58457 | + uint64_t return_to = 18446744073709549181LLU; | |
58154 | 58458 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
58155 | 58459 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
58156 | 58460 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -58159,7 +58463,7 @@ | ||
58159 | 58463 | state.addr = 819859607768530944LLU; // resdest___ |
58160 | 58464 | break; |
58161 | 58465 | } |
58162 | - case 18446744073709549194LLU: // 99999999ZJ''''''''''''''' | |
58466 | + case 18446744073709549181LLU: // 99999999Y7''''''''''''''' | |
58163 | 58467 | { |
58164 | 58468 | // ACCUMULATE ARGUMENTS - BEGIN |
58165 | 58469 | { |
@@ -58179,7 +58483,7 @@ | ||
58179 | 58483 | LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
58180 | 58484 | } |
58181 | 58485 | // ACCUMULATE ARGUMENTS - END |
58182 | - uint64_t return_to = 18446744073709549192LLU; | |
58486 | + uint64_t return_to = 18446744073709549179LLU; | |
58183 | 58487 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
58184 | 58488 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
58185 | 58489 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -58188,7 +58492,7 @@ | ||
58188 | 58492 | state.addr = 819857494882385920LLU; // res_u64___ |
58189 | 58493 | break; |
58190 | 58494 | } |
58191 | - case 18446744073709549192LLU: // 99999999ZH''''''''''''''' | |
58495 | + case 18446744073709549179LLU: // 99999999Y5''''''''''''''' | |
58192 | 58496 | { |
58193 | 58497 | // ACCUMULATE ARGUMENTS - BEGIN |
58194 | 58498 | { |
@@ -58196,7 +58500,7 @@ | ||
58196 | 58500 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
58197 | 58501 | } |
58198 | 58502 | // ACCUMULATE ARGUMENTS - END |
58199 | - uint64_t return_to = 18446744073709549191LLU; | |
58503 | + uint64_t return_to = 18446744073709549178LLU; | |
58200 | 58504 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
58201 | 58505 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
58202 | 58506 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -58205,7 +58509,7 @@ | ||
58205 | 58509 | state.addr = 839519665163075584LLU; // skip______ |
58206 | 58510 | break; |
58207 | 58511 | } |
58208 | - case 18446744073709549191LLU: // 99999999ZG''''''''''''''' | |
58512 | + case 18446744073709549178LLU: // 99999999Y4''''''''''''''' | |
58209 | 58513 | { |
58210 | 58514 | matchid("(", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU))); |
58211 | 58515 | fprintf(stdout, "%s", "\n "); |
@@ -58231,7 +58535,7 @@ | ||
58231 | 58535 | LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
58232 | 58536 | } |
58233 | 58537 | // ACCUMULATE ARGUMENTS - END |
58234 | - uint64_t return_to = 18446744073709549190LLU; | |
58538 | + uint64_t return_to = 18446744073709549177LLU; | |
58235 | 58539 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)); |
58236 | 58540 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
58237 | 58541 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -58240,7 +58544,7 @@ | ||
58240 | 58544 | state.addr = 587881357514113024LLU; // emitpar___ |
58241 | 58545 | break; |
58242 | 58546 | } |
58243 | - case 18446744073709549190LLU: // 99999999ZF''''''''''''''' | |
58547 | + case 18446744073709549177LLU: // 99999999Y3''''''''''''''' | |
58244 | 58548 | { |
58245 | 58549 | fprintf(stdout, "%s", " = max("); |
58246 | 58550 | // ACCUMULATE ARGUMENTS - BEGIN |
@@ -58249,7 +58553,7 @@ | ||
58249 | 58553 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
58250 | 58554 | } |
58251 | 58555 | // ACCUMULATE ARGUMENTS - END |
58252 | - uint64_t return_to = 18446744073709549189LLU; | |
58556 | + uint64_t return_to = 18446744073709549176LLU; | |
58253 | 58557 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
58254 | 58558 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
58255 | 58559 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -58258,7 +58562,7 @@ | ||
58258 | 58562 | state.addr = 839519665163075584LLU; // skip______ |
58259 | 58563 | break; |
58260 | 58564 | } |
58261 | - case 18446744073709549189LLU: // 99999999ZE''''''''''''''' | |
58565 | + case 18446744073709549176LLU: // 99999999Y2''''''''''''''' | |
58262 | 58566 | { |
58263 | 58567 | |
58264 | 58568 | *LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU))); |
@@ -58280,7 +58584,7 @@ | ||
58280 | 58584 | LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
58281 | 58585 | } |
58282 | 58586 | // ACCUMULATE ARGUMENTS - END |
58283 | - uint64_t return_to = 18446744073709549188LLU; | |
58587 | + uint64_t return_to = 18446744073709549175LLU; | |
58284 | 58588 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
58285 | 58589 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
58286 | 58590 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -58289,7 +58593,7 @@ | ||
58289 | 58593 | state.addr = 23446349213393492LLU; // ASSERTINIT |
58290 | 58594 | break; |
58291 | 58595 | } |
58292 | - case 18446744073709549188LLU: // 99999999ZD''''''''''''''' | |
58596 | + case 18446744073709549175LLU: // 99999999Y1''''''''''''''' | |
58293 | 58597 | { |
58294 | 58598 | { |
58295 | 58599 | uint64_t arg = 0; |
@@ -58368,7 +58672,7 @@ | ||
58368 | 58672 | LOCAL_PUSH_MOVE(&heap, 14LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
58369 | 58673 | } |
58370 | 58674 | // ACCUMULATE ARGUMENTS - END |
58371 | - uint64_t return_to = 18446744073709549187LLU; | |
58675 | + uint64_t return_to = 18446744073709549174LLU; | |
58372 | 58676 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)); |
58373 | 58677 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
58374 | 58678 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 15LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -58377,7 +58681,7 @@ | ||
58377 | 58681 | state.addr = 293363126232490310LLU; // PROCVARREF |
58378 | 58682 | break; |
58379 | 58683 | } |
58380 | - case 18446744073709549187LLU: // 99999999ZC''''''''''''''' | |
58684 | + case 18446744073709549174LLU: // 99999999Y0''''''''''''''' | |
58381 | 58685 | { |
58382 | 58686 | // variable u64 initialize goes out of scope |
58383 | 58687 | // emitted destructur for type u64 |
@@ -58398,7 +58702,7 @@ | ||
58398 | 58702 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
58399 | 58703 | } |
58400 | 58704 | // ACCUMULATE ARGUMENTS - END |
58401 | - uint64_t return_to = 18446744073709549186LLU; | |
58705 | + uint64_t return_to = 18446744073709549173LLU; | |
58402 | 58706 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
58403 | 58707 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
58404 | 58708 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -58407,7 +58711,7 @@ | ||
58407 | 58711 | state.addr = 517555565476695680LLU; // assertu64_ |
58408 | 58712 | break; |
58409 | 58713 | } |
58410 | - case 18446744073709549186LLU: // 99999999ZB''''''''''''''' | |
58714 | + case 18446744073709549173LLU: // 99999999Yz''''''''''''''' | |
58411 | 58715 | { |
58412 | 58716 | // ACCUMULATE ARGUMENTS - BEGIN |
58413 | 58717 | { |
@@ -58415,7 +58719,7 @@ | ||
58415 | 58719 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
58416 | 58720 | } |
58417 | 58721 | // ACCUMULATE ARGUMENTS - END |
58418 | - uint64_t return_to = 18446744073709549185LLU; | |
58722 | + uint64_t return_to = 18446744073709549172LLU; | |
58419 | 58723 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
58420 | 58724 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
58421 | 58725 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -58424,7 +58728,7 @@ | ||
58424 | 58728 | state.addr = 839519665163075584LLU; // skip______ |
58425 | 58729 | break; |
58426 | 58730 | } |
58427 | - case 18446744073709549185LLU: // 99999999ZA''''''''''''''' | |
58731 | + case 18446744073709549172LLU: // 99999999Yy''''''''''''''' | |
58428 | 58732 | { |
58429 | 58733 | matchid(",", &/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU))); |
58430 | 58734 | fprintf(stdout, "%s", ", "); |
@@ -58434,7 +58738,7 @@ | ||
58434 | 58738 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
58435 | 58739 | } |
58436 | 58740 | // ACCUMULATE ARGUMENTS - END |
58437 | - uint64_t return_to = 18446744073709549184LLU; | |
58741 | + uint64_t return_to = 18446744073709549171LLU; | |
58438 | 58742 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
58439 | 58743 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
58440 | 58744 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -58443,7 +58747,7 @@ | ||
58443 | 58747 | state.addr = 839519665163075584LLU; // skip______ |
58444 | 58748 | break; |
58445 | 58749 | } |
58446 | - case 18446744073709549184LLU: // 99999999Z_''''''''''''''' | |
58750 | + case 18446744073709549171LLU: // 99999999Yx''''''''''''''' | |
58447 | 58751 | { |
58448 | 58752 | |
58449 | 58753 | *LOCAL_ACCESS(heap.data, 21LLU, 16LLU) = parseid(&/*c_________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 21LLU, 7LLU))); |
@@ -58465,7 +58769,7 @@ | ||
58465 | 58769 | LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
58466 | 58770 | } |
58467 | 58771 | // ACCUMULATE ARGUMENTS - END |
58468 | - uint64_t return_to = 18446744073709549183LLU; | |
58772 | + uint64_t return_to = 18446744073709549170LLU; | |
58469 | 58773 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
58470 | 58774 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
58471 | 58775 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -58474,7 +58 |