Revisão | 999 (tree) |
---|---|
Hora | 2020-05-02 05:25:08 |
Autor | jakobthomsen |
fix built-in ite function
@@ -526,7 +526,7 @@ | ||
526 | 526 | |
527 | 527 | struct all init(struct pair *heapraw); |
528 | 528 | |
529 | -int main() | |
529 | +int main(int argc, char **args) | |
530 | 530 | { |
531 | 531 | #define MEMSIZE (408LLU + 1) |
532 | 532 | struct pair heapraw[33177LLU + 1]; |
@@ -5379,117 +5379,6 @@ | ||
5379 | 5379 | } |
5380 | 5380 | break; |
5381 | 5381 | } |
5382 | - case 288591296313750553LLU: // PARDEFCOPY | |
5383 | - { | |
5384 | - *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 0LLU)) = tree_init(&heap, 4LLU); | |
5385 | - { | |
5386 | - uint64_t arg = tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 2LLU, 0LLU), 0LLU); | |
5387 | - LOCAL_PUSH_MOVE(&heap, 2, &(heap.data[0].elem1)/*address of current closure*/, &arg); | |
5388 | - } | |
5389 | - { | |
5390 | - uint64_t arg = tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU), 1LLU); | |
5391 | - LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg); | |
5392 | - } | |
5393 | - { | |
5394 | - uint64_t arg = tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU), 2LLU); | |
5395 | - LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg); | |
5396 | - } | |
5397 | - { | |
5398 | - uint64_t arg = tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 5LLU, 0LLU), 3LLU); | |
5399 | - LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg); | |
5400 | - } | |
5401 | - { | |
5402 | - uint64_t arg = tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 6LLU, 1LLU), 0LLU); | |
5403 | - LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg); | |
5404 | - } | |
5405 | - { | |
5406 | - uint64_t arg = tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 7LLU, 1LLU), 1LLU); | |
5407 | - LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/*address of current closure*/, &arg); | |
5408 | - } | |
5409 | - { | |
5410 | - uint64_t arg = tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 8LLU, 1LLU), 2LLU); | |
5411 | - LOCAL_PUSH_MOVE(&heap, 8, &(heap.data[0].elem1)/*address of current closure*/, &arg); | |
5412 | - } | |
5413 | - { | |
5414 | - uint64_t arg = tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 9LLU, 1LLU), 3LLU); | |
5415 | - LOCAL_PUSH_MOVE(&heap, 9, &(heap.data[0].elem1)/*address of current closure*/, &arg); | |
5416 | - } | |
5417 | - | |
5418 | - // ACCUMULATE ARGUMENTS - BEGIN | |
5419 | - { | |
5420 | - uint64_t arg = *LOCAL_ACCESS(heap.data, 10LLU, 2LLU); | |
5421 | - LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
5422 | - } | |
5423 | - { | |
5424 | - uint64_t arg = /*type1_____*/*LOCAL_ACCESS(heap.data, 10LLU, 6LLU); | |
5425 | - LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
5426 | - } | |
5427 | - // ACCUMULATE ARGUMENTS - END | |
5428 | - uint64_t return_to = 18446744073709551426LLU; | |
5429 | - const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); | |
5430 | - uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); | |
5431 | - *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; | |
5432 | - heap.data[0].elem1 = heap.data[0].elem0; | |
5433 | - heap.data[0].elem0 = restore; | |
5434 | - state.addr = 367395560426147840LLU; // TYPECOPY__ | |
5435 | - break; | |
5436 | - } | |
5437 | - case 18446744073709551426LLU: // 999999997B''''''''''''''' | |
5438 | - { | |
5439 | - | |
5440 | - // ACCUMULATE ARGUMENTS - BEGIN | |
5441 | - { | |
5442 | - uint64_t arg = *LOCAL_ACCESS(heap.data, 10LLU, 4LLU); | |
5443 | - LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
5444 | - } | |
5445 | - { | |
5446 | - uint64_t arg = /*balance1__*/*LOCAL_ACCESS(heap.data, 10LLU, 8LLU); | |
5447 | - LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); | |
5448 | - } | |
5449 | - // ACCUMULATE ARGUMENTS - END | |
5450 | - uint64_t return_to = 18446744073709551425LLU; | |
5451 | - const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); | |
5452 | - uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); | |
5453 | - *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; | |
5454 | - heap.data[0].elem1 = heap.data[0].elem0; | |
5455 | - heap.data[0].elem0 = restore; | |
5456 | - state.addr = 58555672873677120LLU; // CPBALANCE_ | |
5457 | - break; | |
5458 | - } | |
5459 | - case 18446744073709551425LLU: // 999999997A''''''''''''''' | |
5460 | - { | |
5461 | - | |
5462 | - *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 10LLU, 3LLU)) = /*mutable1__*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 10LLU, 7LLU)); | |
5463 | - | |
5464 | - *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 10LLU, 5LLU)) = /*reference1*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 10LLU, 9LLU)); | |
5465 | - // parameter-reference u64 reference1 goes out of scope | |
5466 | - (void)LOCAL_POP_MOVE(&heap, 10LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference reference1 at 10 | |
5467 | - // parameter-reference continuity balance1__ goes out of scope | |
5468 | - (void)LOCAL_POP_MOVE(&heap, 9LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference balance1__ at 9 | |
5469 | - // parameter-reference u64 mutable1__ goes out of scope | |
5470 | - (void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference mutable1__ at 8 | |
5471 | - // parameter-reference type______ type1_____ goes out of scope | |
5472 | - (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type1_____ at 7 | |
5473 | - // parameter-reference pardef____ __________ goes out of scope | |
5474 | - (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 6 | |
5475 | - // parameter-reference u64 reference0 goes out of scope | |
5476 | - (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference reference0 at 5 | |
5477 | - // parameter-reference continuity balance0__ goes out of scope | |
5478 | - (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference balance0__ at 4 | |
5479 | - // parameter-reference u64 mutable0__ goes out of scope | |
5480 | - (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference mutable0__ at 3 | |
5481 | - // parameter-reference type______ type0_____ goes out of scope | |
5482 | - (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type0_____ at 2 | |
5483 | - // parameter-reference pardef____ __________ goes out of scope | |
5484 | - (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 1 | |
5485 | - { | |
5486 | - uint64_t baseinfo = heap.data[0].elem1; | |
5487 | - struct pair pair = unpair(&heap, &baseinfo); | |
5488 | - *access_heap(heap.data, 1/*memory root*/) = pair.elem0; | |
5489 | - state.addr = pair.elem1; | |
5490 | - } | |
5491 | - break; | |
5492 | - } | |
5493 | 5382 | case 296309897384864500LLU: // ParDefCopy |
5494 | 5383 | { |
5495 | 5384 | { |
@@ -5531,7 +5420,7 @@ | ||
5531 | 5420 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
5532 | 5421 | } |
5533 | 5422 | // ACCUMULATE ARGUMENTS - END |
5534 | - uint64_t return_to = 18446744073709551422LLU; | |
5423 | + uint64_t return_to = 18446744073709551425LLU; | |
5535 | 5424 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
5536 | 5425 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
5537 | 5426 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -5540,7 +5429,7 @@ | ||
5540 | 5429 | state.addr = 367395560426147840LLU; // TYPECOPY__ |
5541 | 5430 | break; |
5542 | 5431 | } |
5543 | - case 18446744073709551422LLU: // 9999999968''''''''''''''' | |
5432 | + case 18446744073709551425LLU: // 999999997A''''''''''''''' | |
5544 | 5433 | { |
5545 | 5434 | { |
5546 | 5435 | uint64_t exchange = LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 8*/; |
@@ -5569,7 +5458,7 @@ | ||
5569 | 5458 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
5570 | 5459 | } |
5571 | 5460 | // ACCUMULATE ARGUMENTS - END |
5572 | - uint64_t return_to = 18446744073709551421LLU; | |
5461 | + uint64_t return_to = 18446744073709551424LLU; | |
5573 | 5462 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
5574 | 5463 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
5575 | 5464 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -5578,7 +5467,7 @@ | ||
5578 | 5467 | state.addr = 552446646280519680LLU; // copyu64___ |
5579 | 5468 | break; |
5580 | 5469 | } |
5581 | - case 18446744073709551421LLU: // 9999999967''''''''''''''' | |
5470 | + case 18446744073709551424LLU: // 999999997_''''''''''''''' | |
5582 | 5471 | { |
5583 | 5472 | { |
5584 | 5473 | uint64_t exchange = LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 8*/; |
@@ -5607,7 +5496,7 @@ | ||
5607 | 5496 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
5608 | 5497 | } |
5609 | 5498 | // ACCUMULATE ARGUMENTS - END |
5610 | - uint64_t return_to = 18446744073709551420LLU; | |
5499 | + uint64_t return_to = 18446744073709551423LLU; | |
5611 | 5500 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
5612 | 5501 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
5613 | 5502 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -5616,7 +5505,7 @@ | ||
5616 | 5505 | state.addr = 58555672873677120LLU; // CPBALANCE_ |
5617 | 5506 | break; |
5618 | 5507 | } |
5619 | - case 18446744073709551420LLU: // 9999999966''''''''''''''' | |
5508 | + case 18446744073709551423LLU: // 9999999969''''''''''''''' | |
5620 | 5509 | { |
5621 | 5510 | { |
5622 | 5511 | uint64_t exchange = LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 8*/; |
@@ -5645,7 +5534,7 @@ | ||
5645 | 5534 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
5646 | 5535 | } |
5647 | 5536 | // ACCUMULATE ARGUMENTS - END |
5648 | - uint64_t return_to = 18446744073709551419LLU; | |
5537 | + uint64_t return_to = 18446744073709551422LLU; | |
5649 | 5538 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
5650 | 5539 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
5651 | 5540 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -5654,7 +5543,7 @@ | ||
5654 | 5543 | state.addr = 552446646280519680LLU; // copyu64___ |
5655 | 5544 | break; |
5656 | 5545 | } |
5657 | - case 18446744073709551419LLU: // 9999999965''''''''''''''' | |
5546 | + case 18446744073709551422LLU: // 9999999968''''''''''''''' | |
5658 | 5547 | { |
5659 | 5548 | { |
5660 | 5549 | uint64_t exchange = LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 8*/; |
@@ -5666,7 +5555,7 @@ | ||
5666 | 5555 | } |
5667 | 5556 | } |
5668 | 5557 | // ACCUMULATE ARGUMENTS - END |
5669 | - uint64_t return_to = 18446744073709551423LLU; | |
5558 | + uint64_t return_to = 18446744073709551426LLU; | |
5670 | 5559 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)); |
5671 | 5560 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
5672 | 5561 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -5675,7 +5564,7 @@ | ||
5675 | 5564 | state.addr = 782700512565788672LLU; // pardef____ |
5676 | 5565 | break; |
5677 | 5566 | } |
5678 | - case 18446744073709551423LLU: // 9999999969''''''''''''''' | |
5567 | + case 18446744073709551426LLU: // 999999997B''''''''''''''' | |
5679 | 5568 | { |
5680 | 5569 | // parameter-reference u64 reference1 goes out of scope |
5681 | 5570 | (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference reference1 at 6 |
@@ -5710,10 +5599,10 @@ | ||
5710 | 5599 | uint64_t arg = 0; |
5711 | 5600 | LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
5712 | 5601 | } |
5713 | - state.addr = 18446744073709551418LLU; // 9999999964''''''''''''''' | |
5602 | + state.addr = 18446744073709551421LLU; // 9999999967''''''''''''''' | |
5714 | 5603 | break; |
5715 | 5604 | } |
5716 | - case 18446744073709551418LLU: // 9999999964''''''''''''''' | |
5605 | + case 18446744073709551421LLU: // 9999999967''''''''''''''' | |
5717 | 5606 | { |
5718 | 5607 | if(!*LOCAL_ACCESS(heap.data, 5LLU, 3LLU)) |
5719 | 5608 | { |
@@ -5720,7 +5609,7 @@ | ||
5720 | 5609 | (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 5 |
5721 | 5610 | (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4 |
5722 | 5611 | { |
5723 | - state.addr = 18446744073709551417LLU; // 9999999963''''''''''''''' | |
5612 | + state.addr = 18446744073709551420LLU; // 9999999966''''''''''''''' | |
5724 | 5613 | break; |
5725 | 5614 | } |
5726 | 5615 | } |
@@ -5740,7 +5629,7 @@ | ||
5740 | 5629 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
5741 | 5630 | } |
5742 | 5631 | // ACCUMULATE ARGUMENTS - END |
5743 | - uint64_t return_to = 18446744073709551413LLU; | |
5632 | + uint64_t return_to = 18446744073709551416LLU; | |
5744 | 5633 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
5745 | 5634 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
5746 | 5635 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -5749,12 +5638,12 @@ | ||
5749 | 5638 | state.addr = 296309897384864500LLU; // ParDefCopy |
5750 | 5639 | break; |
5751 | 5640 | } |
5752 | - case 18446744073709551413LLU: // 999999996z''''''''''''''' | |
5641 | + case 18446744073709551416LLU: // 9999999962''''''''''''''' | |
5753 | 5642 | { |
5754 | - state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 6LLU, 5LLU), &*LOCAL_ACCESS(heap.data, 6LLU, 2LLU), 11) ? 18446744073709551416LLU : 18446744073709551415LLU; | |
5643 | + state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 6LLU, 5LLU), &*LOCAL_ACCESS(heap.data, 6LLU, 2LLU), 11) ? 18446744073709551419LLU : 18446744073709551418LLU; | |
5755 | 5644 | break; |
5756 | 5645 | } |
5757 | - case 18446744073709551416LLU: // 9999999962''''''''''''''' | |
5646 | + case 18446744073709551419LLU: // 9999999965''''''''''''''' | |
5758 | 5647 | { |
5759 | 5648 | { |
5760 | 5649 | fprintf(stderr, "%s\n", "INTERNAL ERROR: out of heap in pardefscp - recompile with increased heap-size"); |
@@ -5767,7 +5656,7 @@ | ||
5767 | 5656 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
5768 | 5657 | } |
5769 | 5658 | // ACCUMULATE ARGUMENTS - END |
5770 | - uint64_t return_to = 18446744073709551412LLU; | |
5659 | + uint64_t return_to = 18446744073709551415LLU; | |
5771 | 5660 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
5772 | 5661 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
5773 | 5662 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -5776,26 +5665,26 @@ | ||
5776 | 5665 | state.addr = 18446744073709551468LLU; // 999999997q''''''''''''''' |
5777 | 5666 | break; |
5778 | 5667 | } |
5779 | - case 18446744073709551412LLU: // 999999996y''''''''''''''' | |
5668 | + case 18446744073709551415LLU: // 9999999961''''''''''''''' | |
5780 | 5669 | { |
5781 | 5670 | // parameter pardef____ dst_______ goes out of scope |
5782 | - state.addr = 18446744073709551414LLU; // 9999999960''''''''''''''' | |
5671 | + state.addr = 18446744073709551417LLU; // 9999999963''''''''''''''' | |
5783 | 5672 | break; |
5784 | 5673 | } |
5785 | - case 18446744073709551415LLU: // 9999999961''''''''''''''' | |
5674 | + case 18446744073709551418LLU: // 9999999964''''''''''''''' | |
5786 | 5675 | { |
5787 | - state.addr = 18446744073709551414LLU; // 9999999960''''''''''''''' | |
5676 | + state.addr = 18446744073709551417LLU; // 9999999963''''''''''''''' | |
5788 | 5677 | break; |
5789 | 5678 | } |
5790 | - case 18446744073709551414LLU: // 9999999960''''''''''''''' | |
5679 | + case 18446744073709551417LLU: // 9999999963''''''''''''''' | |
5791 | 5680 | { |
5792 | 5681 | (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 6 |
5793 | 5682 | // parameter-reference pardef____ src_______ goes out of scope |
5794 | 5683 | // parameter-reference list<pardef____> srcs______ goes out of scope |
5795 | - state.addr = 18446744073709551418LLU; // 9999999964''''''''''''''' | |
5684 | + state.addr = 18446744073709551421LLU; // 9999999967''''''''''''''' | |
5796 | 5685 | break; |
5797 | 5686 | } |
5798 | - case 18446744073709551417LLU: // 9999999963''''''''''''''' | |
5687 | + case 18446744073709551420LLU: // 9999999966''''''''''''''' | |
5799 | 5688 | { |
5800 | 5689 | swap(&*LOCAL_ACCESS(heap.data, 3LLU, 2LLU), &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU))); // result |
5801 | 5690 | // variable list<pardef____> dsts______ goes out of scope |
@@ -5826,10 +5715,10 @@ | ||
5826 | 5715 | uint64_t arg = 0; |
5827 | 5716 | LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
5828 | 5717 | } |
5829 | - state.addr = 18446744073709551411LLU; // 999999996x''''''''''''''' | |
5718 | + state.addr = 18446744073709551414LLU; // 9999999960''''''''''''''' | |
5830 | 5719 | break; |
5831 | 5720 | } |
5832 | - case 18446744073709551411LLU: // 999999996x''''''''''''''' | |
5721 | + case 18446744073709551414LLU: // 9999999960''''''''''''''' | |
5833 | 5722 | { |
5834 | 5723 | if(!*LOCAL_ACCESS(heap.data, 6LLU, 4LLU)) |
5835 | 5724 | { |
@@ -5836,7 +5725,7 @@ | ||
5836 | 5725 | (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 6 |
5837 | 5726 | (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 5 |
5838 | 5727 | { |
5839 | - state.addr = 18446744073709551410LLU; // 999999996w''''''''''''''' | |
5728 | + state.addr = 18446744073709551413LLU; // 999999996z''''''''''''''' | |
5840 | 5729 | break; |
5841 | 5730 | } |
5842 | 5731 | } |
@@ -5866,7 +5755,7 @@ | ||
5866 | 5755 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
5867 | 5756 | } |
5868 | 5757 | // ACCUMULATE ARGUMENTS - END |
5869 | - uint64_t return_to = 18446744073709551409LLU; | |
5758 | + uint64_t return_to = 18446744073709551412LLU; | |
5870 | 5759 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
5871 | 5760 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
5872 | 5761 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -5875,7 +5764,7 @@ | ||
5875 | 5764 | state.addr = 367395560426147840LLU; // TYPECOPY__ |
5876 | 5765 | break; |
5877 | 5766 | } |
5878 | - case 18446744073709551409LLU: // 999999996v''''''''''''''' | |
5767 | + case 18446744073709551412LLU: // 999999996y''''''''''''''' | |
5879 | 5768 | { |
5880 | 5769 | { |
5881 | 5770 | uint64_t arg = 0; |
@@ -5887,7 +5776,7 @@ | ||
5887 | 5776 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
5888 | 5777 | } |
5889 | 5778 | // ACCUMULATE ARGUMENTS - END |
5890 | - uint64_t return_to = 18446744073709551408LLU; | |
5779 | + uint64_t return_to = 18446744073709551411LLU; | |
5891 | 5780 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
5892 | 5781 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
5893 | 5782 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -5896,7 +5785,7 @@ | ||
5896 | 5785 | state.addr = 552437437528276992LLU; // consume___ |
5897 | 5786 | break; |
5898 | 5787 | } |
5899 | - case 18446744073709551408LLU: // 999999996u''''''''''''''' | |
5788 | + case 18446744073709551411LLU: // 999999996x''''''''''''''' | |
5900 | 5789 | { |
5901 | 5790 | { |
5902 | 5791 | uint64_t arg = 0; |
@@ -5924,7 +5813,7 @@ | ||
5924 | 5813 | LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
5925 | 5814 | } |
5926 | 5815 | // ACCUMULATE ARGUMENTS - END |
5927 | - uint64_t return_to = 18446744073709551404LLU; | |
5816 | + uint64_t return_to = 18446744073709551407LLU; | |
5928 | 5817 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)); |
5929 | 5818 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
5930 | 5819 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -5933,12 +5822,12 @@ | ||
5933 | 5822 | state.addr = 782700512565788672LLU; // pardef____ |
5934 | 5823 | break; |
5935 | 5824 | } |
5936 | - case 18446744073709551404LLU: // 999999996q''''''''''''''' | |
5825 | + case 18446744073709551407LLU: // 999999996t''''''''''''''' | |
5937 | 5826 | { |
5938 | - state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 11LLU, 10LLU), &*LOCAL_ACCESS(heap.data, 11LLU, 3LLU), 11) ? 18446744073709551407LLU : 18446744073709551406LLU; | |
5827 | + state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 11LLU, 10LLU), &*LOCAL_ACCESS(heap.data, 11LLU, 3LLU), 11) ? 18446744073709551410LLU : 18446744073709551409LLU; | |
5939 | 5828 | break; |
5940 | 5829 | } |
5941 | - case 18446744073709551407LLU: // 999999996t''''''''''''''' | |
5830 | + case 18446744073709551410LLU: // 999999996w''''''''''''''' | |
5942 | 5831 | { |
5943 | 5832 | fprintf(stderr, "%s", "pushing par "); |
5944 | 5833 | // ACCUMULATE ARGUMENTS - BEGIN |
@@ -5947,7 +5836,7 @@ | ||
5947 | 5836 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
5948 | 5837 | } |
5949 | 5838 | // ACCUMULATE ARGUMENTS - END |
5950 | - uint64_t return_to = 18446744073709551403LLU; | |
5839 | + uint64_t return_to = 18446744073709551406LLU; | |
5951 | 5840 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
5952 | 5841 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
5953 | 5842 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -5956,7 +5845,7 @@ | ||
5956 | 5845 | state.addr = 819847183518878432LLU; // reporttype |
5957 | 5846 | break; |
5958 | 5847 | } |
5959 | - case 18446744073709551403LLU: // 999999996p''''''''''''''' | |
5848 | + case 18446744073709551406LLU: // 999999996s''''''''''''''' | |
5960 | 5849 | { |
5961 | 5850 | fprintf(stderr, "%s", "\n"); |
5962 | 5851 | { |
@@ -5970,7 +5859,7 @@ | ||
5970 | 5859 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
5971 | 5860 | } |
5972 | 5861 | // ACCUMULATE ARGUMENTS - END |
5973 | - uint64_t return_to = 18446744073709551402LLU; | |
5862 | + uint64_t return_to = 18446744073709551405LLU; | |
5974 | 5863 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
5975 | 5864 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
5976 | 5865 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -5979,18 +5868,18 @@ | ||
5979 | 5868 | state.addr = 18446744073709551468LLU; // 999999997q''''''''''''''' |
5980 | 5869 | break; |
5981 | 5870 | } |
5982 | - case 18446744073709551402LLU: // 999999996o''''''''''''''' | |
5871 | + case 18446744073709551405LLU: // 999999996r''''''''''''''' | |
5983 | 5872 | { |
5984 | 5873 | // parameter pardef____ newpar____ goes out of scope |
5985 | - state.addr = 18446744073709551405LLU; // 999999996r''''''''''''''' | |
5874 | + state.addr = 18446744073709551408LLU; // 999999996u''''''''''''''' | |
5986 | 5875 | break; |
5987 | 5876 | } |
5988 | - case 18446744073709551406LLU: // 999999996s''''''''''''''' | |
5877 | + case 18446744073709551409LLU: // 999999996v''''''''''''''' | |
5989 | 5878 | { |
5990 | - state.addr = 18446744073709551405LLU; // 999999996r''''''''''''''' | |
5879 | + state.addr = 18446744073709551408LLU; // 999999996u''''''''''''''' | |
5991 | 5880 | break; |
5992 | 5881 | } |
5993 | - case 18446744073709551405LLU: // 999999996r''''''''''''''' | |
5882 | + case 18446744073709551408LLU: // 999999996u''''''''''''''' | |
5994 | 5883 | { |
5995 | 5884 | (void)LOCAL_POP_MOVE(&heap, 11LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 11 |
5996 | 5885 | // variable continuity continuity goes out of scope |
@@ -6007,10 +5896,10 @@ | ||
6007 | 5896 | (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference mutable___ at 7 |
6008 | 5897 | // parameter-reference elemdef___ src_______ goes out of scope |
6009 | 5898 | // parameter-reference list<elemdef___> srcs______ goes out of scope |
6010 | - state.addr = 18446744073709551411LLU; // 999999996x''''''''''''''' | |
5899 | + state.addr = 18446744073709551414LLU; // 9999999960''''''''''''''' | |
6011 | 5900 | break; |
6012 | 5901 | } |
6013 | - case 18446744073709551410LLU: // 999999996w''''''''''''''' | |
5902 | + case 18446744073709551413LLU: // 999999996z''''''''''''''' | |
6014 | 5903 | { |
6015 | 5904 | swap(&*LOCAL_ACCESS(heap.data, 4LLU, 3LLU), &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU))); // result |
6016 | 5905 | // variable list<pardef____> dsts______ goes out of scope |
@@ -6062,7 +5951,7 @@ | ||
6062 | 5951 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
6063 | 5952 | } |
6064 | 5953 | // ACCUMULATE ARGUMENTS - END |
6065 | - uint64_t return_to = 18446744073709551399LLU; | |
5954 | + uint64_t return_to = 18446744073709551402LLU; | |
6066 | 5955 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
6067 | 5956 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
6068 | 5957 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -6071,7 +5960,7 @@ | ||
6071 | 5960 | state.addr = 552446646280519680LLU; // copyu64___ |
6072 | 5961 | break; |
6073 | 5962 | } |
6074 | - case 18446744073709551399LLU: // 999999996l''''''''''''''' | |
5963 | + case 18446744073709551402LLU: // 999999996o''''''''''''''' | |
6075 | 5964 | { |
6076 | 5965 | { |
6077 | 5966 | uint64_t exchange = LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 6*/; |
@@ -6100,7 +5989,7 @@ | ||
6100 | 5989 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
6101 | 5990 | } |
6102 | 5991 | // ACCUMULATE ARGUMENTS - END |
6103 | - uint64_t return_to = 18446744073709551398LLU; | |
5992 | + uint64_t return_to = 18446744073709551401LLU; | |
6104 | 5993 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
6105 | 5994 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
6106 | 5995 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -6109,7 +5998,7 @@ | ||
6109 | 5998 | state.addr = 367395560426147840LLU; // TYPECOPY__ |
6110 | 5999 | break; |
6111 | 6000 | } |
6112 | - case 18446744073709551398LLU: // 999999996k''''''''''''''' | |
6001 | + case 18446744073709551401LLU: // 999999996n''''''''''''''' | |
6113 | 6002 | { |
6114 | 6003 | { |
6115 | 6004 | uint64_t exchange = LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 6*/; |
@@ -6121,7 +6010,7 @@ | ||
6121 | 6010 | } |
6122 | 6011 | } |
6123 | 6012 | // ACCUMULATE ARGUMENTS - END |
6124 | - uint64_t return_to = 18446744073709551400LLU; | |
6013 | + uint64_t return_to = 18446744073709551403LLU; | |
6125 | 6014 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)); |
6126 | 6015 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
6127 | 6016 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -6130,7 +6019,7 @@ | ||
6130 | 6019 | state.addr = 587581796494082048LLU; // elemdef___ |
6131 | 6020 | break; |
6132 | 6021 | } |
6133 | - case 18446744073709551400LLU: // 999999996m''''''''''''''' | |
6022 | + case 18446744073709551403LLU: // 999999996p''''''''''''''' | |
6134 | 6023 | { |
6135 | 6024 | // parameter-reference type______ type1_____ goes out of scope |
6136 | 6025 | (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type1_____ at 4 |
@@ -6161,10 +6050,10 @@ | ||
6161 | 6050 | uint64_t arg = 0; |
6162 | 6051 | LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
6163 | 6052 | } |
6164 | - state.addr = 18446744073709551397LLU; // 999999996j''''''''''''''' | |
6053 | + state.addr = 18446744073709551400LLU; // 999999996m''''''''''''''' | |
6165 | 6054 | break; |
6166 | 6055 | } |
6167 | - case 18446744073709551397LLU: // 999999996j''''''''''''''' | |
6056 | + case 18446744073709551400LLU: // 999999996m''''''''''''''' | |
6168 | 6057 | { |
6169 | 6058 | if(!*LOCAL_ACCESS(heap.data, 5LLU, 3LLU)) |
6170 | 6059 | { |
@@ -6171,7 +6060,7 @@ | ||
6171 | 6060 | (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 5 |
6172 | 6061 | (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4 |
6173 | 6062 | { |
6174 | - state.addr = 18446744073709551396LLU; // 999999996i''''''''''''''' | |
6063 | + state.addr = 18446744073709551399LLU; // 999999996l''''''''''''''' | |
6175 | 6064 | break; |
6176 | 6065 | } |
6177 | 6066 | } |
@@ -6191,7 +6080,7 @@ | ||
6191 | 6080 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
6192 | 6081 | } |
6193 | 6082 | // ACCUMULATE ARGUMENTS - END |
6194 | - uint64_t return_to = 18446744073709551392LLU; | |
6083 | + uint64_t return_to = 18446744073709551395LLU; | |
6195 | 6084 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
6196 | 6085 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
6197 | 6086 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -6200,12 +6089,12 @@ | ||
6200 | 6089 | state.addr = 101193007747052544LLU; // ElemDefCP_ |
6201 | 6090 | break; |
6202 | 6091 | } |
6203 | - case 18446744073709551392LLU: // 999999996e''''''''''''''' | |
6092 | + case 18446744073709551395LLU: // 999999996h''''''''''''''' | |
6204 | 6093 | { |
6205 | - state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 6LLU, 5LLU), &*LOCAL_ACCESS(heap.data, 6LLU, 2LLU), 7) ? 18446744073709551395LLU : 18446744073709551394LLU; | |
6094 | + state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 6LLU, 5LLU), &*LOCAL_ACCESS(heap.data, 6LLU, 2LLU), 7) ? 18446744073709551398LLU : 18446744073709551397LLU; | |
6206 | 6095 | break; |
6207 | 6096 | } |
6208 | - case 18446744073709551395LLU: // 999999996h''''''''''''''' | |
6097 | + case 18446744073709551398LLU: // 999999996k''''''''''''''' | |
6209 | 6098 | { |
6210 | 6099 | fprintf(stderr, "%s", "pushing par "); |
6211 | 6100 | // ACCUMULATE ARGUMENTS - BEGIN |
@@ -6214,7 +6103,7 @@ | ||
6214 | 6103 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
6215 | 6104 | } |
6216 | 6105 | // ACCUMULATE ARGUMENTS - END |
6217 | - uint64_t return_to = 18446744073709551391LLU; | |
6106 | + uint64_t return_to = 18446744073709551394LLU; | |
6218 | 6107 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
6219 | 6108 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
6220 | 6109 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -6223,7 +6112,7 @@ | ||
6223 | 6112 | state.addr = 819847183518878432LLU; // reporttype |
6224 | 6113 | break; |
6225 | 6114 | } |
6226 | - case 18446744073709551391LLU: // 999999996d''''''''''''''' | |
6115 | + case 18446744073709551394LLU: // 999999996g''''''''''''''' | |
6227 | 6116 | { |
6228 | 6117 | fprintf(stderr, "%s", "\n"); |
6229 | 6118 | { |
@@ -6237,7 +6126,7 @@ | ||
6237 | 6126 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
6238 | 6127 | } |
6239 | 6128 | // ACCUMULATE ARGUMENTS - END |
6240 | - uint64_t return_to = 18446744073709551390LLU; | |
6129 | + uint64_t return_to = 18446744073709551393LLU; | |
6241 | 6130 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
6242 | 6131 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
6243 | 6132 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -6246,26 +6135,26 @@ | ||
6246 | 6135 | state.addr = 18446744073709551465LLU; // 999999997n''''''''''''''' |
6247 | 6136 | break; |
6248 | 6137 | } |
6249 | - case 18446744073709551390LLU: // 999999996c''''''''''''''' | |
6138 | + case 18446744073709551393LLU: // 999999996f''''''''''''''' | |
6250 | 6139 | { |
6251 | 6140 | // parameter elemdef___ dst_______ goes out of scope |
6252 | - state.addr = 18446744073709551393LLU; // 999999996f''''''''''''''' | |
6141 | + state.addr = 18446744073709551396LLU; // 999999996i''''''''''''''' | |
6253 | 6142 | break; |
6254 | 6143 | } |
6255 | - case 18446744073709551394LLU: // 999999996g''''''''''''''' | |
6144 | + case 18446744073709551397LLU: // 999999996j''''''''''''''' | |
6256 | 6145 | { |
6257 | - state.addr = 18446744073709551393LLU; // 999999996f''''''''''''''' | |
6146 | + state.addr = 18446744073709551396LLU; // 999999996i''''''''''''''' | |
6258 | 6147 | break; |
6259 | 6148 | } |
6260 | - case 18446744073709551393LLU: // 999999996f''''''''''''''' | |
6149 | + case 18446744073709551396LLU: // 999999996i''''''''''''''' | |
6261 | 6150 | { |
6262 | 6151 | (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 6 |
6263 | 6152 | // parameter-reference elemdef___ src_______ goes out of scope |
6264 | 6153 | // parameter-reference list<elemdef___> srcs______ goes out of scope |
6265 | - state.addr = 18446744073709551397LLU; // 999999996j''''''''''''''' | |
6154 | + state.addr = 18446744073709551400LLU; // 999999996m''''''''''''''' | |
6266 | 6155 | break; |
6267 | 6156 | } |
6268 | - case 18446744073709551396LLU: // 999999996i''''''''''''''' | |
6157 | + case 18446744073709551399LLU: // 999999996l''''''''''''''' | |
6269 | 6158 | { |
6270 | 6159 | swap(&*LOCAL_ACCESS(heap.data, 3LLU, 2LLU), &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU))); // result |
6271 | 6160 | // variable list<elemdef___> dsts______ goes out of scope |
@@ -6319,7 +6208,7 @@ | ||
6319 | 6208 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
6320 | 6209 | } |
6321 | 6210 | // ACCUMULATE ARGUMENTS - END |
6322 | - uint64_t return_to = 18446744073709551387LLU; | |
6211 | + uint64_t return_to = 18446744073709551390LLU; | |
6323 | 6212 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
6324 | 6213 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
6325 | 6214 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -6328,7 +6217,7 @@ | ||
6328 | 6217 | state.addr = 367395560426147840LLU; // TYPECOPY__ |
6329 | 6218 | break; |
6330 | 6219 | } |
6331 | - case 18446744073709551387LLU: // 999999996$''''''''''''''' | |
6220 | + case 18446744073709551390LLU: // 999999996c''''''''''''''' | |
6332 | 6221 | { |
6333 | 6222 | { |
6334 | 6223 | uint64_t exchange = LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 7*/; |
@@ -6357,7 +6246,7 @@ | ||
6357 | 6246 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
6358 | 6247 | } |
6359 | 6248 | // ACCUMULATE ARGUMENTS - END |
6360 | - uint64_t return_to = 18446744073709551386LLU; | |
6249 | + uint64_t return_to = 18446744073709551389LLU; | |
6361 | 6250 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
6362 | 6251 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
6363 | 6252 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -6366,7 +6255,7 @@ | ||
6366 | 6255 | state.addr = 552446646280519680LLU; // copyu64___ |
6367 | 6256 | break; |
6368 | 6257 | } |
6369 | - case 18446744073709551386LLU: // 999999996Z''''''''''''''' | |
6258 | + case 18446744073709551389LLU: // 999999996b''''''''''''''' | |
6370 | 6259 | { |
6371 | 6260 | { |
6372 | 6261 | uint64_t exchange = LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 7*/; |
@@ -6395,7 +6284,7 @@ | ||
6395 | 6284 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
6396 | 6285 | } |
6397 | 6286 | // ACCUMULATE ARGUMENTS - END |
6398 | - uint64_t return_to = 18446744073709551385LLU; | |
6287 | + uint64_t return_to = 18446744073709551388LLU; | |
6399 | 6288 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
6400 | 6289 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
6401 | 6290 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -6404,7 +6293,7 @@ | ||
6404 | 6293 | state.addr = 552446646280519680LLU; // copyu64___ |
6405 | 6294 | break; |
6406 | 6295 | } |
6407 | - case 18446744073709551385LLU: // 999999996Y''''''''''''''' | |
6296 | + case 18446744073709551388LLU: // 999999996a''''''''''''''' | |
6408 | 6297 | { |
6409 | 6298 | { |
6410 | 6299 | uint64_t exchange = LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 7*/; |
@@ -6416,7 +6305,7 @@ | ||
6416 | 6305 | } |
6417 | 6306 | } |
6418 | 6307 | // ACCUMULATE ARGUMENTS - END |
6419 | - uint64_t return_to = 18446744073709551388LLU; | |
6308 | + uint64_t return_to = 18446744073709551391LLU; | |
6420 | 6309 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
6421 | 6310 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
6422 | 6311 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -6425,7 +6314,7 @@ | ||
6425 | 6314 | state.addr = 819859607768530944LLU; // resdest___ |
6426 | 6315 | break; |
6427 | 6316 | } |
6428 | - case 18446744073709551388LLU: // 999999996a''''''''''''''' | |
6317 | + case 18446744073709551391LLU: // 999999996d''''''''''''''' | |
6429 | 6318 | { |
6430 | 6319 | // parameter-reference u64 reference1 goes out of scope |
6431 | 6320 | (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference reference1 at 5 |
@@ -6444,7 +6333,7 @@ | ||
6444 | 6333 | } |
6445 | 6334 | break; |
6446 | 6335 | } |
6447 | - case 18446744073709551384LLU: // 999999996X''''''''''''''' | |
6336 | + case 18446744073709551387LLU: // 999999996$''''''''''''''' | |
6448 | 6337 | { |
6449 | 6338 | { |
6450 | 6339 | uint64_t arg = tree_pop_move(&heap, 2LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))); |
@@ -6501,7 +6390,7 @@ | ||
6501 | 6390 | } |
6502 | 6391 | break; |
6503 | 6392 | } |
6504 | - case 18446744073709551383LLU: // 999999996W''''''''''''''' | |
6393 | + case 18446744073709551386LLU: // 999999996Z''''''''''''''' | |
6505 | 6394 | { |
6506 | 6395 | { |
6507 | 6396 | uint64_t arg = tree_pop_move(&heap, 7LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))); |
@@ -6543,14 +6432,14 @@ | ||
6543 | 6432 | LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
6544 | 6433 | } |
6545 | 6434 | // emitted destructur for type list<pardef____> |
6546 | - state.addr = 18446744073709551381LLU; // 999999996U''''''''''''''' | |
6435 | + state.addr = 18446744073709551384LLU; // 999999996X''''''''''''''' | |
6547 | 6436 | break; |
6548 | 6437 | } |
6549 | - case 18446744073709551381LLU: // 999999996U''''''''''''''' | |
6438 | + case 18446744073709551384LLU: // 999999996X''''''''''''''' | |
6550 | 6439 | { |
6551 | 6440 | if(!*LOCAL_ACCESS(heap.data, 2LLU, 1LLU)/*list*/) |
6552 | 6441 | { |
6553 | - state.addr = 18446744073709551382LLU; // 999999996V''''''''''''''' | |
6442 | + state.addr = 18446744073709551385LLU; // 999999996Y''''''''''''''' | |
6554 | 6443 | break; |
6555 | 6444 | } |
6556 | 6445 | // temporary list-element |
@@ -6564,7 +6453,7 @@ | ||
6564 | 6453 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
6565 | 6454 | } |
6566 | 6455 | // ACCUMULATE ARGUMENTS - END |
6567 | - uint64_t return_to = 18446744073709551380LLU; | |
6456 | + uint64_t return_to = 18446744073709551383LLU; | |
6568 | 6457 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
6569 | 6458 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
6570 | 6459 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -6573,14 +6462,14 @@ | ||
6573 | 6462 | state.addr = 18446744073709551468LLU; // 999999997q''''''''''''''' |
6574 | 6463 | break; |
6575 | 6464 | } |
6576 | - case 18446744073709551380LLU: // 999999996T''''''''''''''' | |
6465 | + case 18446744073709551383LLU: // 999999996W''''''''''''''' | |
6577 | 6466 | { |
6578 | 6467 | // RELEASE temporary destructor-variable |
6579 | 6468 | (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 3 |
6580 | - state.addr = 18446744073709551381LLU; // 999999996U''''''''''''''' | |
6469 | + state.addr = 18446744073709551384LLU; // 999999996X''''''''''''''' | |
6581 | 6470 | break; |
6582 | 6471 | } |
6583 | - case 18446744073709551382LLU: // 999999996V''''''''''''''' | |
6472 | + case 18446744073709551385LLU: // 999999996Y''''''''''''''' | |
6584 | 6473 | { |
6585 | 6474 | // RELEASE temporary destructor-variable |
6586 | 6475 | (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2 |
@@ -6589,14 +6478,14 @@ | ||
6589 | 6478 | LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
6590 | 6479 | } |
6591 | 6480 | // emitted destructur for type list<resdest___> |
6592 | - state.addr = 18446744073709551378LLU; // 999999996R''''''''''''''' | |
6481 | + state.addr = 18446744073709551381LLU; // 999999996U''''''''''''''' | |
6593 | 6482 | break; |
6594 | 6483 | } |
6595 | - case 18446744073709551378LLU: // 999999996R''''''''''''''' | |
6484 | + case 18446744073709551381LLU: // 999999996U''''''''''''''' | |
6596 | 6485 | { |
6597 | 6486 | if(!*LOCAL_ACCESS(heap.data, 2LLU, 1LLU)/*list*/) |
6598 | 6487 | { |
6599 | - state.addr = 18446744073709551379LLU; // 999999996S''''''''''''''' | |
6488 | + state.addr = 18446744073709551382LLU; // 999999996V''''''''''''''' | |
6600 | 6489 | break; |
6601 | 6490 | } |
6602 | 6491 | // temporary list-element |
@@ -6610,7 +6499,7 @@ | ||
6610 | 6499 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
6611 | 6500 | } |
6612 | 6501 | // ACCUMULATE ARGUMENTS - END |
6613 | - uint64_t return_to = 18446744073709551377LLU; | |
6502 | + uint64_t return_to = 18446744073709551380LLU; | |
6614 | 6503 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
6615 | 6504 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
6616 | 6505 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -6619,14 +6508,14 @@ | ||
6619 | 6508 | state.addr = 18446744073709551534LLU; // 999999998s''''''''''''''' |
6620 | 6509 | break; |
6621 | 6510 | } |
6622 | - case 18446744073709551377LLU: // 999999996Q''''''''''''''' | |
6511 | + case 18446744073709551380LLU: // 999999996T''''''''''''''' | |
6623 | 6512 | { |
6624 | 6513 | // RELEASE temporary destructor-variable |
6625 | 6514 | (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 3 |
6626 | - state.addr = 18446744073709551378LLU; // 999999996R''''''''''''''' | |
6515 | + state.addr = 18446744073709551381LLU; // 999999996U''''''''''''''' | |
6627 | 6516 | break; |
6628 | 6517 | } |
6629 | - case 18446744073709551379LLU: // 999999996S''''''''''''''' | |
6518 | + case 18446744073709551382LLU: // 999999996V''''''''''''''' | |
6630 | 6519 | { |
6631 | 6520 | // RELEASE temporary destructor-variable |
6632 | 6521 | (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2 |
@@ -6748,10 +6637,10 @@ | ||
6748 | 6637 | uint64_t arg = 0; |
6749 | 6638 | LOCAL_PUSH_MOVE(&heap, 11, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
6750 | 6639 | } |
6751 | - state.addr = 18446744073709551375LLU; // 999999996O''''''''''''''' | |
6640 | + state.addr = 18446744073709551378LLU; // 999999996R''''''''''''''' | |
6752 | 6641 | break; |
6753 | 6642 | } |
6754 | - case 18446744073709551375LLU: // 999999996O''''''''''''''' | |
6643 | + case 18446744073709551378LLU: // 999999996R''''''''''''''' | |
6755 | 6644 | { |
6756 | 6645 | if(!*LOCAL_ACCESS(heap.data, 12LLU, 10LLU)) |
6757 | 6646 | { |
@@ -6758,7 +6647,7 @@ | ||
6758 | 6647 | (void)LOCAL_POP_MOVE(&heap, 12LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 12 |
6759 | 6648 | (void)LOCAL_POP_MOVE(&heap, 11LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 11 |
6760 | 6649 | { |
6761 | - state.addr = 18446744073709551374LLU; // 999999996N''''''''''''''' | |
6650 | + state.addr = 18446744073709551377LLU; // 999999996Q''''''''''''''' | |
6762 | 6651 | break; |
6763 | 6652 | } |
6764 | 6653 | } |
@@ -6778,7 +6667,7 @@ | ||
6778 | 6667 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
6779 | 6668 | } |
6780 | 6669 | // ACCUMULATE ARGUMENTS - END |
6781 | - uint64_t return_to = 18446744073709551370LLU; | |
6670 | + uint64_t return_to = 18446744073709551373LLU; | |
6782 | 6671 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
6783 | 6672 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
6784 | 6673 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -6787,12 +6676,12 @@ | ||
6787 | 6676 | state.addr = 333468934555566080LLU; // ResCopy___ |
6788 | 6677 | break; |
6789 | 6678 | } |
6790 | - case 18446744073709551370LLU: // 999999996J''''''''''''''' | |
6679 | + case 18446744073709551373LLU: // 999999996M''''''''''''''' | |
6791 | 6680 | { |
6792 | - state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 13LLU, 12LLU), &*LOCAL_ACCESS(heap.data, 13LLU, 9LLU), 8) ? 18446744073709551373LLU : 18446744073709551372LLU; | |
6681 | + state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 13LLU, 12LLU), &*LOCAL_ACCESS(heap.data, 13LLU, 9LLU), 8) ? 18446744073709551376LLU : 18446744073709551375LLU; | |
6793 | 6682 | break; |
6794 | 6683 | } |
6795 | - case 18446744073709551373LLU: // 999999996M''''''''''''''' | |
6684 | + case 18446744073709551376LLU: // 999999996P''''''''''''''' | |
6796 | 6685 | { |
6797 | 6686 | { |
6798 | 6687 | fprintf(stderr, "%s\n", "INTERNAL ERROR in FunctionCp: out of dynamic heap - recompile compiler to reserve more dynamic heap"); |
@@ -6805,7 +6694,7 @@ | ||
6805 | 6694 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
6806 | 6695 | } |
6807 | 6696 | // ACCUMULATE ARGUMENTS - END |
6808 | - uint64_t return_to = 18446744073709551369LLU; | |
6697 | + uint64_t return_to = 18446744073709551372LLU; | |
6809 | 6698 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
6810 | 6699 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
6811 | 6700 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -6814,26 +6703,26 @@ | ||
6814 | 6703 | state.addr = 18446744073709551534LLU; // 999999998s''''''''''''''' |
6815 | 6704 | break; |
6816 | 6705 | } |
6817 | - case 18446744073709551369LLU: // 999999996I''''''''''''''' | |
6706 | + case 18446744073709551372LLU: // 999999996L''''''''''''''' | |
6818 | 6707 | { |
6819 | 6708 | // parameter resdest___ RP________ goes out of scope |
6820 | - state.addr = 18446744073709551371LLU; // 999999996K''''''''''''''' | |
6709 | + state.addr = 18446744073709551374LLU; // 999999996N''''''''''''''' | |
6821 | 6710 | break; |
6822 | 6711 | } |
6823 | - case 18446744073709551372LLU: // 999999996L''''''''''''''' | |
6712 | + case 18446744073709551375LLU: // 999999996O''''''''''''''' | |
6824 | 6713 | { |
6825 | - state.addr = 18446744073709551371LLU; // 999999996K''''''''''''''' | |
6714 | + state.addr = 18446744073709551374LLU; // 999999996N''''''''''''''' | |
6826 | 6715 | break; |
6827 | 6716 | } |
6828 | - case 18446744073709551371LLU: // 999999996K''''''''''''''' | |
6717 | + case 18446744073709551374LLU: // 999999996N''''''''''''''' | |
6829 | 6718 | { |
6830 | 6719 | (void)LOCAL_POP_MOVE(&heap, 13LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 13 |
6831 | 6720 | // parameter-reference resdest___ rp________ goes out of scope |
6832 | 6721 | // parameter-reference list<resdest___> resultpars goes out of scope |
6833 | - state.addr = 18446744073709551375LLU; // 999999996O''''''''''''''' | |
6722 | + state.addr = 18446744073709551378LLU; // 999999996R''''''''''''''' | |
6834 | 6723 | break; |
6835 | 6724 | } |
6836 | - case 18446744073709551374LLU: // 999999996N''''''''''''''' | |
6725 | + case 18446744073709551377LLU: // 999999996Q''''''''''''''' | |
6837 | 6726 | { |
6838 | 6727 | list_reverse(heap.data, &/*RESULTPARS*/*LOCAL_ACCESS(heap.data, 10LLU, 9LLU)); |
6839 | 6728 | { |
@@ -6848,10 +6737,10 @@ | ||
6848 | 6737 | uint64_t arg = 0; |
6849 | 6738 | LOCAL_PUSH_MOVE(&heap, 12, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
6850 | 6739 | } |
6851 | - state.addr = 18446744073709551368LLU; // 999999996H''''''''''''''' | |
6740 | + state.addr = 18446744073709551371LLU; // 999999996K''''''''''''''' | |
6852 | 6741 | break; |
6853 | 6742 | } |
6854 | - case 18446744073709551368LLU: // 999999996H''''''''''''''' | |
6743 | + case 18446744073709551371LLU: // 999999996K''''''''''''''' | |
6855 | 6744 | { |
6856 | 6745 | if(!*LOCAL_ACCESS(heap.data, 13LLU, 11LLU)) |
6857 | 6746 | { |
@@ -6858,7 +6747,7 @@ | ||
6858 | 6747 | (void)LOCAL_POP_MOVE(&heap, 13LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 13 |
6859 | 6748 | (void)LOCAL_POP_MOVE(&heap, 12LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 12 |
6860 | 6749 | { |
6861 | - state.addr = 18446744073709551367LLU; // 999999996G''''''''''''''' | |
6750 | + state.addr = 18446744073709551370LLU; // 999999996J''''''''''''''' | |
6862 | 6751 | break; |
6863 | 6752 | } |
6864 | 6753 | } |
@@ -6878,7 +6767,7 @@ | ||
6878 | 6767 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
6879 | 6768 | } |
6880 | 6769 | // ACCUMULATE ARGUMENTS - END |
6881 | - uint64_t return_to = 18446744073709551363LLU; | |
6770 | + uint64_t return_to = 18446744073709551366LLU; | |
6882 | 6771 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
6883 | 6772 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
6884 | 6773 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -6887,12 +6776,12 @@ | ||
6887 | 6776 | state.addr = 296309897384864500LLU; // ParDefCopy |
6888 | 6777 | break; |
6889 | 6778 | } |
6890 | - case 18446744073709551363LLU: // 999999996C''''''''''''''' | |
6779 | + case 18446744073709551366LLU: // 999999996F''''''''''''''' | |
6891 | 6780 | { |
6892 | - state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 14LLU, 13LLU), &*LOCAL_ACCESS(heap.data, 14LLU, 10LLU), 11) ? 18446744073709551366LLU : 18446744073709551365LLU; | |
6781 | + state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 14LLU, 13LLU), &*LOCAL_ACCESS(heap.data, 14LLU, 10LLU), 11) ? 18446744073709551369LLU : 18446744073709551368LLU; | |
6893 | 6782 | break; |
6894 | 6783 | } |
6895 | - case 18446744073709551366LLU: // 999999996F''''''''''''''' | |
6784 | + case 18446744073709551369LLU: // 999999996I''''''''''''''' | |
6896 | 6785 | { |
6897 | 6786 | { |
6898 | 6787 | fprintf(stderr, "%s\n", "INTERNAL ERROR in FunctionCp: out of dynamic heap - recompile compiler to reserve more dynamic heap"); |
@@ -6905,7 +6794,7 @@ | ||
6905 | 6794 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
6906 | 6795 | } |
6907 | 6796 | // ACCUMULATE ARGUMENTS - END |
6908 | - uint64_t return_to = 18446744073709551362LLU; | |
6797 | + uint64_t return_to = 18446744073709551365LLU; | |
6909 | 6798 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
6910 | 6799 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
6911 | 6800 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -6914,26 +6803,26 @@ | ||
6914 | 6803 | state.addr = 18446744073709551468LLU; // 999999997q''''''''''''''' |
6915 | 6804 | break; |
6916 | 6805 | } |
6917 | - case 18446744073709551362LLU: // 999999996B''''''''''''''' | |
6806 | + case 18446744073709551365LLU: // 999999996E''''''''''''''' | |
6918 | 6807 | { |
6919 | 6808 | // parameter pardef____ DP________ goes out of scope |
6920 | - state.addr = 18446744073709551364LLU; // 999999996D''''''''''''''' | |
6809 | + state.addr = 18446744073709551367LLU; // 999999996G''''''''''''''' | |
6921 | 6810 | break; |
6922 | 6811 | } |
6923 | - case 18446744073709551365LLU: // 999999996E''''''''''''''' | |
6812 | + case 18446744073709551368LLU: // 999999996H''''''''''''''' | |
6924 | 6813 | { |
6925 | - state.addr = 18446744073709551364LLU; // 999999996D''''''''''''''' | |
6814 | + state.addr = 18446744073709551367LLU; // 999999996G''''''''''''''' | |
6926 | 6815 | break; |
6927 | 6816 | } |
6928 | - case 18446744073709551364LLU: // 999999996D''''''''''''''' | |
6817 | + case 18446744073709551367LLU: // 999999996G''''''''''''''' | |
6929 | 6818 | { |
6930 | 6819 | (void)LOCAL_POP_MOVE(&heap, 14LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 14 |
6931 | 6820 | // parameter-reference pardef____ dp________ goes out of scope |
6932 | 6821 | // parameter-reference list<pardef____> defpars___ goes out of scope |
6933 | - state.addr = 18446744073709551368LLU; // 999999996H''''''''''''''' | |
6822 | + state.addr = 18446744073709551371LLU; // 999999996K''''''''''''''' | |
6934 | 6823 | break; |
6935 | 6824 | } |
6936 | - case 18446744073709551367LLU: // 999999996G''''''''''''''' | |
6825 | + case 18446744073709551370LLU: // 999999996J''''''''''''''' | |
6937 | 6826 | { |
6938 | 6827 | list_reverse(heap.data, &/*DEFPARS___*/*LOCAL_ACCESS(heap.data, 11LLU, 10LLU)); |
6939 | 6828 | // ACCUMULATE ARGUMENTS - BEGIN |
@@ -6967,7 +6856,7 @@ | ||
6967 | 6856 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
6968 | 6857 | } |
6969 | 6858 | // ACCUMULATE ARGUMENTS - END |
6970 | - uint64_t return_to = 18446744073709551360LLU; | |
6859 | + uint64_t return_to = 18446744073709551363LLU; | |
6971 | 6860 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
6972 | 6861 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
6973 | 6862 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -6976,7 +6865,7 @@ | ||
6976 | 6865 | state.addr = 552446646280519680LLU; // copyu64___ |
6977 | 6866 | break; |
6978 | 6867 | } |
6979 | - case 18446744073709551360LLU: // 999999996_''''''''''''''' | |
6868 | + case 18446744073709551363LLU: // 999999996C''''''''''''''' | |
6980 | 6869 | { |
6981 | 6870 | { |
6982 | 6871 | uint64_t exchange = LOCAL_POP_MOVE(&heap, 13LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 13*/; |
@@ -7005,7 +6894,7 @@ | ||
7005 | 6894 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
7006 | 6895 | } |
7007 | 6896 | // ACCUMULATE ARGUMENTS - END |
7008 | - uint64_t return_to = 18446744073709551359LLU; | |
6897 | + uint64_t return_to = 18446744073709551362LLU; | |
7009 | 6898 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
7010 | 6899 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
7011 | 6900 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -7014,7 +6903,7 @@ | ||
7014 | 6903 | state.addr = 552446646280519680LLU; // copyu64___ |
7015 | 6904 | break; |
7016 | 6905 | } |
7017 | - case 18446744073709551359LLU: // 9999999959''''''''''''''' | |
6906 | + case 18446744073709551362LLU: // 999999996B''''''''''''''' | |
7018 | 6907 | { |
7019 | 6908 | { |
7020 | 6909 | uint64_t exchange = LOCAL_POP_MOVE(&heap, 13LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 13*/; |
@@ -7043,7 +6932,7 @@ | ||
7043 | 6932 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
7044 | 6933 | } |
7045 | 6934 | // ACCUMULATE ARGUMENTS - END |
7046 | - uint64_t return_to = 18446744073709551358LLU; | |
6935 | + uint64_t return_to = 18446744073709551361LLU; | |
7047 | 6936 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
7048 | 6937 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
7049 | 6938 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -7052,7 +6941,7 @@ | ||
7052 | 6941 | state.addr = 552446646280519680LLU; // copyu64___ |
7053 | 6942 | break; |
7054 | 6943 | } |
7055 | - case 18446744073709551358LLU: // 9999999958''''''''''''''' | |
6944 | + case 18446744073709551361LLU: // 999999996A''''''''''''''' | |
7056 | 6945 | { |
7057 | 6946 | { |
7058 | 6947 | uint64_t exchange = LOCAL_POP_MOVE(&heap, 13LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 13*/; |
@@ -7081,7 +6970,7 @@ | ||
7081 | 6970 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
7082 | 6971 | } |
7083 | 6972 | // ACCUMULATE ARGUMENTS - END |
7084 | - uint64_t return_to = 18446744073709551357LLU; | |
6973 | + uint64_t return_to = 18446744073709551360LLU; | |
7085 | 6974 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
7086 | 6975 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
7087 | 6976 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -7090,7 +6979,7 @@ | ||
7090 | 6979 | state.addr = 552446646280519680LLU; // copyu64___ |
7091 | 6980 | break; |
7092 | 6981 | } |
7093 | - case 18446744073709551357LLU: // 9999999957''''''''''''''' | |
6982 | + case 18446744073709551360LLU: // 999999996_''''''''''''''' | |
7094 | 6983 | { |
7095 | 6984 | { |
7096 | 6985 | uint64_t exchange = LOCAL_POP_MOVE(&heap, 13LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 13*/; |
@@ -7119,7 +7008,7 @@ | ||
7119 | 7008 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
7120 | 7009 | } |
7121 | 7010 | // ACCUMULATE ARGUMENTS - END |
7122 | - uint64_t return_to = 18446744073709551356LLU; | |
7011 | + uint64_t return_to = 18446744073709551359LLU; | |
7123 | 7012 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
7124 | 7013 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
7125 | 7014 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -7128,7 +7017,7 @@ | ||
7128 | 7017 | state.addr = 552446646280519680LLU; // copyu64___ |
7129 | 7018 | break; |
7130 | 7019 | } |
7131 | - case 18446744073709551356LLU: // 9999999956''''''''''''''' | |
7020 | + case 18446744073709551359LLU: // 9999999959''''''''''''''' | |
7132 | 7021 | { |
7133 | 7022 | { |
7134 | 7023 | uint64_t exchange = LOCAL_POP_MOVE(&heap, 13LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 13*/; |
@@ -7140,7 +7029,7 @@ | ||
7140 | 7029 | } |
7141 | 7030 | } |
7142 | 7031 | // ACCUMULATE ARGUMENTS - END |
7143 | - uint64_t return_to = 18446744073709551361LLU; | |
7032 | + uint64_t return_to = 18446744073709551364LLU; | |
7144 | 7033 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 8LLU, 0/*address of closure-in-construction*/, 0)); |
7145 | 7034 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
7146 | 7035 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 8LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -7149,7 +7038,7 @@ | ||
7149 | 7038 | state.addr = 608168382267297792LLU; // function__ |
7150 | 7039 | break; |
7151 | 7040 | } |
7152 | - case 18446744073709551361LLU: // 999999996A''''''''''''''' | |
7041 | + case 18446744073709551364LLU: // 999999996D''''''''''''''' | |
7153 | 7042 | { |
7154 | 7043 | // variable list<pardef____> DEFPARS___ goes out of scope |
7155 | 7044 | // (uninitialized -> no destructor-call) |
@@ -7264,10 +7153,10 @@ | ||
7264 | 7153 | uint64_t arg = 0; |
7265 | 7154 | LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
7266 | 7155 | } |
7267 | - state.addr = 18446744073709551355LLU; // 9999999955''''''''''''''' | |
7156 | + state.addr = 18446744073709551358LLU; // 9999999958''''''''''''''' | |
7268 | 7157 | break; |
7269 | 7158 | } |
7270 | - case 18446744073709551355LLU: // 9999999955''''''''''''''' | |
7159 | + case 18446744073709551358LLU: // 9999999958''''''''''''''' | |
7271 | 7160 | { |
7272 | 7161 | if(!*LOCAL_ACCESS(heap.data, 8LLU, 6LLU)) |
7273 | 7162 | { |
@@ -7274,7 +7163,7 @@ | ||
7274 | 7163 | (void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 8 |
7275 | 7164 | (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 7 |
7276 | 7165 | { |
7277 | - state.addr = 18446744073709551354LLU; // 9999999954''''''''''''''' | |
7166 | + state.addr = 18446744073709551357LLU; // 9999999957''''''''''''''' | |
7278 | 7167 | break; |
7279 | 7168 | } |
7280 | 7169 | } |
@@ -7294,7 +7183,7 @@ | ||
7294 | 7183 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
7295 | 7184 | } |
7296 | 7185 | // ACCUMULATE ARGUMENTS - END |
7297 | - uint64_t return_to = 18446744073709551350LLU; | |
7186 | + uint64_t return_to = 18446744073709551353LLU; | |
7298 | 7187 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
7299 | 7188 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
7300 | 7189 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -7303,12 +7192,12 @@ | ||
7303 | 7192 | state.addr = 325750391286068249LLU; // RESDEFCOPY |
7304 | 7193 | break; |
7305 | 7194 | } |
7306 | - case 18446744073709551350LLU: // 9999999950''''''''''''''' | |
7195 | + case 18446744073709551353LLU: // 9999999953''''''''''''''' | |
7307 | 7196 | { |
7308 | - state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 9LLU, 8LLU), &*LOCAL_ACCESS(heap.data, 9LLU, 5LLU), 8) ? 18446744073709551353LLU : 18446744073709551352LLU; | |
7197 | + state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 9LLU, 8LLU), &*LOCAL_ACCESS(heap.data, 9LLU, 5LLU), 8) ? 18446744073709551356LLU : 18446744073709551355LLU; | |
7309 | 7198 | break; |
7310 | 7199 | } |
7311 | - case 18446744073709551353LLU: // 9999999953''''''''''''''' | |
7200 | + case 18446744073709551356LLU: // 9999999956''''''''''''''' | |
7312 | 7201 | { |
7313 | 7202 | { |
7314 | 7203 | fprintf(stderr, "%s\n", "out of dynamic heap in equfndef - recompile compiler with more dynamic heap memory"); |
@@ -7321,7 +7210,7 @@ | ||
7321 | 7210 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
7322 | 7211 | } |
7323 | 7212 | // ACCUMULATE ARGUMENTS - END |
7324 | - uint64_t return_to = 18446744073709551349LLU; | |
7213 | + uint64_t return_to = 18446744073709551352LLU; | |
7325 | 7214 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
7326 | 7215 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
7327 | 7216 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -7330,26 +7219,26 @@ | ||
7330 | 7219 | state.addr = 18446744073709551534LLU; // 999999998s''''''''''''''' |
7331 | 7220 | break; |
7332 | 7221 | } |
7333 | - case 18446744073709551349LLU: // 999999995z''''''''''''''' | |
7222 | + case 18446744073709551352LLU: // 9999999952''''''''''''''' | |
7334 | 7223 | { |
7335 | 7224 | // parameter resdest___ new_______ goes out of scope |
7336 | - state.addr = 18446744073709551351LLU; // 9999999951''''''''''''''' | |
7225 | + state.addr = 18446744073709551354LLU; // 9999999954''''''''''''''' | |
7337 | 7226 | break; |
7338 | 7227 | } |
7339 | - case 18446744073709551352LLU: // 9999999952''''''''''''''' | |
7228 | + case 18446744073709551355LLU: // 9999999955''''''''''''''' | |
7340 | 7229 | { |
7341 | - state.addr = 18446744073709551351LLU; // 9999999951''''''''''''''' | |
7230 | + state.addr = 18446744073709551354LLU; // 9999999954''''''''''''''' | |
7342 | 7231 | break; |
7343 | 7232 | } |
7344 | - case 18446744073709551351LLU: // 9999999951''''''''''''''' | |
7233 | + case 18446744073709551354LLU: // 9999999954''''''''''''''' | |
7345 | 7234 | { |
7346 | 7235 | (void)LOCAL_POP_MOVE(&heap, 9LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 9 |
7347 | 7236 | // parameter-reference resdest___ respar1___ goes out of scope |
7348 | 7237 | // parameter-reference list<resdest___> yresults__ goes out of scope |
7349 | - state.addr = 18446744073709551355LLU; // 9999999955''''''''''''''' | |
7238 | + state.addr = 18446744073709551358LLU; // 9999999958''''''''''''''' | |
7350 | 7239 | break; |
7351 | 7240 | } |
7352 | - case 18446744073709551354LLU: // 9999999954''''''''''''''' | |
7241 | + case 18446744073709551357LLU: // 9999999957''''''''''''''' | |
7353 | 7242 | { |
7354 | 7243 | list_reverse(heap.data, &/*yres______*/*LOCAL_ACCESS(heap.data, 6LLU, 5LLU)); |
7355 | 7244 | { |
@@ -7360,10 +7249,10 @@ | ||
7360 | 7249 | uint64_t arg = 0; |
7361 | 7250 | LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
7362 | 7251 | } |
7363 | - state.addr = 18446744073709551348LLU; // 999999995y''''''''''''''' | |
7252 | + state.addr = 18446744073709551351LLU; // 9999999951''''''''''''''' | |
7364 | 7253 | break; |
7365 | 7254 | } |
7366 | - case 18446744073709551348LLU: // 999999995y''''''''''''''' | |
7255 | + case 18446744073709551351LLU: // 9999999951''''''''''''''' | |
7367 | 7256 | { |
7368 | 7257 | if(!*LOCAL_ACCESS(heap.data, 8LLU, 6LLU)) |
7369 | 7258 | { |
@@ -7370,16 +7259,16 @@ | ||
7370 | 7259 | (void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 8 |
7371 | 7260 | (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 7 |
7372 | 7261 | { |
7373 | - state.addr = 18446744073709551347LLU; // 999999995x''''''''''''''' | |
7262 | + state.addr = 18446744073709551350LLU; // 9999999950''''''''''''''' | |
7374 | 7263 | break; |
7375 | 7264 | } |
7376 | 7265 | } |
7377 | 7266 | /*direct*/*LOCAL_ACCESS(heap.data, 8LLU, 7LLU) = (*LOCAL_ACCESS(heap.data, 8LLU, 6LLU) << 1) + 1LLU; |
7378 | 7267 | *LOCAL_ACCESS(heap.data, 8LLU, 6LLU) = heap.data[*LOCAL_ACCESS(heap.data, 8LLU, 6LLU)].elem0; |
7379 | - state.addr = /*yres______*/*LOCAL_ACCESS(heap.data, 8LLU, 5LLU) ? 18446744073709551346LLU : 18446744073709551345LLU; | |
7268 | + state.addr = /*yres______*/*LOCAL_ACCESS(heap.data, 8LLU, 5LLU) ? 18446744073709551349LLU : 18446744073709551348LLU; | |
7380 | 7269 | break; |
7381 | 7270 | } |
7382 | - case 18446744073709551346LLU: // 999999995w''''''''''''''' | |
7271 | + case 18446744073709551349LLU: // 999999995z''''''''''''''' | |
7383 | 7272 | { |
7384 | 7273 | { |
7385 | 7274 | uint64_t arg = list_pop_move(&heap, &*LOCAL_ACCESS(heap.data, 8LLU, 5LLU)/*list*/, 8); |
@@ -7404,7 +7293,7 @@ | ||
7404 | 7293 | LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
7405 | 7294 | } |
7406 | 7295 | // ACCUMULATE ARGUMENTS - END |
7407 | - uint64_t return_to = 18446744073709551343LLU; | |
7296 | + uint64_t return_to = 18446744073709551346LLU; | |
7408 | 7297 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)); |
7409 | 7298 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
7410 | 7299 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -7413,7 +7302,7 @@ | ||
7413 | 7302 | state.addr = 589059885019168768LLU; // equres____ |
7414 | 7303 | break; |
7415 | 7304 | } |
7416 | - case 18446744073709551343LLU: // 999999995t''''''''''''''' | |
7305 | + case 18446744073709551346LLU: // 999999995w''''''''''''''' | |
7417 | 7306 | { |
7418 | 7307 | |
7419 | 7308 | *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 10LLU, 0LLU)) = /*equal_____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 10LLU, 0LLU)) && /*EQUAL_____*/*LOCAL_ACCESS(heap.data, 10LLU, 9LLU); |
@@ -7428,7 +7317,7 @@ | ||
7428 | 7317 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
7429 | 7318 | } |
7430 | 7319 | // ACCUMULATE ARGUMENTS - END |
7431 | - uint64_t return_to = 18446744073709551342LLU; | |
7320 | + uint64_t return_to = 18446744073709551345LLU; | |
7432 | 7321 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
7433 | 7322 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
7434 | 7323 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -7437,32 +7326,32 @@ | ||
7437 | 7326 | state.addr = 18446744073709551534LLU; // 999999998s''''''''''''''' |
7438 | 7327 | break; |
7439 | 7328 | } |
7440 | - case 18446744073709551342LLU: // 999999995s''''''''''''''' | |
7329 | + case 18446744073709551345LLU: // 999999995v''''''''''''''' | |
7441 | 7330 | { |
7442 | 7331 | (void)LOCAL_POP_MOVE(&heap, 9LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference res1______ at 9 |
7443 | - state.addr = 18446744073709551344LLU; // 999999995u''''''''''''''' | |
7332 | + state.addr = 18446744073709551347LLU; // 999999995x''''''''''''''' | |
7444 | 7333 | break; |
7445 | 7334 | } |
7446 | - case 18446744073709551345LLU: // 999999995v''''''''''''''' | |
7335 | + case 18446744073709551348LLU: // 999999995y''''''''''''''' | |
7447 | 7336 | { |
7448 | 7337 | |
7449 | 7338 | *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 8LLU, 0LLU)) = 0; |
7450 | - state.addr = 18446744073709551344LLU; // 999999995u''''''''''''''' | |
7339 | + state.addr = 18446744073709551347LLU; // 999999995x''''''''''''''' | |
7451 | 7340 | break; |
7452 | 7341 | } |
7453 | - case 18446744073709551344LLU: // 999999995u''''''''''''''' | |
7342 | + case 18446744073709551347LLU: // 999999995x''''''''''''''' | |
7454 | 7343 | { |
7455 | 7344 | // parameter-reference resdest___ res0______ goes out of scope |
7456 | 7345 | // parameter-reference list<resdest___> xresults__ goes out of scope |
7457 | - state.addr = 18446744073709551348LLU; // 999999995y''''''''''''''' | |
7346 | + state.addr = 18446744073709551351LLU; // 9999999951''''''''''''''' | |
7458 | 7347 | break; |
7459 | 7348 | } |
7460 | - case 18446744073709551347LLU: // 999999995x''''''''''''''' | |
7349 | + case 18446744073709551350LLU: // 9999999950''''''''''''''' | |
7461 | 7350 | { |
7462 | - state.addr = /*yres______*/*LOCAL_ACCESS(heap.data, 6LLU, 5LLU) ? 18446744073709551341LLU : 18446744073709551340LLU; | |
7351 | + state.addr = /*yres______*/*LOCAL_ACCESS(heap.data, 6LLU, 5LLU) ? 18446744073709551344LLU : 18446744073709551343LLU; | |
7463 | 7352 | break; |
7464 | 7353 | } |
7465 | - case 18446744073709551341LLU: // 999999995r''''''''''''''' | |
7354 | + case 18446744073709551344LLU: // 999999995u''''''''''''''' | |
7466 | 7355 | { |
7467 | 7356 | { |
7468 | 7357 | uint64_t arg = list_pop_move(&heap, &*LOCAL_ACCESS(heap.data, 6LLU, 5LLU)/*list*/, 8); |
@@ -7478,7 +7367,7 @@ | ||
7478 | 7367 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
7479 | 7368 | } |
7480 | 7369 | // ACCUMULATE ARGUMENTS - END |
7481 | - uint64_t return_to = 18446744073709551338LLU; | |
7370 | + uint64_t return_to = 18446744073709551341LLU; | |
7482 | 7371 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
7483 | 7372 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
7484 | 7373 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -7487,29 +7376,29 @@ | ||
7487 | 7376 | state.addr = 18446744073709551534LLU; // 999999998s''''''''''''''' |
7488 | 7377 | break; |
7489 | 7378 | } |
7490 | - case 18446744073709551338LLU: // 999999995o''''''''''''''' | |
7379 | + case 18446744073709551341LLU: // 999999995r''''''''''''''' | |
7491 | 7380 | { |
7492 | 7381 | (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference res1______ at 7 |
7493 | - state.addr = 18446744073709551339LLU; // 999999995p''''''''''''''' | |
7382 | + state.addr = 18446744073709551342LLU; // 999999995s''''''''''''''' | |
7494 | 7383 | break; |
7495 | 7384 | } |
7496 | - case 18446744073709551340LLU: // 999999995q''''''''''''''' | |
7385 | + case 18446744073709551343LLU: // 999999995t''''''''''''''' | |
7497 | 7386 | { |
7498 | - state.addr = 18446744073709551339LLU; // 999999995p''''''''''''''' | |
7387 | + state.addr = 18446744073709551342LLU; // 999999995s''''''''''''''' | |
7499 | 7388 | break; |
7500 | 7389 | } |
7501 | - case 18446744073709551339LLU: // 999999995p''''''''''''''' | |
7390 | + case 18446744073709551342LLU: // 999999995s''''''''''''''' | |
7502 | 7391 | { |
7503 | 7392 | // variable list<resdest___> yres______ goes out of scope |
7504 | 7393 | // emitted destructur for type list<resdest___> |
7505 | - state.addr = 18446744073709551336LLU; // 999999995m''''''''''''''' | |
7394 | + state.addr = 18446744073709551339LLU; // 999999995p''''''''''''''' | |
7506 | 7395 | break; |
7507 | 7396 | } |
7508 | - case 18446744073709551336LLU: // 999999995m''''''''''''''' | |
7397 | + case 18446744073709551339LLU: // 999999995p''''''''''''''' | |
7509 | 7398 | { |
7510 | 7399 | if(!*LOCAL_ACCESS(heap.data, 6LLU, 5LLU)/*list*/) |
7511 | 7400 | { |
7512 | - state.addr = 18446744073709551337LLU; // 999999995n''''''''''''''' | |
7401 | + state.addr = 18446744073709551340LLU; // 999999995q''''''''''''''' | |
7513 | 7402 | break; |
7514 | 7403 | } |
7515 | 7404 | // temporary list-element |
@@ -7523,7 +7412,7 @@ | ||
7523 | 7412 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
7524 | 7413 | } |
7525 | 7414 | // ACCUMULATE ARGUMENTS - END |
7526 | - uint64_t return_to = 18446744073709551335LLU; | |
7415 | + uint64_t return_to = 18446744073709551338LLU; | |
7527 | 7416 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
7528 | 7417 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
7529 | 7418 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -7532,14 +7421,14 @@ | ||
7532 | 7421 | state.addr = 18446744073709551534LLU; // 999999998s''''''''''''''' |
7533 | 7422 | break; |
7534 | 7423 | } |
7535 | - case 18446744073709551335LLU: // 999999995l''''''''''''''' | |
7424 | + case 18446744073709551338LLU: // 999999995o''''''''''''''' | |
7536 | 7425 | { |
7537 | 7426 | // RELEASE temporary destructor-variable |
7538 | 7427 | (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 7 |
7539 | - state.addr = 18446744073709551336LLU; // 999999995m''''''''''''''' | |
7428 | + state.addr = 18446744073709551339LLU; // 999999995p''''''''''''''' | |
7540 | 7429 | break; |
7541 | 7430 | } |
7542 | - case 18446744073709551337LLU: // 999999995n''''''''''''''' | |
7431 | + case 18446744073709551340LLU: // 999999995q''''''''''''''' | |
7543 | 7432 | { |
7544 | 7433 | (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference yres______ at 6 |
7545 | 7434 | { |
@@ -7554,10 +7443,10 @@ | ||
7554 | 7443 | uint64_t arg = 0; |
7555 | 7444 | LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
7556 | 7445 | } |
7557 | - state.addr = 18446744073709551334LLU; // 999999995k''''''''''''''' | |
7446 | + state.addr = 18446744073709551337LLU; // 999999995n''''''''''''''' | |
7558 | 7447 | break; |
7559 | 7448 | } |
7560 | - case 18446744073709551334LLU: // 999999995k''''''''''''''' | |
7449 | + case 18446744073709551337LLU: // 999999995n''''''''''''''' | |
7561 | 7450 | { |
7562 | 7451 | if(!*LOCAL_ACCESS(heap.data, 8LLU, 6LLU)) |
7563 | 7452 | { |
@@ -7564,7 +7453,7 @@ | ||
7564 | 7453 | (void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 8 |
7565 | 7454 | (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 7 |
7566 | 7455 | { |
7567 | - state.addr = 18446744073709551333LLU; // 999999995j''''''''''''''' | |
7456 | + state.addr = 18446744073709551336LLU; // 999999995m''''''''''''''' | |
7568 | 7457 | break; |
7569 | 7458 | } |
7570 | 7459 | } |
@@ -7584,7 +7473,7 @@ | ||
7584 | 7473 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
7585 | 7474 | } |
7586 | 7475 | // ACCUMULATE ARGUMENTS - END |
7587 | - uint64_t return_to = 18446744073709551329LLU; | |
7476 | + uint64_t return_to = 18446744073709551332LLU; | |
7588 | 7477 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
7589 | 7478 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
7590 | 7479 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -7593,12 +7482,12 @@ | ||
7593 | 7482 | state.addr = 296309897384864500LLU; // ParDefCopy |
7594 | 7483 | break; |
7595 | 7484 | } |
7596 | - case 18446744073709551329LLU: // 999999995f''''''''''''''' | |
7485 | + case 18446744073709551332LLU: // 999999995i''''''''''''''' | |
7597 | 7486 | { |
7598 | - state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 9LLU, 8LLU), &*LOCAL_ACCESS(heap.data, 9LLU, 5LLU), 11) ? 18446744073709551332LLU : 18446744073709551331LLU; | |
7487 | + state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 9LLU, 8LLU), &*LOCAL_ACCESS(heap.data, 9LLU, 5LLU), 11) ? 18446744073709551335LLU : 18446744073709551334LLU; | |
7599 | 7488 | break; |
7600 | 7489 | } |
7601 | - case 18446744073709551332LLU: // 999999995i''''''''''''''' | |
7490 | + case 18446744073709551335LLU: // 999999995l''''''''''''''' | |
7602 | 7491 | { |
7603 | 7492 | { |
7604 | 7493 | fprintf(stderr, "%s\n", "out of dynamic heap in equfndef - recompile compiler with more dynamic heap memory"); |
@@ -7611,7 +7500,7 @@ | ||
7611 | 7500 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
7612 | 7501 | } |
7613 | 7502 | // ACCUMULATE ARGUMENTS - END |
7614 | - uint64_t return_to = 18446744073709551328LLU; | |
7503 | + uint64_t return_to = 18446744073709551331LLU; | |
7615 | 7504 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
7616 | 7505 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
7617 | 7506 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -7620,26 +7509,26 @@ | ||
7620 | 7509 | state.addr = 18446744073709551468LLU; // 999999997q''''''''''''''' |
7621 | 7510 | break; |
7622 | 7511 | } |
7623 | - case 18446744073709551328LLU: // 999999995e''''''''''''''' | |
7512 | + case 18446744073709551331LLU: // 999999995h''''''''''''''' | |
7624 | 7513 | { |
7625 | 7514 | // parameter pardef____ new_______ goes out of scope |
7626 | - state.addr = 18446744073709551330LLU; // 999999995g''''''''''''''' | |
7515 | + state.addr = 18446744073709551333LLU; // 999999995j''''''''''''''' | |
7627 | 7516 | break; |
7628 | 7517 | } |
7629 | - case 18446744073709551331LLU: // 999999995h''''''''''''''' | |
7518 | + case 18446744073709551334LLU: // 999999995k''''''''''''''' | |
7630 | 7519 | { |
7631 | - state.addr = 18446744073709551330LLU; // 999999995g''''''''''''''' | |
7520 | + state.addr = 18446744073709551333LLU; // 999999995j''''''''''''''' | |
7632 | 7521 | break; |
7633 | 7522 | } |
7634 | - case 18446744073709551330LLU: // 999999995g''''''''''''''' | |
7523 | + case 18446744073709551333LLU: // 999999995j''''''''''''''' | |
7635 | 7524 | { |
7636 | 7525 | (void)LOCAL_POP_MOVE(&heap, 9LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 9 |
7637 | 7526 | // parameter-reference pardef____ par1______ goes out of scope |
7638 | 7527 | // parameter-reference list<pardef____> ydefpars__ goes out of scope |
7639 | - state.addr = 18446744073709551334LLU; // 999999995k''''''''''''''' | |
7528 | + state.addr = 18446744073709551337LLU; // 999999995n''''''''''''''' | |
7640 | 7529 | break; |
7641 | 7530 | } |
7642 | - case 18446744073709551333LLU: // 999999995j''''''''''''''' | |
7531 | + case 18446744073709551336LLU: // 999999995m''''''''''''''' | |
7643 | 7532 | { |
7644 | 7533 | list_reverse(heap.data, &/*ypars_____*/*LOCAL_ACCESS(heap.data, 6LLU, 5LLU)); |
7645 | 7534 | { |
@@ -7650,10 +7539,10 @@ | ||
7650 | 7539 | uint64_t arg = 0; |
7651 | 7540 | LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
7652 | 7541 | } |
7653 | - state.addr = 18446744073709551327LLU; // 999999995d''''''''''''''' | |
7542 | + state.addr = 18446744073709551330LLU; // 999999995g''''''''''''''' | |
7654 | 7543 | break; |
7655 | 7544 | } |
7656 | - case 18446744073709551327LLU: // 999999995d''''''''''''''' | |
7545 | + case 18446744073709551330LLU: // 999999995g''''''''''''''' | |
7657 | 7546 | { |
7658 | 7547 | if(!*LOCAL_ACCESS(heap.data, 8LLU, 6LLU)) |
7659 | 7548 | { |
@@ -7660,16 +7549,16 @@ | ||
7660 | 7549 | (void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 8 |
7661 | 7550 | (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 7 |
7662 | 7551 | { |
7663 | - state.addr = 18446744073709551326LLU; // 999999995c''''''''''''''' | |
7552 | + state.addr = 18446744073709551329LLU; // 999999995f''''''''''''''' | |
7664 | 7553 | break; |
7665 | 7554 | } |
7666 | 7555 | } |
7667 | 7556 | /*direct*/*LOCAL_ACCESS(heap.data, 8LLU, 7LLU) = (*LOCAL_ACCESS(heap.data, 8LLU, 6LLU) << 1) + 1LLU; |
7668 | 7557 | *LOCAL_ACCESS(heap.data, 8LLU, 6LLU) = heap.data[*LOCAL_ACCESS(heap.data, 8LLU, 6LLU)].elem0; |
7669 | - state.addr = /*ypars_____*/*LOCAL_ACCESS(heap.data, 8LLU, 5LLU) ? 18446744073709551325LLU : 18446744073709551324LLU; | |
7558 | + state.addr = /*ypars_____*/*LOCAL_ACCESS(heap.data, 8LLU, 5LLU) ? 18446744073709551328LLU : 18446744073709551327LLU; | |
7670 | 7559 | break; |
7671 | 7560 | } |
7672 | - case 18446744073709551325LLU: // 999999995b''''''''''''''' | |
7561 | + case 18446744073709551328LLU: // 999999995e''''''''''''''' | |
7673 | 7562 | { |
7674 | 7563 | { |
7675 | 7564 | uint64_t arg = list_pop_move(&heap, &*LOCAL_ACCESS(heap.data, 8LLU, 5LLU)/*list*/, 11); |
@@ -7694,7 +7583,7 @@ | ||
7694 | 7583 | LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
7695 | 7584 | } |
7696 | 7585 | // ACCUMULATE ARGUMENTS - END |
7697 | - uint64_t return_to = 18446744073709551322LLU; | |
7586 | + uint64_t return_to = 18446744073709551325LLU; | |
7698 | 7587 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)); |
7699 | 7588 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
7700 | 7589 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -7703,7 +7592,7 @@ | ||
7703 | 7592 | state.addr = 589059743276730432LLU; // equpardef_ |
7704 | 7593 | break; |
7705 | 7594 | } |
7706 | - case 18446744073709551322LLU: // 999999995Z''''''''''''''' | |
7595 | + case 18446744073709551325LLU: // 999999995b''''''''''''''' | |
7707 | 7596 | { |
7708 | 7597 | |
7709 | 7598 | *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 10LLU, 0LLU)) = /*equal_____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 10LLU, 0LLU)) && /*EQUAL_____*/*LOCAL_ACCESS(heap.data, 10LLU, 9LLU); |
@@ -7718,7 +7607,7 @@ | ||
7718 | 7607 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
7719 | 7608 | } |
7720 | 7609 | // ACCUMULATE ARGUMENTS - END |
7721 | - uint64_t return_to = 18446744073709551321LLU; | |
7610 | + uint64_t return_to = 18446744073709551324LLU; | |
7722 | 7611 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
7723 | 7612 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
7724 | 7613 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -7727,32 +7616,32 @@ | ||
7727 | 7616 | state.addr = 18446744073709551468LLU; // 999999997q''''''''''''''' |
7728 | 7617 | break; |
7729 | 7618 | } |
7730 | - case 18446744073709551321LLU: // 999999995Y''''''''''''''' | |
7619 | + case 18446744073709551324LLU: // 999999995a''''''''''''''' | |
7731 | 7620 | { |
7732 | 7621 | (void)LOCAL_POP_MOVE(&heap, 9LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference par1______ at 9 |
7733 | - state.addr = 18446744073709551323LLU; // 999999995$''''''''''''''' | |
7622 | + state.addr = 18446744073709551326LLU; // 999999995c''''''''''''''' | |
7734 | 7623 | break; |
7735 | 7624 | } |
7736 | - case 18446744073709551324LLU: // 999999995a''''''''''''''' | |
7625 | + case 18446744073709551327LLU: // 999999995d''''''''''''''' | |
7737 | 7626 | { |
7738 | 7627 | |
7739 | 7628 | *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 8LLU, 0LLU)) = 0; |
7740 | - state.addr = 18446744073709551323LLU; // 999999995$''''''''''''''' | |
7629 | + state.addr = 18446744073709551326LLU; // 999999995c''''''''''''''' | |
7741 | 7630 | break; |
7742 | 7631 | } |
7743 | - case 18446744073709551323LLU: // 999999995$''''''''''''''' | |
7632 | + case 18446744073709551326LLU: // 999999995c''''''''''''''' | |
7744 | 7633 | { |
7745 | 7634 | // parameter-reference pardef____ par0______ goes out of scope |
7746 | 7635 | // parameter-reference list<pardef____> xdefpars__ goes out of scope |
7747 | - state.addr = 18446744073709551327LLU; // 999999995d''''''''''''''' | |
7636 | + state.addr = 18446744073709551330LLU; // 999999995g''''''''''''''' | |
7748 | 7637 | break; |
7749 | 7638 | } |
7750 | - case 18446744073709551326LLU: // 999999995c''''''''''''''' | |
7639 | + case 18446744073709551329LLU: // 999999995f''''''''''''''' | |
7751 | 7640 | { |
7752 | - state.addr = /*ypars_____*/*LOCAL_ACCESS(heap.data, 6LLU, 5LLU) ? 18446744073709551320LLU : 18446744073709551319LLU; | |
7641 | + state.addr = /*ypars_____*/*LOCAL_ACCESS(heap.data, 6LLU, 5LLU) ? 18446744073709551323LLU : 18446744073709551322LLU; | |
7753 | 7642 | break; |
7754 | 7643 | } |
7755 | - case 18446744073709551320LLU: // 999999995X''''''''''''''' | |
7644 | + case 18446744073709551323LLU: // 999999995$''''''''''''''' | |
7756 | 7645 | { |
7757 | 7646 | { |
7758 | 7647 | uint64_t arg = list_pop_move(&heap, &*LOCAL_ACCESS(heap.data, 6LLU, 5LLU)/*list*/, 11); |
@@ -7768,7 +7657,7 @@ | ||
7768 | 7657 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
7769 | 7658 | } |
7770 | 7659 | // ACCUMULATE ARGUMENTS - END |
7771 | - uint64_t return_to = 18446744073709551317LLU; | |
7660 | + uint64_t return_to = 18446744073709551320LLU; | |
7772 | 7661 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
7773 | 7662 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
7774 | 7663 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -7777,29 +7666,29 @@ | ||
7777 | 7666 | state.addr = 18446744073709551468LLU; // 999999997q''''''''''''''' |
7778 | 7667 | break; |
7779 | 7668 | } |
7780 | - case 18446744073709551317LLU: // 999999995U''''''''''''''' | |
7669 | + case 18446744073709551320LLU: // 999999995X''''''''''''''' | |
7781 | 7670 | { |
7782 | 7671 | (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference par1______ at 7 |
7783 | - state.addr = 18446744073709551318LLU; // 999999995V''''''''''''''' | |
7672 | + state.addr = 18446744073709551321LLU; // 999999995Y''''''''''''''' | |
7784 | 7673 | break; |
7785 | 7674 | } |
7786 | - case 18446744073709551319LLU: // 999999995W''''''''''''''' | |
7675 | + case 18446744073709551322LLU: // 999999995Z''''''''''''''' | |
7787 | 7676 | { |
7788 | - state.addr = 18446744073709551318LLU; // 999999995V''''''''''''''' | |
7677 | + state.addr = 18446744073709551321LLU; // 999999995Y''''''''''''''' | |
7789 | 7678 | break; |
7790 | 7679 | } |
7791 | - case 18446744073709551318LLU: // 999999995V''''''''''''''' | |
7680 | + case 18446744073709551321LLU: // 999999995Y''''''''''''''' | |
7792 | 7681 | { |
7793 | 7682 | // variable list<pardef____> ypars_____ goes out of scope |
7794 | 7683 | // emitted destructur for type list<pardef____> |
7795 | - state.addr = 18446744073709551315LLU; // 999999995S''''''''''''''' | |
7684 | + state.addr = 18446744073709551318LLU; // 999999995V''''''''''''''' | |
7796 | 7685 | break; |
7797 | 7686 | } |
7798 | - case 18446744073709551315LLU: // 999999995S''''''''''''''' | |
7687 | + case 18446744073709551318LLU: // 999999995V''''''''''''''' | |
7799 | 7688 | { |
7800 | 7689 | if(!*LOCAL_ACCESS(heap.data, 6LLU, 5LLU)/*list*/) |
7801 | 7690 | { |
7802 | - state.addr = 18446744073709551316LLU; // 999999995T''''''''''''''' | |
7691 | + state.addr = 18446744073709551319LLU; // 999999995W''''''''''''''' | |
7803 | 7692 | break; |
7804 | 7693 | } |
7805 | 7694 | // temporary list-element |
@@ -7813,7 +7702,7 @@ | ||
7813 | 7702 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
7814 | 7703 | } |
7815 | 7704 | // ACCUMULATE ARGUMENTS - END |
7816 | - uint64_t return_to = 18446744073709551314LLU; | |
7705 | + uint64_t return_to = 18446744073709551317LLU; | |
7817 | 7706 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
7818 | 7707 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
7819 | 7708 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -7822,14 +7711,14 @@ | ||
7822 | 7711 | state.addr = 18446744073709551468LLU; // 999999997q''''''''''''''' |
7823 | 7712 | break; |
7824 | 7713 | } |
7825 | - case 18446744073709551314LLU: // 999999995R''''''''''''''' | |
7714 | + case 18446744073709551317LLU: // 999999995U''''''''''''''' | |
7826 | 7715 | { |
7827 | 7716 | // RELEASE temporary destructor-variable |
7828 | 7717 | (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 7 |
7829 | - state.addr = 18446744073709551315LLU; // 999999995S''''''''''''''' | |
7718 | + state.addr = 18446744073709551318LLU; // 999999995V''''''''''''''' | |
7830 | 7719 | break; |
7831 | 7720 | } |
7832 | - case 18446744073709551316LLU: // 999999995T''''''''''''''' | |
7721 | + case 18446744073709551319LLU: // 999999995W''''''''''''''' | |
7833 | 7722 | { |
7834 | 7723 | (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference ypars_____ at 6 |
7835 | 7724 | // parameter-reference list<pardef____> ydefpars__ goes out of scope |
@@ -7866,10 +7755,10 @@ | ||
7866 | 7755 | uint64_t arg = 0; |
7867 | 7756 | LOCAL_PUSH_MOVE(&heap, 17, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
7868 | 7757 | } |
7869 | - state.addr = 18446744073709551313LLU; // 999999995Q''''''''''''''' | |
7758 | + state.addr = 18446744073709551316LLU; // 999999995T''''''''''''''' | |
7870 | 7759 | break; |
7871 | 7760 | } |
7872 | - case 18446744073709551313LLU: // 999999995Q''''''''''''''' | |
7761 | + case 18446744073709551316LLU: // 999999995T''''''''''''''' | |
7873 | 7762 | { |
7874 | 7763 | if(!*LOCAL_ACCESS(heap.data, 18LLU, 16LLU)) |
7875 | 7764 | { |
@@ -7876,7 +7765,7 @@ | ||
7876 | 7765 | (void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 18 |
7877 | 7766 | (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 17 |
7878 | 7767 | { |
7879 | - state.addr = 18446744073709551312LLU; // 999999995P''''''''''''''' | |
7768 | + state.addr = 18446744073709551315LLU; // 999999995S''''''''''''''' | |
7880 | 7769 | break; |
7881 | 7770 | } |
7882 | 7771 | } |
@@ -7896,7 +7785,7 @@ | ||
7896 | 7785 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
7897 | 7786 | } |
7898 | 7787 | // ACCUMULATE ARGUMENTS - END |
7899 | - uint64_t return_to = 18446744073709551308LLU; | |
7788 | + uint64_t return_to = 18446744073709551311LLU; | |
7900 | 7789 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
7901 | 7790 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
7902 | 7791 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -7905,12 +7794,12 @@ | ||
7905 | 7794 | state.addr = 325750391286068249LLU; // RESDEFCOPY |
7906 | 7795 | break; |
7907 | 7796 | } |
7908 | - case 18446744073709551308LLU: // 999999995L''''''''''''''' | |
7797 | + case 18446744073709551311LLU: // 999999995O''''''''''''''' | |
7909 | 7798 | { |
7910 | - state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 19LLU, 18LLU), &*LOCAL_ACCESS(heap.data, 19LLU, 15LLU), 8) ? 18446744073709551311LLU : 18446744073709551310LLU; | |
7799 | + state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 19LLU, 18LLU), &*LOCAL_ACCESS(heap.data, 19LLU, 15LLU), 8) ? 18446744073709551314LLU : 18446744073709551313LLU; | |
7911 | 7800 | break; |
7912 | 7801 | } |
7913 | - case 18446744073709551311LLU: // 999999995O''''''''''''''' | |
7802 | + case 18446744073709551314LLU: // 999999995R''''''''''''''' | |
7914 | 7803 | { |
7915 | 7804 | { |
7916 | 7805 | fprintf(stderr, "%s\n", "out of dynamic heap in equfndef - recompile compiler with more dynamic heap memory"); |
@@ -7923,7 +7812,7 @@ | ||
7923 | 7812 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
7924 | 7813 | } |
7925 | 7814 | // ACCUMULATE ARGUMENTS - END |
7926 | - uint64_t return_to = 18446744073709551307LLU; | |
7815 | + uint64_t return_to = 18446744073709551310LLU; | |
7927 | 7816 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
7928 | 7817 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
7929 | 7818 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -7932,26 +7821,26 @@ | ||
7932 | 7821 | state.addr = 18446744073709551534LLU; // 999999998s''''''''''''''' |
7933 | 7822 | break; |
7934 | 7823 | } |
7935 | - case 18446744073709551307LLU: // 999999995K''''''''''''''' | |
7824 | + case 18446744073709551310LLU: // 999999995N''''''''''''''' | |
7936 | 7825 | { |
7937 | 7826 | // parameter resdest___ new_______ goes out of scope |
7938 | - state.addr = 18446744073709551309LLU; // 999999995M''''''''''''''' | |
7827 | + state.addr = 18446744073709551312LLU; // 999999995P''''''''''''''' | |
7939 | 7828 | break; |
7940 | 7829 | } |
7941 | - case 18446744073709551310LLU: // 999999995N''''''''''''''' | |
7830 | + case 18446744073709551313LLU: // 999999995Q''''''''''''''' | |
7942 | 7831 | { |
7943 | - state.addr = 18446744073709551309LLU; // 999999995M''''''''''''''' | |
7832 | + state.addr = 18446744073709551312LLU; // 999999995P''''''''''''''' | |
7944 | 7833 | break; |
7945 | 7834 | } |
7946 | - case 18446744073709551309LLU: // 999999995M''''''''''''''' | |
7835 | + case 18446744073709551312LLU: // 999999995P''''''''''''''' | |
7947 | 7836 | { |
7948 | 7837 | (void)LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 19 |
7949 | 7838 | // parameter-reference resdest___ respar1___ goes out of scope |
7950 | 7839 | // parameter-reference list<resdest___> yresults__ goes out of scope |
7951 | - state.addr = 18446744073709551313LLU; // 999999995Q''''''''''''''' | |
7840 | + state.addr = 18446744073709551316LLU; // 999999995T''''''''''''''' | |
7952 | 7841 | break; |
7953 | 7842 | } |
7954 | - case 18446744073709551312LLU: // 999999995P''''''''''''''' | |
7843 | + case 18446744073709551315LLU: // 999999995S''''''''''''''' | |
7955 | 7844 | { |
7956 | 7845 | list_reverse(heap.data, &/*yres______*/*LOCAL_ACCESS(heap.data, 16LLU, 15LLU)); |
7957 | 7846 | { |
@@ -7962,10 +7851,10 @@ | ||
7962 | 7851 | uint64_t arg = 0; |
7963 | 7852 | LOCAL_PUSH_MOVE(&heap, 17, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
7964 | 7853 | } |
7965 | - state.addr = 18446744073709551306LLU; // 999999995J''''''''''''''' | |
7854 | + state.addr = 18446744073709551309LLU; // 999999995M''''''''''''''' | |
7966 | 7855 | break; |
7967 | 7856 | } |
7968 | - case 18446744073709551306LLU: // 999999995J''''''''''''''' | |
7857 | + case 18446744073709551309LLU: // 999999995M''''''''''''''' | |
7969 | 7858 | { |
7970 | 7859 | if(!*LOCAL_ACCESS(heap.data, 18LLU, 16LLU)) |
7971 | 7860 | { |
@@ -7972,16 +7861,16 @@ | ||
7972 | 7861 | (void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 18 |
7973 | 7862 | (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 17 |
7974 | 7863 | { |
7975 | - state.addr = 18446744073709551305LLU; // 999999995I''''''''''''''' | |
7864 | + state.addr = 18446744073709551308LLU; // 999999995L''''''''''''''' | |
7976 | 7865 | break; |
7977 | 7866 | } |
7978 | 7867 | } |
7979 | 7868 | /*direct*/*LOCAL_ACCESS(heap.data, 18LLU, 17LLU) = (*LOCAL_ACCESS(heap.data, 18LLU, 16LLU) << 1) + 1LLU; |
7980 | 7869 | *LOCAL_ACCESS(heap.data, 18LLU, 16LLU) = heap.data[*LOCAL_ACCESS(heap.data, 18LLU, 16LLU)].elem0; |
7981 | - state.addr = /*yres______*/*LOCAL_ACCESS(heap.data, 18LLU, 15LLU) ? 18446744073709551304LLU : 18446744073709551303LLU; | |
7870 | + state.addr = /*yres______*/*LOCAL_ACCESS(heap.data, 18LLU, 15LLU) ? 18446744073709551307LLU : 18446744073709551306LLU; | |
7982 | 7871 | break; |
7983 | 7872 | } |
7984 | - case 18446744073709551304LLU: // 999999995H''''''''''''''' | |
7873 | + case 18446744073709551307LLU: // 999999995K''''''''''''''' | |
7985 | 7874 | { |
7986 | 7875 | { |
7987 | 7876 | uint64_t arg = list_pop_move(&heap, &*LOCAL_ACCESS(heap.data, 18LLU, 15LLU)/*list*/, 8); |
@@ -8006,7 +7895,7 @@ | ||
8006 | 7895 | LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
8007 | 7896 | } |
8008 | 7897 | // ACCUMULATE ARGUMENTS - END |
8009 | - uint64_t return_to = 18446744073709551301LLU; | |
7898 | + uint64_t return_to = 18446744073709551304LLU; | |
8010 | 7899 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)); |
8011 | 7900 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
8012 | 7901 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -8015,7 +7904,7 @@ | ||
8015 | 7904 | state.addr = 589059885019168768LLU; // equres____ |
8016 | 7905 | break; |
8017 | 7906 | } |
8018 | - case 18446744073709551301LLU: // 999999995E''''''''''''''' | |
7907 | + case 18446744073709551304LLU: // 999999995H''''''''''''''' | |
8019 | 7908 | { |
8020 | 7909 | |
8021 | 7910 | *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 20LLU, 0LLU)) = /*equal_____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 20LLU, 0LLU)) && /*EQUAL_____*/*LOCAL_ACCESS(heap.data, 20LLU, 19LLU); |
@@ -8030,7 +7919,7 @@ | ||
8030 | 7919 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
8031 | 7920 | } |
8032 | 7921 | // ACCUMULATE ARGUMENTS - END |
8033 | - uint64_t return_to = 18446744073709551300LLU; | |
7922 | + uint64_t return_to = 18446744073709551303LLU; | |
8034 | 7923 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
8035 | 7924 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
8036 | 7925 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -8039,32 +7928,32 @@ | ||
8039 | 7928 | state.addr = 18446744073709551534LLU; // 999999998s''''''''''''''' |
8040 | 7929 | break; |
8041 | 7930 | } |
8042 | - case 18446744073709551300LLU: // 999999995D''''''''''''''' | |
7931 | + case 18446744073709551303LLU: // 999999995G''''''''''''''' | |
8043 | 7932 | { |
8044 | 7933 | (void)LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference res1______ at 19 |
8045 | - state.addr = 18446744073709551302LLU; // 999999995F''''''''''''''' | |
7934 | + state.addr = 18446744073709551305LLU; // 999999995I''''''''''''''' | |
8046 | 7935 | break; |
8047 | 7936 | } |
8048 | - case 18446744073709551303LLU: // 999999995G''''''''''''''' | |
7937 | + case 18446744073709551306LLU: // 999999995J''''''''''''''' | |
8049 | 7938 | { |
8050 | 7939 | |
8051 | 7940 | *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 18LLU, 0LLU)) = 0; |
8052 | - state.addr = 18446744073709551302LLU; // 999999995F''''''''''''''' | |
7941 | + state.addr = 18446744073709551305LLU; // 999999995I''''''''''''''' | |
8053 | 7942 | break; |
8054 | 7943 | } |
8055 | - case 18446744073709551302LLU: // 999999995F''''''''''''''' | |
7944 | + case 18446744073709551305LLU: // 999999995I''''''''''''''' | |
8056 | 7945 | { |
8057 | 7946 | // parameter-reference resdest___ res0______ goes out of scope |
8058 | 7947 | // parameter-reference list<resdest___> xresults__ goes out of scope |
8059 | - state.addr = 18446744073709551306LLU; // 999999995J''''''''''''''' | |
7948 | + state.addr = 18446744073709551309LLU; // 999999995M''''''''''''''' | |
8060 | 7949 | break; |
8061 | 7950 | } |
8062 | - case 18446744073709551305LLU: // 999999995I''''''''''''''' | |
7951 | + case 18446744073709551308LLU: // 999999995L''''''''''''''' | |
8063 | 7952 | { |
8064 | - state.addr = /*yres______*/*LOCAL_ACCESS(heap.data, 16LLU, 15LLU) ? 18446744073709551299LLU : 18446744073709551298LLU; | |
7953 | + state.addr = /*yres______*/*LOCAL_ACCESS(heap.data, 16LLU, 15LLU) ? 18446744073709551302LLU : 18446744073709551301LLU; | |
8065 | 7954 | break; |
8066 | 7955 | } |
8067 | - case 18446744073709551299LLU: // 999999995C''''''''''''''' | |
7956 | + case 18446744073709551302LLU: // 999999995F''''''''''''''' | |
8068 | 7957 | { |
8069 | 7958 | { |
8070 | 7959 | uint64_t arg = list_pop_move(&heap, &*LOCAL_ACCESS(heap.data, 16LLU, 15LLU)/*list*/, 8); |
@@ -8080,7 +7969,7 @@ | ||
8080 | 7969 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
8081 | 7970 | } |
8082 | 7971 | // ACCUMULATE ARGUMENTS - END |
8083 | - uint64_t return_to = 18446744073709551296LLU; | |
7972 | + uint64_t return_to = 18446744073709551299LLU; | |
8084 | 7973 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
8085 | 7974 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
8086 | 7975 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -8089,29 +7978,29 @@ | ||
8089 | 7978 | state.addr = 18446744073709551534LLU; // 999999998s''''''''''''''' |
8090 | 7979 | break; |
8091 | 7980 | } |
8092 | - case 18446744073709551296LLU: // 999999995_''''''''''''''' | |
7981 | + case 18446744073709551299LLU: // 999999995C''''''''''''''' | |
8093 | 7982 | { |
8094 | 7983 | (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference res1______ at 17 |
8095 | - state.addr = 18446744073709551297LLU; // 999999995A''''''''''''''' | |
7984 | + state.addr = 18446744073709551300LLU; // 999999995D''''''''''''''' | |
8096 | 7985 | break; |
8097 | 7986 | } |
8098 | - case 18446744073709551298LLU: // 999999995B''''''''''''''' | |
7987 | + case 18446744073709551301LLU: // 999999995E''''''''''''''' | |
8099 | 7988 | { |
8100 | - state.addr = 18446744073709551297LLU; // 999999995A''''''''''''''' | |
7989 | + state.addr = 18446744073709551300LLU; // 999999995D''''''''''''''' | |
8101 | 7990 | break; |
8102 | 7991 | } |
8103 | - case 18446744073709551297LLU: // 999999995A''''''''''''''' | |
7992 | + case 18446744073709551300LLU: // 999999995D''''''''''''''' | |
8104 | 7993 | { |
8105 | 7994 | // variable list<resdest___> yres______ goes out of scope |
8106 | 7995 | // emitted destructur for type list<resdest___> |
8107 | - state.addr = 18446744073709551294LLU; // 9999999948''''''''''''''' | |
7996 | + state.addr = 18446744073709551297LLU; // 999999995A''''''''''''''' | |
8108 | 7997 | break; |
8109 | 7998 | } |
8110 | - case 18446744073709551294LLU: // 9999999948''''''''''''''' | |
7999 | + case 18446744073709551297LLU: // 999999995A''''''''''''''' | |
8111 | 8000 | { |
8112 | 8001 | if(!*LOCAL_ACCESS(heap.data, 16LLU, 15LLU)/*list*/) |
8113 | 8002 | { |
8114 | - state.addr = 18446744073709551295LLU; // 9999999949''''''''''''''' | |
8003 | + state.addr = 18446744073709551298LLU; // 999999995B''''''''''''''' | |
8115 | 8004 | break; |
8116 | 8005 | } |
8117 | 8006 | // temporary list-element |
@@ -8125,7 +8014,7 @@ | ||
8125 | 8014 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
8126 | 8015 | } |
8127 | 8016 | // ACCUMULATE ARGUMENTS - END |
8128 | - uint64_t return_to = 18446744073709551293LLU; | |
8017 | + uint64_t return_to = 18446744073709551296LLU; | |
8129 | 8018 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
8130 | 8019 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
8131 | 8020 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -8134,14 +8023,14 @@ | ||
8134 | 8023 | state.addr = 18446744073709551534LLU; // 999999998s''''''''''''''' |
8135 | 8024 | break; |
8136 | 8025 | } |
8137 | - case 18446744073709551293LLU: // 9999999947''''''''''''''' | |
8026 | + case 18446744073709551296LLU: // 999999995_''''''''''''''' | |
8138 | 8027 | { |
8139 | 8028 | // RELEASE temporary destructor-variable |
8140 | 8029 | (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 17 |
8141 | - state.addr = 18446744073709551294LLU; // 9999999948''''''''''''''' | |
8030 | + state.addr = 18446744073709551297LLU; // 999999995A''''''''''''''' | |
8142 | 8031 | break; |
8143 | 8032 | } |
8144 | - case 18446744073709551295LLU: // 9999999949''''''''''''''' | |
8033 | + case 18446744073709551298LLU: // 999999995B''''''''''''''' | |
8145 | 8034 | { |
8146 | 8035 | (void)LOCAL_POP_MOVE(&heap, 16LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference yres______ at 16 |
8147 | 8036 | { |
@@ -8156,10 +8045,10 @@ | ||
8156 | 8045 | uint64_t arg = 0; |
8157 | 8046 | LOCAL_PUSH_MOVE(&heap, 17, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
8158 | 8047 | } |
8159 | - state.addr = 18446744073709551292LLU; // 9999999946''''''''''''''' | |
8048 | + state.addr = 18446744073709551295LLU; // 9999999949''''''''''''''' | |
8160 | 8049 | break; |
8161 | 8050 | } |
8162 | - case 18446744073709551292LLU: // 9999999946''''''''''''''' | |
8051 | + case 18446744073709551295LLU: // 9999999949''''''''''''''' | |
8163 | 8052 | { |
8164 | 8053 | if(!*LOCAL_ACCESS(heap.data, 18LLU, 16LLU)) |
8165 | 8054 | { |
@@ -8166,7 +8055,7 @@ | ||
8166 | 8055 | (void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 18 |
8167 | 8056 | (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 17 |
8168 | 8057 | { |
8169 | - state.addr = 18446744073709551291LLU; // 9999999945''''''''''''''' | |
8058 | + state.addr = 18446744073709551294LLU; // 9999999948''''''''''''''' | |
8170 | 8059 | break; |
8171 | 8060 | } |
8172 | 8061 | } |
@@ -8186,7 +8075,7 @@ | ||
8186 | 8075 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
8187 | 8076 | } |
8188 | 8077 | // ACCUMULATE ARGUMENTS - END |
8189 | - uint64_t return_to = 18446744073709551287LLU; | |
8078 | + uint64_t return_to = 18446744073709551290LLU; | |
8190 | 8079 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
8191 | 8080 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
8192 | 8081 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -8195,12 +8084,12 @@ | ||
8195 | 8084 | state.addr = 296309897384864500LLU; // ParDefCopy |
8196 | 8085 | break; |
8197 | 8086 | } |
8198 | - case 18446744073709551287LLU: // 9999999941''''''''''''''' | |
8087 | + case 18446744073709551290LLU: // 9999999944''''''''''''''' | |
8199 | 8088 | { |
8200 | - state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 19LLU, 18LLU), &*LOCAL_ACCESS(heap.data, 19LLU, 15LLU), 11) ? 18446744073709551290LLU : 18446744073709551289LLU; | |
8089 | + state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 19LLU, 18LLU), &*LOCAL_ACCESS(heap.data, 19LLU, 15LLU), 11) ? 18446744073709551293LLU : 18446744073709551292LLU; | |
8201 | 8090 | break; |
8202 | 8091 | } |
8203 | - case 18446744073709551290LLU: // 9999999944''''''''''''''' | |
8092 | + case 18446744073709551293LLU: // 9999999947''''''''''''''' | |
8204 | 8093 | { |
8205 | 8094 | { |
8206 | 8095 | fprintf(stderr, "%s\n", "out of dynamic heap in equfndef - recompile compiler with more dynamic heap memory"); |
@@ -8213,7 +8102,7 @@ | ||
8213 | 8102 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
8214 | 8103 | } |
8215 | 8104 | // ACCUMULATE ARGUMENTS - END |
8216 | - uint64_t return_to = 18446744073709551286LLU; | |
8105 | + uint64_t return_to = 18446744073709551289LLU; | |
8217 | 8106 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
8218 | 8107 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
8219 | 8108 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -8222,26 +8111,26 @@ | ||
8222 | 8111 | state.addr = 18446744073709551468LLU; // 999999997q''''''''''''''' |
8223 | 8112 | break; |
8224 | 8113 | } |
8225 | - case 18446744073709551286LLU: // 9999999940''''''''''''''' | |
8114 | + case 18446744073709551289LLU: // 9999999943''''''''''''''' | |
8226 | 8115 | { |
8227 | 8116 | // parameter pardef____ new_______ goes out of scope |
8228 | - state.addr = 18446744073709551288LLU; // 9999999942''''''''''''''' | |
8117 | + state.addr = 18446744073709551291LLU; // 9999999945''''''''''''''' | |
8229 | 8118 | break; |
8230 | 8119 | } |
8231 | - case 18446744073709551289LLU: // 9999999943''''''''''''''' | |
8120 | + case 18446744073709551292LLU: // 9999999946''''''''''''''' | |
8232 | 8121 | { |
8233 | - state.addr = 18446744073709551288LLU; // 9999999942''''''''''''''' | |
8122 | + state.addr = 18446744073709551291LLU; // 9999999945''''''''''''''' | |
8234 | 8123 | break; |
8235 | 8124 | } |
8236 | - case 18446744073709551288LLU: // 9999999942''''''''''''''' | |
8125 | + case 18446744073709551291LLU: // 9999999945''''''''''''''' | |
8237 | 8126 | { |
8238 | 8127 | (void)LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 19 |
8239 | 8128 | // parameter-reference pardef____ par1______ goes out of scope |
8240 | 8129 | // parameter-reference list<pardef____> ydefpars__ goes out of scope |
8241 | - state.addr = 18446744073709551292LLU; // 9999999946''''''''''''''' | |
8130 | + state.addr = 18446744073709551295LLU; // 9999999949''''''''''''''' | |
8242 | 8131 | break; |
8243 | 8132 | } |
8244 | - case 18446744073709551291LLU: // 9999999945''''''''''''''' | |
8133 | + case 18446744073709551294LLU: // 9999999948''''''''''''''' | |
8245 | 8134 | { |
8246 | 8135 | list_reverse(heap.data, &/*ypars_____*/*LOCAL_ACCESS(heap.data, 16LLU, 15LLU)); |
8247 | 8136 | { |
@@ -8252,10 +8141,10 @@ | ||
8252 | 8141 | uint64_t arg = 0; |
8253 | 8142 | LOCAL_PUSH_MOVE(&heap, 17, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
8254 | 8143 | } |
8255 | - state.addr = 18446744073709551285LLU; // 999999994z''''''''''''''' | |
8144 | + state.addr = 18446744073709551288LLU; // 9999999942''''''''''''''' | |
8256 | 8145 | break; |
8257 | 8146 | } |
8258 | - case 18446744073709551285LLU: // 999999994z''''''''''''''' | |
8147 | + case 18446744073709551288LLU: // 9999999942''''''''''''''' | |
8259 | 8148 | { |
8260 | 8149 | if(!*LOCAL_ACCESS(heap.data, 18LLU, 16LLU)) |
8261 | 8150 | { |
@@ -8262,16 +8151,16 @@ | ||
8262 | 8151 | (void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 18 |
8263 | 8152 | (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 17 |
8264 | 8153 | { |
8265 | - state.addr = 18446744073709551284LLU; // 999999994y''''''''''''''' | |
8154 | + state.addr = 18446744073709551287LLU; // 9999999941''''''''''''''' | |
8266 | 8155 | break; |
8267 | 8156 | } |
8268 | 8157 | } |
8269 | 8158 | /*direct*/*LOCAL_ACCESS(heap.data, 18LLU, 17LLU) = (*LOCAL_ACCESS(heap.data, 18LLU, 16LLU) << 1) + 1LLU; |
8270 | 8159 | *LOCAL_ACCESS(heap.data, 18LLU, 16LLU) = heap.data[*LOCAL_ACCESS(heap.data, 18LLU, 16LLU)].elem0; |
8271 | - state.addr = /*ypars_____*/*LOCAL_ACCESS(heap.data, 18LLU, 15LLU) ? 18446744073709551283LLU : 18446744073709551282LLU; | |
8160 | + state.addr = /*ypars_____*/*LOCAL_ACCESS(heap.data, 18LLU, 15LLU) ? 18446744073709551286LLU : 18446744073709551285LLU; | |
8272 | 8161 | break; |
8273 | 8162 | } |
8274 | - case 18446744073709551283LLU: // 999999994x''''''''''''''' | |
8163 | + case 18446744073709551286LLU: // 9999999940''''''''''''''' | |
8275 | 8164 | { |
8276 | 8165 | { |
8277 | 8166 | uint64_t arg = list_pop_move(&heap, &*LOCAL_ACCESS(heap.data, 18LLU, 15LLU)/*list*/, 11); |
@@ -8296,7 +8185,7 @@ | ||
8296 | 8185 | LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
8297 | 8186 | } |
8298 | 8187 | // ACCUMULATE ARGUMENTS - END |
8299 | - uint64_t return_to = 18446744073709551280LLU; | |
8188 | + uint64_t return_to = 18446744073709551283LLU; | |
8300 | 8189 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)); |
8301 | 8190 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
8302 | 8191 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -8305,7 +8194,7 @@ | ||
8305 | 8194 | state.addr = 589059743276730432LLU; // equpardef_ |
8306 | 8195 | break; |
8307 | 8196 | } |
8308 | - case 18446744073709551280LLU: // 999999994u''''''''''''''' | |
8197 | + case 18446744073709551283LLU: // 999999994x''''''''''''''' | |
8309 | 8198 | { |
8310 | 8199 | |
8311 | 8200 | *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 20LLU, 0LLU)) = /*equal_____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 20LLU, 0LLU)) && /*EQUAL_____*/*LOCAL_ACCESS(heap.data, 20LLU, 19LLU); |
@@ -8320,7 +8209,7 @@ | ||
8320 | 8209 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
8321 | 8210 | } |
8322 | 8211 | // ACCUMULATE ARGUMENTS - END |
8323 | - uint64_t return_to = 18446744073709551279LLU; | |
8212 | + uint64_t return_to = 18446744073709551282LLU; | |
8324 | 8213 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
8325 | 8214 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
8326 | 8215 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -8329,32 +8218,32 @@ | ||
8329 | 8218 | state.addr = 18446744073709551468LLU; // 999999997q''''''''''''''' |
8330 | 8219 | break; |
8331 | 8220 | } |
8332 | - case 18446744073709551279LLU: // 999999994t''''''''''''''' | |
8221 | + case 18446744073709551282LLU: // 999999994w''''''''''''''' | |
8333 | 8222 | { |
8334 | 8223 | (void)LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference par1______ at 19 |
8335 | - state.addr = 18446744073709551281LLU; // 999999994v''''''''''''''' | |
8224 | + state.addr = 18446744073709551284LLU; // 999999994y''''''''''''''' | |
8336 | 8225 | break; |
8337 | 8226 | } |
8338 | - case 18446744073709551282LLU: // 999999994w''''''''''''''' | |
8227 | + case 18446744073709551285LLU: // 999999994z''''''''''''''' | |
8339 | 8228 | { |
8340 | 8229 | |
8341 | 8230 | *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 18LLU, 0LLU)) = 0; |
8342 | - state.addr = 18446744073709551281LLU; // 999999994v''''''''''''''' | |
8231 | + state.addr = 18446744073709551284LLU; // 999999994y''''''''''''''' | |
8343 | 8232 | break; |
8344 | 8233 | } |
8345 | - case 18446744073709551281LLU: // 999999994v''''''''''''''' | |
8234 | + case 18446744073709551284LLU: // 999999994y''''''''''''''' | |
8346 | 8235 | { |
8347 | 8236 | // parameter-reference pardef____ par0______ goes out of scope |
8348 | 8237 | // parameter-reference list<pardef____> xdefpars__ goes out of scope |
8349 | - state.addr = 18446744073709551285LLU; // 999999994z''''''''''''''' | |
8238 | + state.addr = 18446744073709551288LLU; // 9999999942''''''''''''''' | |
8350 | 8239 | break; |
8351 | 8240 | } |
8352 | - case 18446744073709551284LLU: // 999999994y''''''''''''''' | |
8241 | + case 18446744073709551287LLU: // 9999999941''''''''''''''' | |
8353 | 8242 | { |
8354 | - state.addr = /*ypars_____*/*LOCAL_ACCESS(heap.data, 16LLU, 15LLU) ? 18446744073709551278LLU : 18446744073709551277LLU; | |
8243 | + state.addr = /*ypars_____*/*LOCAL_ACCESS(heap.data, 16LLU, 15LLU) ? 18446744073709551281LLU : 18446744073709551280LLU; | |
8355 | 8244 | break; |
8356 | 8245 | } |
8357 | - case 18446744073709551278LLU: // 999999994s''''''''''''''' | |
8246 | + case 18446744073709551281LLU: // 999999994v''''''''''''''' | |
8358 | 8247 | { |
8359 | 8248 | { |
8360 | 8249 | uint64_t arg = list_pop_move(&heap, &*LOCAL_ACCESS(heap.data, 16LLU, 15LLU)/*list*/, 11); |
@@ -8370,7 +8259,7 @@ | ||
8370 | 8259 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
8371 | 8260 | } |
8372 | 8261 | // ACCUMULATE ARGUMENTS - END |
8373 | - uint64_t return_to = 18446744073709551275LLU; | |
8262 | + uint64_t return_to = 18446744073709551278LLU; | |
8374 | 8263 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
8375 | 8264 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
8376 | 8265 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -8379,29 +8268,29 @@ | ||
8379 | 8268 | state.addr = 18446744073709551468LLU; // 999999997q''''''''''''''' |
8380 | 8269 | break; |
8381 | 8270 | } |
8382 | - case 18446744073709551275LLU: // 999999994p''''''''''''''' | |
8271 | + case 18446744073709551278LLU: // 999999994s''''''''''''''' | |
8383 | 8272 | { |
8384 | 8273 | (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference par1______ at 17 |
8385 | - state.addr = 18446744073709551276LLU; // 999999994q''''''''''''''' | |
8274 | + state.addr = 18446744073709551279LLU; // 999999994t''''''''''''''' | |
8386 | 8275 | break; |
8387 | 8276 | } |
8388 | - case 18446744073709551277LLU: // 999999994r''''''''''''''' | |
8277 | + case 18446744073709551280LLU: // 999999994u''''''''''''''' | |
8389 | 8278 | { |
8390 | - state.addr = 18446744073709551276LLU; // 999999994q''''''''''''''' | |
8279 | + state.addr = 18446744073709551279LLU; // 999999994t''''''''''''''' | |
8391 | 8280 | break; |
8392 | 8281 | } |
8393 | - case 18446744073709551276LLU: // 999999994q''''''''''''''' | |
8282 | + case 18446744073709551279LLU: // 999999994t''''''''''''''' | |
8394 | 8283 | { |
8395 | 8284 | // variable list<pardef____> ypars_____ goes out of scope |
8396 | 8285 | // emitted destructur for type list<pardef____> |
8397 | - state.addr = 18446744073709551273LLU; // 999999994n''''''''''''''' | |
8286 | + state.addr = 18446744073709551276LLU; // 999999994q''''''''''''''' | |
8398 | 8287 | break; |
8399 | 8288 | } |
8400 | - case 18446744073709551273LLU: // 999999994n''''''''''''''' | |
8289 | + case 18446744073709551276LLU: // 999999994q''''''''''''''' | |
8401 | 8290 | { |
8402 | 8291 | if(!*LOCAL_ACCESS(heap.data, 16LLU, 15LLU)/*list*/) |
8403 | 8292 | { |
8404 | - state.addr = 18446744073709551274LLU; // 999999994o''''''''''''''' | |
8293 | + state.addr = 18446744073709551277LLU; // 999999994r''''''''''''''' | |
8405 | 8294 | break; |
8406 | 8295 | } |
8407 | 8296 | // temporary list-element |
@@ -8415,7 +8304,7 @@ | ||
8415 | 8304 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
8416 | 8305 | } |
8417 | 8306 | // ACCUMULATE ARGUMENTS - END |
8418 | - uint64_t return_to = 18446744073709551272LLU; | |
8307 | + uint64_t return_to = 18446744073709551275LLU; | |
8419 | 8308 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
8420 | 8309 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
8421 | 8310 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -8424,14 +8313,14 @@ | ||
8424 | 8313 | state.addr = 18446744073709551468LLU; // 999999997q''''''''''''''' |
8425 | 8314 | break; |
8426 | 8315 | } |
8427 | - case 18446744073709551272LLU: // 999999994m''''''''''''''' | |
8316 | + case 18446744073709551275LLU: // 999999994p''''''''''''''' | |
8428 | 8317 | { |
8429 | 8318 | // RELEASE temporary destructor-variable |
8430 | 8319 | (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 17 |
8431 | - state.addr = 18446744073709551273LLU; // 999999994n''''''''''''''' | |
8320 | + state.addr = 18446744073709551276LLU; // 999999994q''''''''''''''' | |
8432 | 8321 | break; |
8433 | 8322 | } |
8434 | - case 18446744073709551274LLU: // 999999994o''''''''''''''' | |
8323 | + case 18446744073709551277LLU: // 999999994r''''''''''''''' | |
8435 | 8324 | { |
8436 | 8325 | (void)LOCAL_POP_MOVE(&heap, 16LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference ypars_____ at 16 |
8437 | 8326 | { |
@@ -8538,10 +8427,10 @@ | ||
8538 | 8427 | uint64_t arg = 0; |
8539 | 8428 | LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
8540 | 8429 | } |
8541 | - state.addr = 18446744073709551271LLU; // 999999994l''''''''''''''' | |
8430 | + state.addr = 18446744073709551274LLU; // 999999994o''''''''''''''' | |
8542 | 8431 | break; |
8543 | 8432 | } |
8544 | - case 18446744073709551271LLU: // 999999994l''''''''''''''' | |
8433 | + case 18446744073709551274LLU: // 999999994o''''''''''''''' | |
8545 | 8434 | { |
8546 | 8435 | if(!*LOCAL_ACCESS(heap.data, 6LLU, 4LLU)) |
8547 | 8436 | { |
@@ -8548,7 +8437,7 @@ | ||
8548 | 8437 | (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 6 |
8549 | 8438 | (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 5 |
8550 | 8439 | { |
8551 | - state.addr = 18446744073709551270LLU; // 999999994k''''''''''''''' | |
8440 | + state.addr = 18446744073709551273LLU; // 999999994n''''''''''''''' | |
8552 | 8441 | break; |
8553 | 8442 | } |
8554 | 8443 | } |
@@ -8568,7 +8457,7 @@ | ||
8568 | 8457 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
8569 | 8458 | } |
8570 | 8459 | // ACCUMULATE ARGUMENTS - END |
8571 | - uint64_t return_to = 18446744073709551266LLU; | |
8460 | + uint64_t return_to = 18446744073709551269LLU; | |
8572 | 8461 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
8573 | 8462 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
8574 | 8463 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -8577,12 +8466,12 @@ | ||
8577 | 8466 | state.addr = 325750391286068249LLU; // RESDEFCOPY |
8578 | 8467 | break; |
8579 | 8468 | } |
8580 | - case 18446744073709551266LLU: // 999999994g''''''''''''''' | |
8469 | + case 18446744073709551269LLU: // 999999994j''''''''''''''' | |
8581 | 8470 | { |
8582 | - state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 7LLU, 6LLU), &*LOCAL_ACCESS(heap.data, 7LLU, 3LLU), 8) ? 18446744073709551269LLU : 18446744073709551268LLU; | |
8471 | + state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 7LLU, 6LLU), &*LOCAL_ACCESS(heap.data, 7LLU, 3LLU), 8) ? 18446744073709551272LLU : 18446744073709551271LLU; | |
8583 | 8472 | break; |
8584 | 8473 | } |
8585 | - case 18446744073709551269LLU: // 999999994j''''''''''''''' | |
8474 | + case 18446744073709551272LLU: // 999999994m''''''''''''''' | |
8586 | 8475 | { |
8587 | 8476 | { |
8588 | 8477 | fprintf(stderr, "%s\n", "out of dynamic heap in equfndef - recompile compiler with more dynamic heap memory"); |
@@ -8595,7 +8484,7 @@ | ||
8595 | 8484 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
8596 | 8485 | } |
8597 | 8486 | // ACCUMULATE ARGUMENTS - END |
8598 | - uint64_t return_to = 18446744073709551265LLU; | |
8487 | + uint64_t return_to = 18446744073709551268LLU; | |
8599 | 8488 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
8600 | 8489 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
8601 | 8490 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -8604,26 +8493,26 @@ | ||
8604 | 8493 | state.addr = 18446744073709551534LLU; // 999999998s''''''''''''''' |
8605 | 8494 | break; |
8606 | 8495 | } |
8607 | - case 18446744073709551265LLU: // 999999994f''''''''''''''' | |
8496 | + case 18446744073709551268LLU: // 999999994i''''''''''''''' | |
8608 | 8497 | { |
8609 | 8498 | // parameter resdest___ new_______ goes out of scope |
8610 | - state.addr = 18446744073709551267LLU; // 999999994h''''''''''''''' | |
8499 | + state.addr = 18446744073709551270LLU; // 999999994k''''''''''''''' | |
8611 | 8500 | break; |
8612 | 8501 | } |
8613 | - case 18446744073709551268LLU: // 999999994i''''''''''''''' | |
8502 | + case 18446744073709551271LLU: // 999999994l''''''''''''''' | |
8614 | 8503 | { |
8615 | - state.addr = 18446744073709551267LLU; // 999999994h''''''''''''''' | |
8504 | + state.addr = 18446744073709551270LLU; // 999999994k''''''''''''''' | |
8616 | 8505 | break; |
8617 | 8506 | } |
8618 | - case 18446744073709551267LLU: // 999999994h''''''''''''''' | |
8507 | + case 18446744073709551270LLU: // 999999994k''''''''''''''' | |
8619 | 8508 | { |
8620 | 8509 | (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 7 |
8621 | 8510 | // parameter-reference resdest___ respar1___ goes out of scope |
8622 | 8511 | // parameter-reference function__ y_________ goes out of scope |
8623 | - state.addr = 18446744073709551271LLU; // 999999994l''''''''''''''' | |
8512 | + state.addr = 18446744073709551274LLU; // 999999994o''''''''''''''' | |
8624 | 8513 | break; |
8625 | 8514 | } |
8626 | - case 18446744073709551270LLU: // 999999994k''''''''''''''' | |
8515 | + case 18446744073709551273LLU: // 999999994n''''''''''''''' | |
8627 | 8516 | { |
8628 | 8517 | list_reverse(heap.data, &/*yres______*/*LOCAL_ACCESS(heap.data, 4LLU, 3LLU)); |
8629 | 8518 | { |
@@ -8634,10 +8523,10 @@ | ||
8634 | 8523 | uint64_t arg = 0; |
8635 | 8524 | LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
8636 | 8525 | } |
8637 | - state.addr = 18446744073709551264LLU; // 999999994e''''''''''''''' | |
8526 | + state.addr = 18446744073709551267LLU; // 999999994h''''''''''''''' | |
8638 | 8527 | break; |
8639 | 8528 | } |
8640 | - case 18446744073709551264LLU: // 999999994e''''''''''''''' | |
8529 | + case 18446744073709551267LLU: // 999999994h''''''''''''''' | |
8641 | 8530 | { |
8642 | 8531 | if(!*LOCAL_ACCESS(heap.data, 6LLU, 4LLU)) |
8643 | 8532 | { |
@@ -8644,16 +8533,16 @@ | ||
8644 | 8533 | (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 6 |
8645 | 8534 | (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 5 |
8646 | 8535 | { |
8647 | - state.addr = 18446744073709551263LLU; // 999999994d''''''''''''''' | |
8536 | + state.addr = 18446744073709551266LLU; // 999999994g''''''''''''''' | |
8648 | 8537 | break; |
8649 | 8538 | } |
8650 | 8539 | } |
8651 | 8540 | /*direct*/*LOCAL_ACCESS(heap.data, 6LLU, 5LLU) = (*LOCAL_ACCESS(heap.data, 6LLU, 4LLU) << 1) + 1LLU; |
8652 | 8541 | *LOCAL_ACCESS(heap.data, 6LLU, 4LLU) = heap.data[*LOCAL_ACCESS(heap.data, 6LLU, 4LLU)].elem0; |
8653 | - state.addr = /*yres______*/*LOCAL_ACCESS(heap.data, 6LLU, 3LLU) ? 18446744073709551262LLU : 18446744073709551261LLU; | |
8542 | + state.addr = /*yres______*/*LOCAL_ACCESS(heap.data, 6LLU, 3LLU) ? 18446744073709551265LLU : 18446744073709551264LLU; | |
8654 | 8543 | break; |
8655 | 8544 | } |
8656 | - case 18446744073709551262LLU: // 999999994c''''''''''''''' | |
8545 | + case 18446744073709551265LLU: // 999999994f''''''''''''''' | |
8657 | 8546 | { |
8658 | 8547 | { |
8659 | 8548 | uint64_t arg = list_pop_move(&heap, &*LOCAL_ACCESS(heap.data, 6LLU, 3LLU)/*list*/, 8); |
@@ -8678,7 +8567,7 @@ | ||
8678 | 8567 | LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
8679 | 8568 | } |
8680 | 8569 | // ACCUMULATE ARGUMENTS - END |
8681 | - uint64_t return_to = 18446744073709551259LLU; | |
8570 | + uint64_t return_to = 18446744073709551262LLU; | |
8682 | 8571 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)); |
8683 | 8572 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
8684 | 8573 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -8687,7 +8576,7 @@ | ||
8687 | 8576 | state.addr = 589059885019168768LLU; // equres____ |
8688 | 8577 | break; |
8689 | 8578 | } |
8690 | - case 18446744073709551259LLU: // 999999994$''''''''''''''' | |
8579 | + case 18446744073709551262LLU: // 999999994c''''''''''''''' | |
8691 | 8580 | { |
8692 | 8581 | |
8693 | 8582 | *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 8LLU, 0LLU)) = /*equal_____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 8LLU, 0LLU)) && /*EQUAL_____*/*LOCAL_ACCESS(heap.data, 8LLU, 7LLU); |
@@ -8702,7 +8591,7 @@ | ||
8702 | 8591 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
8703 | 8592 | } |
8704 | 8593 | // ACCUMULATE ARGUMENTS - END |
8705 | - uint64_t return_to = 18446744073709551258LLU; | |
8594 | + uint64_t return_to = 18446744073709551261LLU; | |
8706 | 8595 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
8707 | 8596 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
8708 | 8597 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -8711,32 +8600,32 @@ | ||
8711 | 8600 | state.addr = 18446744073709551534LLU; // 999999998s''''''''''''''' |
8712 | 8601 | break; |
8713 | 8602 | } |
8714 | - case 18446744073709551258LLU: // 999999994Z''''''''''''''' | |
8603 | + case 18446744073709551261LLU: // 999999994b''''''''''''''' | |
8715 | 8604 | { |
8716 | 8605 | (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference res1______ at 7 |
8717 | - state.addr = 18446744073709551260LLU; // 999999994a''''''''''''''' | |
8606 | + state.addr = 18446744073709551263LLU; // 999999994d''''''''''''''' | |
8718 | 8607 | break; |
8719 | 8608 | } |
8720 | - case 18446744073709551261LLU: // 999999994b''''''''''''''' | |
8609 | + case 18446744073709551264LLU: // 999999994e''''''''''''''' | |
8721 | 8610 | { |
8722 | 8611 | |
8723 | 8612 | *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 6LLU, 0LLU)) = 0; |
8724 | - state.addr = 18446744073709551260LLU; // 999999994a''''''''''''''' | |
8613 | + state.addr = 18446744073709551263LLU; // 999999994d''''''''''''''' | |
8725 | 8614 | break; |
8726 | 8615 | } |
8727 | - case 18446744073709551260LLU: // 999999994a''''''''''''''' | |
8616 | + case 18446744073709551263LLU: // 999999994d''''''''''''''' | |
8728 | 8617 | { |
8729 | 8618 | // parameter-reference resdest___ res0______ goes out of scope |
8730 | 8619 | // parameter-reference function__ x_________ goes out of scope |
8731 | - state.addr = 18446744073709551264LLU; // 999999994e''''''''''''''' | |
8620 | + state.addr = 18446744073709551267LLU; // 999999994h''''''''''''''' | |
8732 | 8621 | break; |
8733 | 8622 | } |
8734 | - case 18446744073709551263LLU: // 999999994d''''''''''''''' | |
8623 | + case 18446744073709551266LLU: // 999999994g''''''''''''''' | |
8735 | 8624 | { |
8736 | - state.addr = /*yres______*/*LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551257LLU : 18446744073709551256LLU; | |
8625 | + state.addr = /*yres______*/*LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551260LLU : 18446744073709551259LLU; | |
8737 | 8626 | break; |
8738 | 8627 | } |
8739 | - case 18446744073709551257LLU: // 999999994Y''''''''''''''' | |
8628 | + case 18446744073709551260LLU: // 999999994a''''''''''''''' | |
8740 | 8629 | { |
8741 | 8630 | { |
8742 | 8631 | uint64_t arg = list_pop_move(&heap, &*LOCAL_ACCESS(heap.data, 4LLU, 3LLU)/*list*/, 8); |
@@ -8752,7 +8641,7 @@ | ||
8752 | 8641 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
8753 | 8642 | } |
8754 | 8643 | // ACCUMULATE ARGUMENTS - END |
8755 | - uint64_t return_to = 18446744073709551254LLU; | |
8644 | + uint64_t return_to = 18446744073709551257LLU; | |
8756 | 8645 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
8757 | 8646 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
8758 | 8647 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -8761,29 +8650,29 @@ | ||
8761 | 8650 | state.addr = 18446744073709551534LLU; // 999999998s''''''''''''''' |
8762 | 8651 | break; |
8763 | 8652 | } |
8764 | - case 18446744073709551254LLU: // 999999994V''''''''''''''' | |
8653 | + case 18446744073709551257LLU: // 999999994Y''''''''''''''' | |
8765 | 8654 | { |
8766 | 8655 | (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference res1______ at 5 |
8767 | - state.addr = 18446744073709551255LLU; // 999999994W''''''''''''''' | |
8656 | + state.addr = 18446744073709551258LLU; // 999999994Z''''''''''''''' | |
8768 | 8657 | break; |
8769 | 8658 | } |
8770 | - case 18446744073709551256LLU: // 999999994X''''''''''''''' | |
8659 | + case 18446744073709551259LLU: // 999999994$''''''''''''''' | |
8771 | 8660 | { |
8772 | - state.addr = 18446744073709551255LLU; // 999999994W''''''''''''''' | |
8661 | + state.addr = 18446744073709551258LLU; // 999999994Z''''''''''''''' | |
8773 | 8662 | break; |
8774 | 8663 | } |
8775 | - case 18446744073709551255LLU: // 999999994W''''''''''''''' | |
8664 | + case 18446744073709551258LLU: // 999999994Z''''''''''''''' | |
8776 | 8665 | { |
8777 | 8666 | // variable list<resdest___> yres______ goes out of scope |
8778 | 8667 | // emitted destructur for type list<resdest___> |
8779 | - state.addr = 18446744073709551252LLU; // 999999994T''''''''''''''' | |
8668 | + state.addr = 18446744073709551255LLU; // 999999994W''''''''''''''' | |
8780 | 8669 | break; |
8781 | 8670 | } |
8782 | - case 18446744073709551252LLU: // 999999994T''''''''''''''' | |
8671 | + case 18446744073709551255LLU: // 999999994W''''''''''''''' | |
8783 | 8672 | { |
8784 | 8673 | if(!*LOCAL_ACCESS(heap.data, 4LLU, 3LLU)/*list*/) |
8785 | 8674 | { |
8786 | - state.addr = 18446744073709551253LLU; // 999999994U''''''''''''''' | |
8675 | + state.addr = 18446744073709551256LLU; // 999999994X''''''''''''''' | |
8787 | 8676 | break; |
8788 | 8677 | } |
8789 | 8678 | // temporary list-element |
@@ -8797,7 +8686,7 @@ | ||
8797 | 8686 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
8798 | 8687 | } |
8799 | 8688 | // ACCUMULATE ARGUMENTS - END |
8800 | - uint64_t return_to = 18446744073709551251LLU; | |
8689 | + uint64_t return_to = 18446744073709551254LLU; | |
8801 | 8690 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
8802 | 8691 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
8803 | 8692 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -8806,14 +8695,14 @@ | ||
8806 | 8695 | state.addr = 18446744073709551534LLU; // 999999998s''''''''''''''' |
8807 | 8696 | break; |
8808 | 8697 | } |
8809 | - case 18446744073709551251LLU: // 999999994S''''''''''''''' | |
8698 | + case 18446744073709551254LLU: // 999999994V''''''''''''''' | |
8810 | 8699 | { |
8811 | 8700 | // RELEASE temporary destructor-variable |
8812 | 8701 | (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 5 |
8813 | - state.addr = 18446744073709551252LLU; // 999999994T''''''''''''''' | |
8702 | + state.addr = 18446744073709551255LLU; // 999999994W''''''''''''''' | |
8814 | 8703 | break; |
8815 | 8704 | } |
8816 | - case 18446744073709551253LLU: // 999999994U''''''''''''''' | |
8705 | + case 18446744073709551256LLU: // 999999994X''''''''''''''' | |
8817 | 8706 | { |
8818 | 8707 | (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference yres______ at 4 |
8819 | 8708 | { |
@@ -8828,10 +8717,10 @@ | ||
8828 | 8717 | uint64_t arg = 0; |
8829 | 8718 | LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
8830 | 8719 | } |
8831 | - state.addr = 18446744073709551250LLU; // 999999994R''''''''''''''' | |
8720 | + state.addr = 18446744073709551253LLU; // 999999994U''''''''''''''' | |
8832 | 8721 | break; |
8833 | 8722 | } |
8834 | - case 18446744073709551250LLU: // 999999994R''''''''''''''' | |
8723 | + case 18446744073709551253LLU: // 999999994U''''''''''''''' | |
8835 | 8724 | { |
8836 | 8725 | if(!*LOCAL_ACCESS(heap.data, 6LLU, 4LLU)) |
8837 | 8726 | { |
@@ -8838,7 +8727,7 @@ | ||
8838 | 8727 | (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 6 |
8839 | 8728 | (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 5 |
8840 | 8729 | { |
8841 | - state.addr = 18446744073709551249LLU; // 999999994Q''''''''''''''' | |
8730 | + state.addr = 18446744073709551252LLU; // 999999994T''''''''''''''' | |
8842 | 8731 | break; |
8843 | 8732 | } |
8844 | 8733 | } |
@@ -8858,7 +8747,7 @@ | ||
8858 | 8747 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
8859 | 8748 | } |
8860 | 8749 | // ACCUMULATE ARGUMENTS - END |
8861 | - uint64_t return_to = 18446744073709551245LLU; | |
8750 | + uint64_t return_to = 18446744073709551248LLU; | |
8862 | 8751 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
8863 | 8752 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
8864 | 8753 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -8867,12 +8756,12 @@ | ||
8867 | 8756 | state.addr = 296309897384864500LLU; // ParDefCopy |
8868 | 8757 | break; |
8869 | 8758 | } |
8870 | - case 18446744073709551245LLU: // 999999994M''''''''''''''' | |
8759 | + case 18446744073709551248LLU: // 999999994P''''''''''''''' | |
8871 | 8760 | { |
8872 | - state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 7LLU, 6LLU), &*LOCAL_ACCESS(heap.data, 7LLU, 3LLU), 11) ? 18446744073709551248LLU : 18446744073709551247LLU; | |
8761 | + state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 7LLU, 6LLU), &*LOCAL_ACCESS(heap.data, 7LLU, 3LLU), 11) ? 18446744073709551251LLU : 18446744073709551250LLU; | |
8873 | 8762 | break; |
8874 | 8763 | } |
8875 | - case 18446744073709551248LLU: // 999999994P''''''''''''''' | |
8764 | + case 18446744073709551251LLU: // 999999994S''''''''''''''' | |
8876 | 8765 | { |
8877 | 8766 | { |
8878 | 8767 | fprintf(stderr, "%s\n", "out of dynamic heap in equfndef - recompile compiler with more dynamic heap memory"); |
@@ -8885,7 +8774,7 @@ | ||
8885 | 8774 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
8886 | 8775 | } |
8887 | 8776 | // ACCUMULATE ARGUMENTS - END |
8888 | - uint64_t return_to = 18446744073709551244LLU; | |
8777 | + uint64_t return_to = 18446744073709551247LLU; | |
8889 | 8778 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
8890 | 8779 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
8891 | 8780 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -8894,26 +8783,26 @@ | ||
8894 | 8783 | state.addr = 18446744073709551468LLU; // 999999997q''''''''''''''' |
8895 | 8784 | break; |
8896 | 8785 | } |
8897 | - case 18446744073709551244LLU: // 999999994L''''''''''''''' | |
8786 | + case 18446744073709551247LLU: // 999999994O''''''''''''''' | |
8898 | 8787 | { |
8899 | 8788 | // parameter pardef____ new_______ goes out of scope |
8900 | - state.addr = 18446744073709551246LLU; // 999999994N''''''''''''''' | |
8789 | + state.addr = 18446744073709551249LLU; // 999999994Q''''''''''''''' | |
8901 | 8790 | break; |
8902 | 8791 | } |
8903 | - case 18446744073709551247LLU: // 999999994O''''''''''''''' | |
8792 | + case 18446744073709551250LLU: // 999999994R''''''''''''''' | |
8904 | 8793 | { |
8905 | - state.addr = 18446744073709551246LLU; // 999999994N''''''''''''''' | |
8794 | + state.addr = 18446744073709551249LLU; // 999999994Q''''''''''''''' | |
8906 | 8795 | break; |
8907 | 8796 | } |
8908 | - case 18446744073709551246LLU: // 999999994N''''''''''''''' | |
8797 | + case 18446744073709551249LLU: // 999999994Q''''''''''''''' | |
8909 | 8798 | { |
8910 | 8799 | (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 7 |
8911 | 8800 | // parameter-reference pardef____ par1______ goes out of scope |
8912 | 8801 | // parameter-reference function__ y_________ goes out of scope |
8913 | - state.addr = 18446744073709551250LLU; // 999999994R''''''''''''''' | |
8802 | + state.addr = 18446744073709551253LLU; // 999999994U''''''''''''''' | |
8914 | 8803 | break; |
8915 | 8804 | } |
8916 | - case 18446744073709551249LLU: // 999999994Q''''''''''''''' | |
8805 | + case 18446744073709551252LLU: // 999999994T''''''''''''''' | |
8917 | 8806 | { |
8918 | 8807 | list_reverse(heap.data, &/*ypars_____*/*LOCAL_ACCESS(heap.data, 4LLU, 3LLU)); |
8919 | 8808 | { |
@@ -8924,10 +8813,10 @@ | ||
8924 | 8813 | uint64_t arg = 0; |
8925 | 8814 | LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
8926 | 8815 | } |
8927 | - state.addr = 18446744073709551243LLU; // 999999994K''''''''''''''' | |
8816 | + state.addr = 18446744073709551246LLU; // 999999994N''''''''''''''' | |
8928 | 8817 | break; |
8929 | 8818 | } |
8930 | - case 18446744073709551243LLU: // 999999994K''''''''''''''' | |
8819 | + case 18446744073709551246LLU: // 999999994N''''''''''''''' | |
8931 | 8820 | { |
8932 | 8821 | if(!*LOCAL_ACCESS(heap.data, 6LLU, 4LLU)) |
8933 | 8822 | { |
@@ -8934,16 +8823,16 @@ | ||
8934 | 8823 | (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 6 |
8935 | 8824 | (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 5 |
8936 | 8825 | { |
8937 | - state.addr = 18446744073709551242LLU; // 999999994J''''''''''''''' | |
8826 | + state.addr = 18446744073709551245LLU; // 999999994M''''''''''''''' | |
8938 | 8827 | break; |
8939 | 8828 | } |
8940 | 8829 | } |
8941 | 8830 | /*direct*/*LOCAL_ACCESS(heap.data, 6LLU, 5LLU) = (*LOCAL_ACCESS(heap.data, 6LLU, 4LLU) << 1) + 1LLU; |
8942 | 8831 | *LOCAL_ACCESS(heap.data, 6LLU, 4LLU) = heap.data[*LOCAL_ACCESS(heap.data, 6LLU, 4LLU)].elem0; |
8943 | - state.addr = /*ypars_____*/*LOCAL_ACCESS(heap.data, 6LLU, 3LLU) ? 18446744073709551241LLU : 18446744073709551240LLU; | |
8832 | + state.addr = /*ypars_____*/*LOCAL_ACCESS(heap.data, 6LLU, 3LLU) ? 18446744073709551244LLU : 18446744073709551243LLU; | |
8944 | 8833 | break; |
8945 | 8834 | } |
8946 | - case 18446744073709551241LLU: // 999999994I''''''''''''''' | |
8835 | + case 18446744073709551244LLU: // 999999994L''''''''''''''' | |
8947 | 8836 | { |
8948 | 8837 | { |
8949 | 8838 | uint64_t arg = list_pop_move(&heap, &*LOCAL_ACCESS(heap.data, 6LLU, 3LLU)/*list*/, 11); |
@@ -8968,7 +8857,7 @@ | ||
8968 | 8857 | LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
8969 | 8858 | } |
8970 | 8859 | // ACCUMULATE ARGUMENTS - END |
8971 | - uint64_t return_to = 18446744073709551238LLU; | |
8860 | + uint64_t return_to = 18446744073709551241LLU; | |
8972 | 8861 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)); |
8973 | 8862 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
8974 | 8863 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -8977,7 +8866,7 @@ | ||
8977 | 8866 | state.addr = 589059743276730432LLU; // equpardef_ |
8978 | 8867 | break; |
8979 | 8868 | } |
8980 | - case 18446744073709551238LLU: // 999999994F''''''''''''''' | |
8869 | + case 18446744073709551241LLU: // 999999994I''''''''''''''' | |
8981 | 8870 | { |
8982 | 8871 | |
8983 | 8872 | *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 8LLU, 0LLU)) = /*equal_____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 8LLU, 0LLU)) && /*EQUAL_____*/*LOCAL_ACCESS(heap.data, 8LLU, 7LLU); |
@@ -8992,7 +8881,7 @@ | ||
8992 | 8881 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
8993 | 8882 | } |
8994 | 8883 | // ACCUMULATE ARGUMENTS - END |
8995 | - uint64_t return_to = 18446744073709551237LLU; | |
8884 | + uint64_t return_to = 18446744073709551240LLU; | |
8996 | 8885 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
8997 | 8886 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
8998 | 8887 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -9001,32 +8890,32 @@ | ||
9001 | 8890 | state.addr = 18446744073709551468LLU; // 999999997q''''''''''''''' |
9002 | 8891 | break; |
9003 | 8892 | } |
9004 | - case 18446744073709551237LLU: // 999999994E''''''''''''''' | |
8893 | + case 18446744073709551240LLU: // 999999994H''''''''''''''' | |
9005 | 8894 | { |
9006 | 8895 | (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference par1______ at 7 |
9007 | - state.addr = 18446744073709551239LLU; // 999999994G''''''''''''''' | |
8896 | + state.addr = 18446744073709551242LLU; // 999999994J''''''''''''''' | |
9008 | 8897 | break; |
9009 | 8898 | } |
9010 | - case 18446744073709551240LLU: // 999999994H''''''''''''''' | |
8899 | + case 18446744073709551243LLU: // 999999994K''''''''''''''' | |
9011 | 8900 | { |
9012 | 8901 | |
9013 | 8902 | *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 6LLU, 0LLU)) = 0; |
9014 | - state.addr = 18446744073709551239LLU; // 999999994G''''''''''''''' | |
8903 | + state.addr = 18446744073709551242LLU; // 999999994J''''''''''''''' | |
9015 | 8904 | break; |
9016 | 8905 | } |
9017 | - case 18446744073709551239LLU: // 999999994G''''''''''''''' | |
8906 | + case 18446744073709551242LLU: // 999999994J''''''''''''''' | |
9018 | 8907 | { |
9019 | 8908 | // parameter-reference pardef____ par0______ goes out of scope |
9020 | 8909 | // parameter-reference function__ x_________ goes out of scope |
9021 | - state.addr = 18446744073709551243LLU; // 999999994K''''''''''''''' | |
8910 | + state.addr = 18446744073709551246LLU; // 999999994N''''''''''''''' | |
9022 | 8911 | break; |
9023 | 8912 | } |
9024 | - case 18446744073709551242LLU: // 999999994J''''''''''''''' | |
8913 | + case 18446744073709551245LLU: // 999999994M''''''''''''''' | |
9025 | 8914 | { |
9026 | - state.addr = /*ypars_____*/*LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551236LLU : 18446744073709551235LLU; | |
8915 | + state.addr = /*ypars_____*/*LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551239LLU : 18446744073709551238LLU; | |
9027 | 8916 | break; |
9028 | 8917 | } |
9029 | - case 18446744073709551236LLU: // 999999994D''''''''''''''' | |
8918 | + case 18446744073709551239LLU: // 999999994G''''''''''''''' | |
9030 | 8919 | { |
9031 | 8920 | { |
9032 | 8921 | uint64_t arg = list_pop_move(&heap, &*LOCAL_ACCESS(heap.data, 4LLU, 3LLU)/*list*/, 11); |
@@ -9042,7 +8931,7 @@ | ||
9042 | 8931 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
9043 | 8932 | } |
9044 | 8933 | // ACCUMULATE ARGUMENTS - END |
9045 | - uint64_t return_to = 18446744073709551233LLU; | |
8934 | + uint64_t return_to = 18446744073709551236LLU; | |
9046 | 8935 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
9047 | 8936 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
9048 | 8937 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -9051,29 +8940,29 @@ | ||
9051 | 8940 | state.addr = 18446744073709551468LLU; // 999999997q''''''''''''''' |
9052 | 8941 | break; |
9053 | 8942 | } |
9054 | - case 18446744073709551233LLU: // 999999994A''''''''''''''' | |
8943 | + case 18446744073709551236LLU: // 999999994D''''''''''''''' | |
9055 | 8944 | { |
9056 | 8945 | (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference par1______ at 5 |
9057 | - state.addr = 18446744073709551234LLU; // 999999994B''''''''''''''' | |
8946 | + state.addr = 18446744073709551237LLU; // 999999994E''''''''''''''' | |
9058 | 8947 | break; |
9059 | 8948 | } |
9060 | - case 18446744073709551235LLU: // 999999994C''''''''''''''' | |
8949 | + case 18446744073709551238LLU: // 999999994F''''''''''''''' | |
9061 | 8950 | { |
9062 | - state.addr = 18446744073709551234LLU; // 999999994B''''''''''''''' | |
8951 | + state.addr = 18446744073709551237LLU; // 999999994E''''''''''''''' | |
9063 | 8952 | break; |
9064 | 8953 | } |
9065 | - case 18446744073709551234LLU: // 999999994B''''''''''''''' | |
8954 | + case 18446744073709551237LLU: // 999999994E''''''''''''''' | |
9066 | 8955 | { |
9067 | 8956 | // variable list<pardef____> ypars_____ goes out of scope |
9068 | 8957 | // emitted destructur for type list<pardef____> |
9069 | - state.addr = 18446744073709551231LLU; // 9999999939''''''''''''''' | |
8958 | + state.addr = 18446744073709551234LLU; // 999999994B''''''''''''''' | |
9070 | 8959 | break; |
9071 | 8960 | } |
9072 | - case 18446744073709551231LLU: // 9999999939''''''''''''''' | |
8961 | + case 18446744073709551234LLU: // 999999994B''''''''''''''' | |
9073 | 8962 | { |
9074 | 8963 | if(!*LOCAL_ACCESS(heap.data, 4LLU, 3LLU)/*list*/) |
9075 | 8964 | { |
9076 | - state.addr = 18446744073709551232LLU; // 999999994_''''''''''''''' | |
8965 | + state.addr = 18446744073709551235LLU; // 999999994C''''''''''''''' | |
9077 | 8966 | break; |
9078 | 8967 | } |
9079 | 8968 | // temporary list-element |
@@ -9087,7 +8976,7 @@ | ||
9087 | 8976 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
9088 | 8977 | } |
9089 | 8978 | // ACCUMULATE ARGUMENTS - END |
9090 | - uint64_t return_to = 18446744073709551230LLU; | |
8979 | + uint64_t return_to = 18446744073709551233LLU; | |
9091 | 8980 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
9092 | 8981 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
9093 | 8982 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -9096,14 +8985,14 @@ | ||
9096 | 8985 | state.addr = 18446744073709551468LLU; // 999999997q''''''''''''''' |
9097 | 8986 | break; |
9098 | 8987 | } |
9099 | - case 18446744073709551230LLU: // 9999999938''''''''''''''' | |
8988 | + case 18446744073709551233LLU: // 999999994A''''''''''''''' | |
9100 | 8989 | { |
9101 | 8990 | // RELEASE temporary destructor-variable |
9102 | 8991 | (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 5 |
9103 | - state.addr = 18446744073709551231LLU; // 9999999939''''''''''''''' | |
8992 | + state.addr = 18446744073709551234LLU; // 999999994B''''''''''''''' | |
9104 | 8993 | break; |
9105 | 8994 | } |
9106 | - case 18446744073709551232LLU: // 999999994_''''''''''''''' | |
8995 | + case 18446744073709551235LLU: // 999999994C''''''''''''''' | |
9107 | 8996 | { |
9108 | 8997 | (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference ypars_____ at 4 |
9109 | 8998 | { |
@@ -9170,7 +9059,7 @@ | ||
9170 | 9059 | } |
9171 | 9060 | break; |
9172 | 9061 | } |
9173 | - case 18446744073709551229LLU: // 9999999937''''''''''''''' | |
9062 | + case 18446744073709551232LLU: // 999999994_''''''''''''''' | |
9174 | 9063 | { |
9175 | 9064 | { |
9176 | 9065 | uint64_t arg = tree_pop_move(&heap, 2LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))); |
@@ -9177,14 +9066,14 @@ | ||
9177 | 9066 | LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
9178 | 9067 | } |
9179 | 9068 | // emitted destructur for type list<elemdef___> |
9180 | - state.addr = 18446744073709551227LLU; // 9999999935''''''''''''''' | |
9069 | + state.addr = 18446744073709551230LLU; // 9999999938''''''''''''''' | |
9181 | 9070 | break; |
9182 | 9071 | } |
9183 | - case 18446744073709551227LLU: // 9999999935''''''''''''''' | |
9072 | + case 18446744073709551230LLU: // 9999999938''''''''''''''' | |
9184 | 9073 | { |
9185 | 9074 | if(!*LOCAL_ACCESS(heap.data, 2LLU, 1LLU)/*list*/) |
9186 | 9075 | { |
9187 | - state.addr = 18446744073709551228LLU; // 9999999936''''''''''''''' | |
9076 | + state.addr = 18446744073709551231LLU; // 9999999939''''''''''''''' | |
9188 | 9077 | break; |
9189 | 9078 | } |
9190 | 9079 | // temporary list-element |
@@ -9198,7 +9087,7 @@ | ||
9198 | 9087 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
9199 | 9088 | } |
9200 | 9089 | // ACCUMULATE ARGUMENTS - END |
9201 | - uint64_t return_to = 18446744073709551226LLU; | |
9090 | + uint64_t return_to = 18446744073709551229LLU; | |
9202 | 9091 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
9203 | 9092 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
9204 | 9093 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -9207,14 +9096,14 @@ | ||
9207 | 9096 | state.addr = 18446744073709551465LLU; // 999999997n''''''''''''''' |
9208 | 9097 | break; |
9209 | 9098 | } |
9210 | - case 18446744073709551226LLU: // 9999999934''''''''''''''' | |
9099 | + case 18446744073709551229LLU: // 9999999937''''''''''''''' | |
9211 | 9100 | { |
9212 | 9101 | // RELEASE temporary destructor-variable |
9213 | 9102 | (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 3 |
9214 | - state.addr = 18446744073709551227LLU; // 9999999935''''''''''''''' | |
9103 | + state.addr = 18446744073709551230LLU; // 9999999938''''''''''''''' | |
9215 | 9104 | break; |
9216 | 9105 | } |
9217 | - case 18446744073709551228LLU: // 9999999936''''''''''''''' | |
9106 | + case 18446744073709551231LLU: // 9999999939''''''''''''''' | |
9218 | 9107 | { |
9219 | 9108 | // RELEASE temporary destructor-variable |
9220 | 9109 | (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2 |
@@ -9293,10 +9182,10 @@ | ||
9293 | 9182 | uint64_t arg = 0; |
9294 | 9183 | LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
9295 | 9184 | } |
9296 | - state.addr = 18446744073709551224LLU; // 9999999932''''''''''''''' | |
9185 | + state.addr = 18446744073709551227LLU; // 9999999935''''''''''''''' | |
9297 | 9186 | break; |
9298 | 9187 | } |
9299 | - case 18446744073709551224LLU: // 9999999932''''''''''''''' | |
9188 | + case 18446744073709551227LLU: // 9999999935''''''''''''''' | |
9300 | 9189 | { |
9301 | 9190 | if(!*LOCAL_ACCESS(heap.data, 8LLU, 6LLU)) |
9302 | 9191 | { |
@@ -9303,7 +9192,7 @@ | ||
9303 | 9192 | (void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 8 |
9304 | 9193 | (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 7 |
9305 | 9194 | { |
9306 | - state.addr = 18446744073709551223LLU; // 9999999931''''''''''''''' | |
9195 | + state.addr = 18446744073709551226LLU; // 9999999934''''''''''''''' | |
9307 | 9196 | break; |
9308 | 9197 | } |
9309 | 9198 | } |
@@ -9323,7 +9212,7 @@ | ||
9323 | 9212 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
9324 | 9213 | } |
9325 | 9214 | // ACCUMULATE ARGUMENTS - END |
9326 | - uint64_t return_to = 18446744073709551219LLU; | |
9215 | + uint64_t return_to = 18446744073709551222LLU; | |
9327 | 9216 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
9328 | 9217 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
9329 | 9218 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -9332,12 +9221,12 @@ | ||
9332 | 9221 | state.addr = 101193007747052544LLU; // ElemDefCP_ |
9333 | 9222 | break; |
9334 | 9223 | } |
9335 | - case 18446744073709551219LLU: // 999999993x''''''''''''''' | |
9224 | + case 18446744073709551222LLU: // 9999999930''''''''''''''' | |
9336 | 9225 | { |
9337 | - state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 9LLU, 8LLU), &*LOCAL_ACCESS(heap.data, 9LLU, 5LLU), 7) ? 18446744073709551222LLU : 18446744073709551221LLU; | |
9226 | + state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 9LLU, 8LLU), &*LOCAL_ACCESS(heap.data, 9LLU, 5LLU), 7) ? 18446744073709551225LLU : 18446744073709551224LLU; | |
9338 | 9227 | break; |
9339 | 9228 | } |
9340 | - case 18446744073709551222LLU: // 9999999930''''''''''''''' | |
9229 | + case 18446744073709551225LLU: // 9999999933''''''''''''''' | |
9341 | 9230 | { |
9342 | 9231 | { |
9343 | 9232 | fprintf(stderr, "%s\n", "INTERNAL ERROR: out of memory in copyvar - recompile compiler with more dynamic heap"); |
@@ -9350,7 +9239,7 @@ | ||
9350 | 9239 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
9351 | 9240 | } |
9352 | 9241 | // ACCUMULATE ARGUMENTS - END |
9353 | - uint64_t return_to = 18446744073709551218LLU; | |
9242 | + uint64_t return_to = 18446744073709551221LLU; | |
9354 | 9243 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
9355 | 9244 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
9356 | 9245 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -9359,26 +9248,26 @@ | ||
9359 | 9248 | state.addr = 18446744073709551465LLU; // 999999997n''''''''''''''' |
9360 | 9249 | break; |
9361 | 9250 | } |
9362 | - case 18446744073709551218LLU: // 999999993w''''''''''''''' | |
9251 | + case 18446744073709551221LLU: // 999999993z''''''''''''''' | |
9363 | 9252 | { |
9364 | 9253 | // parameter elemdef___ dstpar____ goes out of scope |
9365 | - state.addr = 18446744073709551220LLU; // 999999993y''''''''''''''' | |
9254 | + state.addr = 18446744073709551223LLU; // 9999999931''''''''''''''' | |
9366 | 9255 | break; |
9367 | 9256 | } |
9368 | - case 18446744073709551221LLU: // 999999993z''''''''''''''' | |
9257 | + case 18446744073709551224LLU: // 9999999932''''''''''''''' | |
9369 | 9258 | { |
9370 | - state.addr = 18446744073709551220LLU; // 999999993y''''''''''''''' | |
9259 | + state.addr = 18446744073709551223LLU; // 9999999931''''''''''''''' | |
9371 | 9260 | break; |
9372 | 9261 | } |
9373 | - case 18446744073709551220LLU: // 999999993y''''''''''''''' | |
9262 | + case 18446744073709551223LLU: // 9999999931''''''''''''''' | |
9374 | 9263 | { |
9375 | 9264 | (void)LOCAL_POP_MOVE(&heap, 9LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 9 |
9376 | 9265 | // parameter-reference elemdef___ srcpar____ goes out of scope |
9377 | 9266 | // parameter-reference list<elemdef___> srcpars___ goes out of scope |
9378 | - state.addr = 18446744073709551224LLU; // 9999999932''''''''''''''' | |
9267 | + state.addr = 18446744073709551227LLU; // 9999999935''''''''''''''' | |
9379 | 9268 | break; |
9380 | 9269 | } |
9381 | - case 18446744073709551223LLU: // 9999999931''''''''''''''' | |
9270 | + case 18446744073709551226LLU: // 9999999934''''''''''''''' | |
9382 | 9271 | { |
9383 | 9272 | // ACCUMULATE ARGUMENTS - BEGIN |
9384 | 9273 | { |
@@ -9394,7 +9283,7 @@ | ||
9394 | 9283 | LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
9395 | 9284 | } |
9396 | 9285 | // ACCUMULATE ARGUMENTS - END |
9397 | - uint64_t return_to = 18446744073709551217LLU; | |
9286 | + uint64_t return_to = 18446744073709551220LLU; | |
9398 | 9287 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)); |
9399 | 9288 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
9400 | 9289 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -9403,7 +9292,7 @@ | ||
9403 | 9292 | state.addr = 890787243071635456LLU; // variant___ |
9404 | 9293 | break; |
9405 | 9294 | } |
9406 | - case 18446744073709551217LLU: // 999999993v''''''''''''''' | |
9295 | + case 18446744073709551220LLU: // 999999993y''''''''''''''' | |
9407 | 9296 | { |
9408 | 9297 | // variable list<elemdef___> dstpars___ goes out of scope |
9409 | 9298 | // (uninitialized -> no destructor-call) |
@@ -9453,10 +9342,10 @@ | ||
9453 | 9342 | uint64_t arg = 0; |
9454 | 9343 | LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
9455 | 9344 | } |
9456 | - state.addr = 18446744073709551215LLU; // 999999993t''''''''''''''' | |
9345 | + state.addr = 18446744073709551218LLU; // 999999993w''''''''''''''' | |
9457 | 9346 | break; |
9458 | 9347 | } |
9459 | - case 18446744073709551215LLU: // 999999993t''''''''''''''' | |
9348 | + case 18446744073709551218LLU: // 999999993w''''''''''''''' | |
9460 | 9349 | { |
9461 | 9350 | if(!*LOCAL_ACCESS(heap.data, 8LLU, 6LLU)) |
9462 | 9351 | { |
@@ -9463,7 +9352,7 @@ | ||
9463 | 9352 | (void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 8 |
9464 | 9353 | (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 7 |
9465 | 9354 | { |
9466 | - state.addr = 18446744073709551214LLU; // 999999993s''''''''''''''' | |
9355 | + state.addr = 18446744073709551217LLU; // 999999993v''''''''''''''' | |
9467 | 9356 | break; |
9468 | 9357 | } |
9469 | 9358 | } |
@@ -9483,7 +9372,7 @@ | ||
9483 | 9372 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
9484 | 9373 | } |
9485 | 9374 | // ACCUMULATE ARGUMENTS - END |
9486 | - uint64_t return_to = 18446744073709551210LLU; | |
9375 | + uint64_t return_to = 18446744073709551213LLU; | |
9487 | 9376 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
9488 | 9377 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
9489 | 9378 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -9492,12 +9381,12 @@ | ||
9492 | 9381 | state.addr = 101193007747052544LLU; // ElemDefCP_ |
9493 | 9382 | break; |
9494 | 9383 | } |
9495 | - case 18446744073709551210LLU: // 999999993o''''''''''''''' | |
9384 | + case 18446744073709551213LLU: // 999999993r''''''''''''''' | |
9496 | 9385 | { |
9497 | - state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 9LLU, 8LLU), &*LOCAL_ACCESS(heap.data, 9LLU, 5LLU), 7) ? 18446744073709551213LLU : 18446744073709551212LLU; | |
9386 | + state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 9LLU, 8LLU), &*LOCAL_ACCESS(heap.data, 9LLU, 5LLU), 7) ? 18446744073709551216LLU : 18446744073709551215LLU; | |
9498 | 9387 | break; |
9499 | 9388 | } |
9500 | - case 18446744073709551213LLU: // 999999993r''''''''''''''' | |
9389 | + case 18446744073709551216LLU: // 999999993u''''''''''''''' | |
9501 | 9390 | { |
9502 | 9391 | { |
9503 | 9392 | fprintf(stderr, "%s\n", "INTERNAL ERROR: out of memory in copyvar - recompile compiler with more dynamic heap"); |
@@ -9510,7 +9399,7 @@ | ||
9510 | 9399 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
9511 | 9400 | } |
9512 | 9401 | // ACCUMULATE ARGUMENTS - END |
9513 | - uint64_t return_to = 18446744073709551209LLU; | |
9402 | + uint64_t return_to = 18446744073709551212LLU; | |
9514 | 9403 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
9515 | 9404 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
9516 | 9405 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -9519,26 +9408,26 @@ | ||
9519 | 9408 | state.addr = 18446744073709551465LLU; // 999999997n''''''''''''''' |
9520 | 9409 | break; |
9521 | 9410 | } |
9522 | - case 18446744073709551209LLU: // 999999993n''''''''''''''' | |
9411 | + case 18446744073709551212LLU: // 999999993q''''''''''''''' | |
9523 | 9412 | { |
9524 | 9413 | // parameter elemdef___ dstpar____ goes out of scope |
9525 | - state.addr = 18446744073709551211LLU; // 999999993p''''''''''''''' | |
9414 | + state.addr = 18446744073709551214LLU; // 999999993s''''''''''''''' | |
9526 | 9415 | break; |
9527 | 9416 | } |
9528 | - case 18446744073709551212LLU: // 999999993q''''''''''''''' | |
9417 | + case 18446744073709551215LLU: // 999999993t''''''''''''''' | |
9529 | 9418 | { |
9530 | - state.addr = 18446744073709551211LLU; // 999999993p''''''''''''''' | |
9419 | + state.addr = 18446744073709551214LLU; // 999999993s''''''''''''''' | |
9531 | 9420 | break; |
9532 | 9421 | } |
9533 | - case 18446744073709551211LLU: // 999999993p''''''''''''''' | |
9422 | + case 18446744073709551214LLU: // 999999993s''''''''''''''' | |
9534 | 9423 | { |
9535 | 9424 | (void)LOCAL_POP_MOVE(&heap, 9LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 9 |
9536 | 9425 | // parameter-reference elemdef___ srcpar____ goes out of scope |
9537 | 9426 | // parameter-reference list<elemdef___> srcpars___ goes out of scope |
9538 | - state.addr = 18446744073709551215LLU; // 999999993t''''''''''''''' | |
9427 | + state.addr = 18446744073709551218LLU; // 999999993w''''''''''''''' | |
9539 | 9428 | break; |
9540 | 9429 | } |
9541 | - case 18446744073709551214LLU: // 999999993s''''''''''''''' | |
9430 | + case 18446744073709551217LLU: // 999999993v''''''''''''''' | |
9542 | 9431 | { |
9543 | 9432 | list_reverse(heap.data, &/*dstpars___*/*LOCAL_ACCESS(heap.data, 6LLU, 5LLU)); |
9544 | 9433 | // ACCUMULATE ARGUMENTS - BEGIN |
@@ -9555,7 +9444,7 @@ | ||
9555 | 9444 | LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
9556 | 9445 | } |
9557 | 9446 | // ACCUMULATE ARGUMENTS - END |
9558 | - uint64_t return_to = 18446744073709551208LLU; | |
9447 | + uint64_t return_to = 18446744073709551211LLU; | |
9559 | 9448 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)); |
9560 | 9449 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
9561 | 9450 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -9564,7 +9453,7 @@ | ||
9564 | 9453 | state.addr = 890787243071635456LLU; // variant___ |
9565 | 9454 | break; |
9566 | 9455 | } |
9567 | - case 18446744073709551208LLU: // 999999993m''''''''''''''' | |
9456 | + case 18446744073709551211LLU: // 999999993p''''''''''''''' | |
9568 | 9457 | { |
9569 | 9458 | // variable list<elemdef___> dstpars___ goes out of scope |
9570 | 9459 | // (uninitialized -> no destructor-call) |
@@ -9601,10 +9490,10 @@ | ||
9601 | 9490 | uint64_t arg = 0; |
9602 | 9491 | LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
9603 | 9492 | } |
9604 | - state.addr = 18446744073709551207LLU; // 999999993l''''''''''''''' | |
9493 | + state.addr = 18446744073709551210LLU; // 999999993o''''''''''''''' | |
9605 | 9494 | break; |
9606 | 9495 | } |
9607 | - case 18446744073709551207LLU: // 999999993l''''''''''''''' | |
9496 | + case 18446744073709551210LLU: // 999999993o''''''''''''''' | |
9608 | 9497 | { |
9609 | 9498 | if(!*LOCAL_ACCESS(heap.data, 5LLU, 3LLU)) |
9610 | 9499 | { |
@@ -9611,7 +9500,7 @@ | ||
9611 | 9500 | (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 5 |
9612 | 9501 | (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4 |
9613 | 9502 | { |
9614 | - state.addr = 18446744073709551206LLU; // 999999993k''''''''''''''' | |
9503 | + state.addr = 18446744073709551209LLU; // 999999993n''''''''''''''' | |
9615 | 9504 | break; |
9616 | 9505 | } |
9617 | 9506 | } |
@@ -9631,7 +9520,7 @@ | ||
9631 | 9520 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
9632 | 9521 | } |
9633 | 9522 | // ACCUMULATE ARGUMENTS - END |
9634 | - uint64_t return_to = 18446744073709551202LLU; | |
9523 | + uint64_t return_to = 18446744073709551205LLU; | |
9635 | 9524 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
9636 | 9525 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
9637 | 9526 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -9640,12 +9529,12 @@ | ||
9640 | 9529 | state.addr = 66057858067013632LLU; // CopyVarR__ |
9641 | 9530 | break; |
9642 | 9531 | } |
9643 | - case 18446744073709551202LLU: // 999999993g''''''''''''''' | |
9532 | + case 18446744073709551205LLU: // 999999993j''''''''''''''' | |
9644 | 9533 | { |
9645 | - state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 6LLU, 5LLU), &*LOCAL_ACCESS(heap.data, 6LLU, 2LLU), 4) ? 18446744073709551205LLU : 18446744073709551204LLU; | |
9534 | + state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 6LLU, 5LLU), &*LOCAL_ACCESS(heap.data, 6LLU, 2LLU), 4) ? 18446744073709551208LLU : 18446744073709551207LLU; | |
9646 | 9535 | break; |
9647 | 9536 | } |
9648 | - case 18446744073709551205LLU: // 999999993j''''''''''''''' | |
9537 | + case 18446744073709551208LLU: // 999999993m''''''''''''''' | |
9649 | 9538 | { |
9650 | 9539 | { |
9651 | 9540 | fprintf(stderr, "%s\n", "INTERNAL ERROR: out of memory in copyvars - recompile compiler with more dynamic heap"); |
@@ -9658,35 +9547,35 @@ | ||
9658 | 9547 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
9659 | 9548 | } |
9660 | 9549 | // ACCUMULATE ARGUMENTS - END |
9661 | - uint64_t return_to = 18446744073709551201LLU; | |
9550 | + uint64_t return_to = 18446744073709551204LLU; | |
9662 | 9551 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
9663 | 9552 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
9664 | 9553 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
9665 | 9554 | heap.data[0].elem1 = heap.data[0].elem0; |
9666 | 9555 | heap.data[0].elem0 = restore; |
9667 | - state.addr = 18446744073709551229LLU; // 9999999937''''''''''''''' | |
9556 | + state.addr = 18446744073709551232LLU; // 999999994_''''''''''''''' | |
9668 | 9557 | break; |
9669 | 9558 | } |
9670 | - case 18446744073709551201LLU: // 999999993f''''''''''''''' | |
9559 | + case 18446744073709551204LLU: // 999999993i''''''''''''''' | |
9671 | 9560 | { |
9672 | 9561 | // parameter variant___ dst_______ goes out of scope |
9673 | - state.addr = 18446744073709551203LLU; // 999999993h''''''''''''''' | |
9562 | + state.addr = 18446744073709551206LLU; // 999999993k''''''''''''''' | |
9674 | 9563 | break; |
9675 | 9564 | } |
9676 | - case 18446744073709551204LLU: // 999999993i''''''''''''''' | |
9565 | + case 18446744073709551207LLU: // 999999993l''''''''''''''' | |
9677 | 9566 | { |
9678 | - state.addr = 18446744073709551203LLU; // 999999993h''''''''''''''' | |
9567 | + state.addr = 18446744073709551206LLU; // 999999993k''''''''''''''' | |
9679 | 9568 | break; |
9680 | 9569 | } |
9681 | - case 18446744073709551203LLU: // 999999993h''''''''''''''' | |
9570 | + case 18446744073709551206LLU: // 999999993k''''''''''''''' | |
9682 | 9571 | { |
9683 | 9572 | (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 6 |
9684 | 9573 | // parameter-reference variant___ src_______ goes out of scope |
9685 | 9574 | // parameter-reference list<variant___> srcs______ goes out of scope |
9686 | - state.addr = 18446744073709551207LLU; // 999999993l''''''''''''''' | |
9575 | + state.addr = 18446744073709551210LLU; // 999999993o''''''''''''''' | |
9687 | 9576 | break; |
9688 | 9577 | } |
9689 | - case 18446744073709551206LLU: // 999999993k''''''''''''''' | |
9578 | + case 18446744073709551209LLU: // 999999993n''''''''''''''' | |
9690 | 9579 | { |
9691 | 9580 | swap(&*LOCAL_ACCESS(heap.data, 3LLU, 2LLU), &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU))); // result |
9692 | 9581 | // variable list<variant___> dsts______ goes out of scope |
@@ -9703,7 +9592,7 @@ | ||
9703 | 9592 | } |
9704 | 9593 | break; |
9705 | 9594 | } |
9706 | - case 18446744073709551199LLU: // 999999993d''''''''''''''' | |
9595 | + case 18446744073709551202LLU: // 999999993g''''''''''''''' | |
9707 | 9596 | { |
9708 | 9597 | // destructor for variant tkunion___ |
9709 | 9598 | { |
@@ -9711,14 +9600,14 @@ | ||
9711 | 9600 | LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
9712 | 9601 | } |
9713 | 9602 | // emitted destructur for type list<variant___> |
9714 | - state.addr = 18446744073709551196LLU; // 999999993a''''''''''''''' | |
9603 | + state.addr = 18446744073709551199LLU; // 999999993d''''''''''''''' | |
9715 | 9604 | break; |
9716 | 9605 | } |
9717 | - case 18446744073709551196LLU: // 999999993a''''''''''''''' | |
9606 | + case 18446744073709551199LLU: // 999999993d''''''''''''''' | |
9718 | 9607 | { |
9719 | 9608 | if(!*LOCAL_ACCESS(heap.data, 2LLU, 1LLU)/*list*/) |
9720 | 9609 | { |
9721 | - state.addr = 18446744073709551197LLU; // 999999993b''''''''''''''' | |
9610 | + state.addr = 18446744073709551200LLU; // 999999993e''''''''''''''' | |
9722 | 9611 | break; |
9723 | 9612 | } |
9724 | 9613 | // temporary list-element |
@@ -9732,23 +9621,23 @@ | ||
9732 | 9621 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
9733 | 9622 | } |
9734 | 9623 | // ACCUMULATE ARGUMENTS - END |
9735 | - uint64_t return_to = 18446744073709551195LLU; | |
9624 | + uint64_t return_to = 18446744073709551198LLU; | |
9736 | 9625 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
9737 | 9626 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
9738 | 9627 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
9739 | 9628 | heap.data[0].elem1 = heap.data[0].elem0; |
9740 | 9629 | heap.data[0].elem0 = restore; |
9741 | - state.addr = 18446744073709551229LLU; // 9999999937''''''''''''''' | |
9630 | + state.addr = 18446744073709551232LLU; // 999999994_''''''''''''''' | |
9742 | 9631 | break; |
9743 | 9632 | } |
9744 | - case 18446744073709551195LLU: // 999999993$''''''''''''''' | |
9633 | + case 18446744073709551198LLU: // 999999993c''''''''''''''' | |
9745 | 9634 | { |
9746 | 9635 | // RELEASE temporary destructor-variable |
9747 | 9636 | (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 3 |
9748 | - state.addr = 18446744073709551196LLU; // 999999993a''''''''''''''' | |
9637 | + state.addr = 18446744073709551199LLU; // 999999993d''''''''''''''' | |
9749 | 9638 | break; |
9750 | 9639 | } |
9751 | - case 18446744073709551197LLU: // 999999993b''''''''''''''' | |
9640 | + case 18446744073709551200LLU: // 999999993e''''''''''''''' | |
9752 | 9641 | { |
9753 | 9642 | // RELEASE temporary destructor-variable |
9754 | 9643 | (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2 |
@@ -9762,7 +9651,7 @@ | ||
9762 | 9651 | } |
9763 | 9652 | break; |
9764 | 9653 | } |
9765 | - case 18446744073709551198LLU: // 999999993c''''''''''''''' | |
9654 | + case 18446744073709551201LLU: // 999999993f''''''''''''''' | |
9766 | 9655 | { |
9767 | 9656 | // destructor for variant tkstruct__ |
9768 | 9657 | { |
@@ -9770,14 +9659,14 @@ | ||
9770 | 9659 | LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
9771 | 9660 | } |
9772 | 9661 | // emitted destructur for type list<elemdef___> |
9773 | - state.addr = 18446744073709551193LLU; // 999999993Y''''''''''''''' | |
9662 | + state.addr = 18446744073709551196LLU; // 999999993a''''''''''''''' | |
9774 | 9663 | break; |
9775 | 9664 | } |
9776 | - case 18446744073709551193LLU: // 999999993Y''''''''''''''' | |
9665 | + case 18446744073709551196LLU: // 999999993a''''''''''''''' | |
9777 | 9666 | { |
9778 | 9667 | if(!*LOCAL_ACCESS(heap.data, 2LLU, 1LLU)/*list*/) |
9779 | 9668 | { |
9780 | - state.addr = 18446744073709551194LLU; // 999999993Z''''''''''''''' | |
9669 | + state.addr = 18446744073709551197LLU; // 999999993b''''''''''''''' | |
9781 | 9670 | break; |
9782 | 9671 | } |
9783 | 9672 | // temporary list-element |
@@ -9791,7 +9680,7 @@ | ||
9791 | 9680 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
9792 | 9681 | } |
9793 | 9682 | // ACCUMULATE ARGUMENTS - END |
9794 | - uint64_t return_to = 18446744073709551192LLU; | |
9683 | + uint64_t return_to = 18446744073709551195LLU; | |
9795 | 9684 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
9796 | 9685 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
9797 | 9686 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -9800,14 +9689,14 @@ | ||
9800 | 9689 | state.addr = 18446744073709551465LLU; // 999999997n''''''''''''''' |
9801 | 9690 | break; |
9802 | 9691 | } |
9803 | - case 18446744073709551192LLU: // 999999993X''''''''''''''' | |
9692 | + case 18446744073709551195LLU: // 999999993$''''''''''''''' | |
9804 | 9693 | { |
9805 | 9694 | // RELEASE temporary destructor-variable |
9806 | 9695 | (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 3 |
9807 | - state.addr = 18446744073709551193LLU; // 999999993Y''''''''''''''' | |
9696 | + state.addr = 18446744073709551196LLU; // 999999993a''''''''''''''' | |
9808 | 9697 | break; |
9809 | 9698 | } |
9810 | - case 18446744073709551194LLU: // 999999993Z''''''''''''''' | |
9699 | + case 18446744073709551197LLU: // 999999993b''''''''''''''' | |
9811 | 9700 | { |
9812 | 9701 | // RELEASE temporary destructor-variable |
9813 | 9702 | (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2 |
@@ -9821,11 +9710,11 @@ | ||
9821 | 9710 | } |
9822 | 9711 | break; |
9823 | 9712 | } |
9824 | - case 18446744073709551200LLU: // 999999993e''''''''''''''' | |
9713 | + case 18446744073709551203LLU: // 999999993h''''''''''''''' | |
9825 | 9714 | { |
9826 | 9715 | struct pair type_data = unpair(&heap, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))); |
9827 | 9716 | *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU)) = type_data.elem1; |
9828 | - state.addr = 18446744073709551198LLU + type_data.elem0; | |
9717 | + state.addr = 18446744073709551201LLU + type_data.elem0; | |
9829 | 9718 | break; |
9830 | 9719 | } |
9831 | 9720 | case 857586742161833984LLU: // tkunion___ |
@@ -9888,7 +9777,7 @@ | ||
9888 | 9777 | { |
9889 | 9778 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 != 0/*tkstruct__*/) |
9890 | 9779 | { |
9891 | - state.addr = 18446744073709551191LLU; // 999999993W''''''''''''''' | |
9780 | + state.addr = 18446744073709551194LLU; // 999999993Z''''''''''''''' | |
9892 | 9781 | break; |
9893 | 9782 | } |
9894 | 9783 | { |
@@ -9911,10 +9800,10 @@ | ||
9911 | 9800 | uint64_t arg = 0; |
9912 | 9801 | LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
9913 | 9802 | } |
9914 | - state.addr = 18446744073709551190LLU; // 999999993V''''''''''''''' | |
9803 | + state.addr = 18446744073709551193LLU; // 999999993Y''''''''''''''' | |
9915 | 9804 | break; |
9916 | 9805 | } |
9917 | - case 18446744073709551190LLU: // 999999993V''''''''''''''' | |
9806 | + case 18446744073709551193LLU: // 999999993Y''''''''''''''' | |
9918 | 9807 | { |
9919 | 9808 | if(!*LOCAL_ACCESS(heap.data, 7LLU, 5LLU)) |
9920 | 9809 | { |
@@ -9921,7 +9810,7 @@ | ||
9921 | 9810 | (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 7 |
9922 | 9811 | (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 6 |
9923 | 9812 | { |
9924 | - state.addr = 18446744073709551189LLU; // 999999993U''''''''''''''' | |
9813 | + state.addr = 18446744073709551192LLU; // 999999993X''''''''''''''' | |
9925 | 9814 | break; |
9926 | 9815 | } |
9927 | 9816 | } |
@@ -9954,7 +9843,7 @@ | ||
9954 | 9843 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
9955 | 9844 | } |
9956 | 9845 | // ACCUMULATE ARGUMENTS - END |
9957 | - uint64_t return_to = 18446744073709551184LLU; | |
9846 | + uint64_t return_to = 18446744073709551187LLU; | |
9958 | 9847 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
9959 | 9848 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
9960 | 9849 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -9963,7 +9852,7 @@ | ||
9963 | 9852 | state.addr = 552446646280519680LLU; // copyu64___ |
9964 | 9853 | break; |
9965 | 9854 | } |
9966 | - case 18446744073709551184LLU: // 999999993P''''''''''''''' | |
9855 | + case 18446744073709551187LLU: // 999999993S''''''''''''''' | |
9967 | 9856 | { |
9968 | 9857 | { |
9969 | 9858 | uint64_t exchange = LOCAL_POP_MOVE(&heap, 10LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 10*/; |
@@ -9992,7 +9881,7 @@ | ||
9992 | 9881 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
9993 | 9882 | } |
9994 | 9883 | // ACCUMULATE ARGUMENTS - END |
9995 | - uint64_t return_to = 18446744073709551183LLU; | |
9884 | + uint64_t return_to = 18446744073709551186LLU; | |
9996 | 9885 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
9997 | 9886 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
9998 | 9887 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -10001,7 +9890,7 @@ | ||
10001 | 9890 | state.addr = 367395560426147840LLU; // TYPECOPY__ |
10002 | 9891 | break; |
10003 | 9892 | } |
10004 | - case 18446744073709551183LLU: // 999999993O''''''''''''''' | |
9893 | + case 18446744073709551186LLU: // 999999993R''''''''''''''' | |
10005 | 9894 | { |
10006 | 9895 | { |
10007 | 9896 | uint64_t exchange = LOCAL_POP_MOVE(&heap, 10LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 10*/; |
@@ -10013,7 +9902,7 @@ | ||
10013 | 9902 | } |
10014 | 9903 | } |
10015 | 9904 | // ACCUMULATE ARGUMENTS - END |
10016 | - uint64_t return_to = 18446744073709551185LLU; | |
9905 | + uint64_t return_to = 18446744073709551188LLU; | |
10017 | 9906 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)); |
10018 | 9907 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
10019 | 9908 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -10022,12 +9911,12 @@ | ||
10022 | 9911 | state.addr = 587581796494082048LLU; // elemdef___ |
10023 | 9912 | break; |
10024 | 9913 | } |
10025 | - case 18446744073709551185LLU: // 999999993Q''''''''''''''' | |
9914 | + case 18446744073709551188LLU: // 999999993T''''''''''''''' | |
10026 | 9915 | { |
10027 | - state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 8LLU, 7LLU), &*LOCAL_ACCESS(heap.data, 8LLU, 4LLU), 7) ? 18446744073709551188LLU : 18446744073709551187LLU; | |
9916 | + state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 8LLU, 7LLU), &*LOCAL_ACCESS(heap.data, 8LLU, 4LLU), 7) ? 18446744073709551191LLU : 18446744073709551190LLU; | |
10028 | 9917 | break; |
10029 | 9918 | } |
10030 | - case 18446744073709551188LLU: // 999999993T''''''''''''''' | |
9919 | + case 18446744073709551191LLU: // 999999993W''''''''''''''' | |
10031 | 9920 | { |
10032 | 9921 | { |
10033 | 9922 | fprintf(stderr, "%s\n", "INTERNAL ERROR: out of memory in copytk - recompile compiler with more dynamic heap"); |
@@ -10040,7 +9929,7 @@ | ||
10040 | 9929 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
10041 | 9930 | } |
10042 | 9931 | // ACCUMULATE ARGUMENTS - END |
10043 | - uint64_t return_to = 18446744073709551182LLU; | |
9932 | + uint64_t return_to = 18446744073709551185LLU; | |
10044 | 9933 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
10045 | 9934 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
10046 | 9935 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -10049,26 +9938,26 @@ | ||
10049 | 9938 | state.addr = 18446744073709551465LLU; // 999999997n''''''''''''''' |
10050 | 9939 | break; |
10051 | 9940 | } |
10052 | - case 18446744073709551182LLU: // 999999993N''''''''''''''' | |
9941 | + case 18446744073709551185LLU: // 999999993Q''''''''''''''' | |
10053 | 9942 | { |
10054 | 9943 | // parameter elemdef___ DEFPAR____ goes out of scope |
10055 | - state.addr = 18446744073709551186LLU; // 999999993R''''''''''''''' | |
9944 | + state.addr = 18446744073709551189LLU; // 999999993U''''''''''''''' | |
10056 | 9945 | break; |
10057 | 9946 | } |
10058 | - case 18446744073709551187LLU: // 999999993S''''''''''''''' | |
9947 | + case 18446744073709551190LLU: // 999999993V''''''''''''''' | |
10059 | 9948 | { |
10060 | - state.addr = 18446744073709551186LLU; // 999999993R''''''''''''''' | |
9949 | + state.addr = 18446744073709551189LLU; // 999999993U''''''''''''''' | |
10061 | 9950 | break; |
10062 | 9951 | } |
10063 | - case 18446744073709551186LLU: // 999999993R''''''''''''''' | |
9952 | + case 18446744073709551189LLU: // 999999993U''''''''''''''' | |
10064 | 9953 | { |
10065 | 9954 | (void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 8 |
10066 | 9955 | // parameter-reference elemdef___ defpar____ goes out of scope |
10067 | 9956 | // parameter-reference list<elemdef___> defpars___ goes out of scope |
10068 | - state.addr = 18446744073709551190LLU; // 999999993V''''''''''''''' | |
9957 | + state.addr = 18446744073709551193LLU; // 999999993Y''''''''''''''' | |
10069 | 9958 | break; |
10070 | 9959 | } |
10071 | - case 18446744073709551189LLU: // 999999993U''''''''''''''' | |
9960 | + case 18446744073709551192LLU: // 999999993X''''''''''''''' | |
10072 | 9961 | { |
10073 | 9962 | list_reverse(heap.data, &/*DEFPARS___*/*LOCAL_ACCESS(heap.data, 5LLU, 4LLU)); |
10074 | 9963 | // ACCUMULATE ARGUMENTS - BEGIN |
@@ -10081,7 +9970,7 @@ | ||
10081 | 9970 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
10082 | 9971 | } |
10083 | 9972 | // ACCUMULATE ARGUMENTS - END |
10084 | - uint64_t return_to = 18446744073709551181LLU; | |
9973 | + uint64_t return_to = 18446744073709551184LLU; | |
10085 | 9974 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
10086 | 9975 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
10087 | 9976 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -10090,7 +9979,7 @@ | ||
10090 | 9979 | state.addr = 857578368147320832LLU; // tkstruct__ |
10091 | 9980 | break; |
10092 | 9981 | } |
10093 | - case 18446744073709551181LLU: // 999999993M''''''''''''''' | |
9982 | + case 18446744073709551184LLU: // 999999993P''''''''''''''' | |
10094 | 9983 | { |
10095 | 9984 | // variable list<elemdef___> DEFPARS___ goes out of scope |
10096 | 9985 | // (uninitialized -> no destructor-call) |
@@ -10110,11 +9999,11 @@ | ||
10110 | 9999 | } |
10111 | 10000 | break; |
10112 | 10001 | } |
10113 | - case 18446744073709551191LLU: // 999999993W''''''''''''''' | |
10002 | + case 18446744073709551194LLU: // 999999993Z''''''''''''''' | |
10114 | 10003 | { |
10115 | 10004 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 != 1/*tkunion___*/) |
10116 | 10005 | { |
10117 | - state.addr = 18446744073709551180LLU; // 999999993L''''''''''''''' | |
10006 | + state.addr = 18446744073709551183LLU; // 999999993O''''''''''''''' | |
10118 | 10007 | break; |
10119 | 10008 | } |
10120 | 10009 | { |
@@ -10137,10 +10026,10 @@ | ||
10137 | 10026 | uint64_t arg = 0; |
10138 | 10027 | LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
10139 | 10028 | } |
10140 | - state.addr = 18446744073709551179LLU; // 999999993K''''''''''''''' | |
10029 | + state.addr = 18446744073709551182LLU; // 999999993N''''''''''''''' | |
10141 | 10030 | break; |
10142 | 10031 | } |
10143 | - case 18446744073709551179LLU: // 999999993K''''''''''''''' | |
10032 | + case 18446744073709551182LLU: // 999999993N''''''''''''''' | |
10144 | 10033 | { |
10145 | 10034 | if(!*LOCAL_ACCESS(heap.data, 7LLU, 5LLU)) |
10146 | 10035 | { |
@@ -10147,7 +10036,7 @@ | ||
10147 | 10036 | (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 7 |
10148 | 10037 | (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 6 |
10149 | 10038 | { |
10150 | - state.addr = 18446744073709551178LLU; // 999999993J''''''''''''''' | |
10039 | + state.addr = 18446744073709551181LLU; // 999999993M''''''''''''''' | |
10151 | 10040 | break; |
10152 | 10041 | } |
10153 | 10042 | } |
@@ -10167,7 +10056,7 @@ | ||
10167 | 10056 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
10168 | 10057 | } |
10169 | 10058 | // ACCUMULATE ARGUMENTS - END |
10170 | - uint64_t return_to = 18446744073709551174LLU; | |
10059 | + uint64_t return_to = 18446744073709551177LLU; | |
10171 | 10060 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
10172 | 10061 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
10173 | 10062 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -10176,12 +10065,12 @@ | ||
10176 | 10065 | state.addr = 66057858066939904LLU; // CopyVar___ |
10177 | 10066 | break; |
10178 | 10067 | } |
10179 | - case 18446744073709551174LLU: // 999999993F''''''''''''''' | |
10068 | + case 18446744073709551177LLU: // 999999993I''''''''''''''' | |
10180 | 10069 | { |
10181 | - state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 8LLU, 7LLU), &*LOCAL_ACCESS(heap.data, 8LLU, 4LLU), 4) ? 18446744073709551177LLU : 18446744073709551176LLU; | |
10070 | + state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 8LLU, 7LLU), &*LOCAL_ACCESS(heap.data, 8LLU, 4LLU), 4) ? 18446744073709551180LLU : 18446744073709551179LLU; | |
10182 | 10071 | break; |
10183 | 10072 | } |
10184 | - case 18446744073709551177LLU: // 999999993I''''''''''''''' | |
10073 | + case 18446744073709551180LLU: // 999999993L''''''''''''''' | |
10185 | 10074 | { |
10186 | 10075 | { |
10187 | 10076 | fprintf(stderr, "%s\n", "INTERNAL ERROR: out of memory in copytk - recompile compiler with more dynamic heap"); |
@@ -10194,35 +10083,35 @@ | ||
10194 | 10083 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
10195 | 10084 | } |
10196 | 10085 | // ACCUMULATE ARGUMENTS - END |
10197 | - uint64_t return_to = 18446744073709551173LLU; | |
10086 | + uint64_t return_to = 18446744073709551176LLU; | |
10198 | 10087 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
10199 | 10088 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
10200 | 10089 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
10201 | 10090 | heap.data[0].elem1 = heap.data[0].elem0; |
10202 | 10091 | heap.data[0].elem0 = restore; |
10203 | - state.addr = 18446744073709551229LLU; // 9999999937''''''''''''''' | |
10092 | + state.addr = 18446744073709551232LLU; // 999999994_''''''''''''''' | |
10204 | 10093 | break; |
10205 | 10094 | } |
10206 | - case 18446744073709551173LLU: // 999999993E''''''''''''''' | |
10095 | + case 18446744073709551176LLU: // 999999993H''''''''''''''' | |
10207 | 10096 | { |
10208 | 10097 | // parameter variant___ tmp_______ goes out of scope |
10209 | - state.addr = 18446744073709551175LLU; // 999999993G''''''''''''''' | |
10098 | + state.addr = 18446744073709551178LLU; // 999999993J''''''''''''''' | |
10210 | 10099 | break; |
10211 | 10100 | } |
10212 | - case 18446744073709551176LLU: // 999999993H''''''''''''''' | |
10101 | + case 18446744073709551179LLU: // 999999993K''''''''''''''' | |
10213 | 10102 | { |
10214 | - state.addr = 18446744073709551175LLU; // 999999993G''''''''''''''' | |
10103 | + state.addr = 18446744073709551178LLU; // 999999993J''''''''''''''' | |
10215 | 10104 | break; |
10216 | 10105 | } |
10217 | - case 18446744073709551175LLU: // 999999993G''''''''''''''' | |
10106 | + case 18446744073709551178LLU: // 999999993J''''''''''''''' | |
10218 | 10107 | { |
10219 | 10108 | (void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 8 |
10220 | 10109 | // parameter-reference variant___ constr____ goes out of scope |
10221 | 10110 | // parameter-reference list<variant___> constrs___ goes out of scope |
10222 | - state.addr = 18446744073709551179LLU; // 999999993K''''''''''''''' | |
10111 | + state.addr = 18446744073709551182LLU; // 999999993N''''''''''''''' | |
10223 | 10112 | break; |
10224 | 10113 | } |
10225 | - case 18446744073709551178LLU: // 999999993J''''''''''''''' | |
10114 | + case 18446744073709551181LLU: // 999999993M''''''''''''''' | |
10226 | 10115 | { |
10227 | 10116 | list_reverse(heap.data, &/*CONSTRS___*/*LOCAL_ACCESS(heap.data, 5LLU, 4LLU)); |
10228 | 10117 | // ACCUMULATE ARGUMENTS - BEGIN |
@@ -10235,7 +10124,7 @@ | ||
10235 | 10124 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
10236 | 10125 | } |
10237 | 10126 | // ACCUMULATE ARGUMENTS - END |
10238 | - uint64_t return_to = 18446744073709551172LLU; | |
10127 | + uint64_t return_to = 18446744073709551175LLU; | |
10239 | 10128 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
10240 | 10129 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
10241 | 10130 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -10244,7 +10133,7 @@ | ||
10244 | 10133 | state.addr = 857586742161833984LLU; // tkunion___ |
10245 | 10134 | break; |
10246 | 10135 | } |
10247 | - case 18446744073709551172LLU: // 999999993D''''''''''''''' | |
10136 | + case 18446744073709551175LLU: // 999999993G''''''''''''''' | |
10248 | 10137 | { |
10249 | 10138 | // variable list<variant___> CONSTRS___ goes out of scope |
10250 | 10139 | // (uninitialized -> no destructor-call) |
@@ -10264,7 +10153,7 @@ | ||
10264 | 10153 | } |
10265 | 10154 | break; |
10266 | 10155 | } |
10267 | - case 18446744073709551180LLU: // 999999993L''''''''''''''' | |
10156 | + case 18446744073709551183LLU: // 999999993O''''''''''''''' | |
10268 | 10157 | { |
10269 | 10158 | fprintf(stderr, "INTERNAL COMPILER ERROR: missing pattern-match-case in definition of CopyTK____\n"); |
10270 | 10159 | exit(-1); |
@@ -10274,7 +10163,7 @@ | ||
10274 | 10163 | { |
10275 | 10164 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 0/*tkstruct__*/) |
10276 | 10165 | { |
10277 | - state.addr = 18446744073709551171LLU; // 999999993C''''''''''''''' | |
10166 | + state.addr = 18446744073709551174LLU; // 999999993F''''''''''''''' | |
10278 | 10167 | break; |
10279 | 10168 | } |
10280 | 10169 | { |
@@ -10294,11 +10183,11 @@ | ||
10294 | 10183 | } |
10295 | 10184 | break; |
10296 | 10185 | } |
10297 | - case 18446744073709551171LLU: // 999999993C''''''''''''''' | |
10186 | + case 18446744073709551174LLU: // 999999993F''''''''''''''' | |
10298 | 10187 | { |
10299 | 10188 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 1/*tkunion___*/) |
10300 | 10189 | { |
10301 | - state.addr = 18446744073709551170LLU; // 999999993B''''''''''''''' | |
10190 | + state.addr = 18446744073709551173LLU; // 999999993E''''''''''''''' | |
10302 | 10191 | break; |
10303 | 10192 | } |
10304 | 10193 | { |
@@ -10318,13 +10207,13 @@ | ||
10318 | 10207 | } |
10319 | 10208 | break; |
10320 | 10209 | } |
10321 | - case 18446744073709551170LLU: // 999999993B''''''''''''''' | |
10210 | + case 18446744073709551173LLU: // 999999993E''''''''''''''' | |
10322 | 10211 | { |
10323 | 10212 | fprintf(stderr, "INTERNAL COMPILER ERROR: missing pattern-match-case in definition of reporttyk_\n"); |
10324 | 10213 | exit(-1); |
10325 | 10214 | break; |
10326 | 10215 | } |
10327 | - case 18446744073709551169LLU: // 999999993A''''''''''''''' | |
10216 | + case 18446744073709551172LLU: // 999999993D''''''''''''''' | |
10328 | 10217 | { |
10329 | 10218 | { |
10330 | 10219 | uint64_t arg = tree_pop_move(&heap, 2LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))); |
@@ -10344,7 +10233,7 @@ | ||
10344 | 10233 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
10345 | 10234 | } |
10346 | 10235 | // ACCUMULATE ARGUMENTS - END |
10347 | - uint64_t return_to = 18446744073709551168LLU; | |
10236 | + uint64_t return_to = 18446744073709551171LLU; | |
10348 | 10237 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
10349 | 10238 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
10350 | 10239 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -10353,7 +10242,7 @@ | ||
10353 | 10242 | state.addr = 18446744073709551484LLU; // 9999999976''''''''''''''' |
10354 | 10243 | break; |
10355 | 10244 | } |
10356 | - case 18446744073709551168LLU: // 999999993_''''''''''''''' | |
10245 | + case 18446744073709551171LLU: // 999999993C''''''''''''''' | |
10357 | 10246 | { |
10358 | 10247 | // RELEASE temporary destructor-variable |
10359 | 10248 | (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2 |
@@ -10398,7 +10287,7 @@ | ||
10398 | 10287 | } |
10399 | 10288 | break; |
10400 | 10289 | } |
10401 | - case 18446744073709551167LLU: // 9999999929''''''''''''''' | |
10290 | + case 18446744073709551170LLU: // 999999993B''''''''''''''' | |
10402 | 10291 | { |
10403 | 10292 | { |
10404 | 10293 | uint64_t arg = tree_pop_move(&heap, 3LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))); |
@@ -10412,14 +10301,14 @@ | ||
10412 | 10301 | LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
10413 | 10302 | } |
10414 | 10303 | // emitted destructur for type list<varentry__> |
10415 | - state.addr = 18446744073709551165LLU; // 9999999927''''''''''''''' | |
10304 | + state.addr = 18446744073709551168LLU; // 999999993_''''''''''''''' | |
10416 | 10305 | break; |
10417 | 10306 | } |
10418 | - case 18446744073709551165LLU: // 9999999927''''''''''''''' | |
10307 | + case 18446744073709551168LLU: // 999999993_''''''''''''''' | |
10419 | 10308 | { |
10420 | 10309 | if(!*LOCAL_ACCESS(heap.data, 2LLU, 1LLU)/*list*/) |
10421 | 10310 | { |
10422 | - state.addr = 18446744073709551166LLU; // 9999999928''''''''''''''' | |
10311 | + state.addr = 18446744073709551169LLU; // 999999993A''''''''''''''' | |
10423 | 10312 | break; |
10424 | 10313 | } |
10425 | 10314 | // temporary list-element |
@@ -10433,23 +10322,23 @@ | ||
10433 | 10322 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
10434 | 10323 | } |
10435 | 10324 | // ACCUMULATE ARGUMENTS - END |
10436 | - uint64_t return_to = 18446744073709551164LLU; | |
10325 | + uint64_t return_to = 18446744073709551167LLU; | |
10437 | 10326 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
10438 | 10327 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
10439 | 10328 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
10440 | 10329 | heap.data[0].elem1 = heap.data[0].elem0; |
10441 | 10330 | heap.data[0].elem0 = restore; |
10442 | - state.addr = 18446744073709551169LLU; // 999999993A''''''''''''''' | |
10331 | + state.addr = 18446744073709551172LLU; // 999999993D''''''''''''''' | |
10443 | 10332 | break; |
10444 | 10333 | } |
10445 | - case 18446744073709551164LLU: // 9999999926''''''''''''''' | |
10334 | + case 18446744073709551167LLU: // 9999999929''''''''''''''' | |
10446 | 10335 | { |
10447 | 10336 | // RELEASE temporary destructor-variable |
10448 | 10337 | (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 3 |
10449 | - state.addr = 18446744073709551165LLU; // 9999999927''''''''''''''' | |
10338 | + state.addr = 18446744073709551168LLU; // 999999993_''''''''''''''' | |
10450 | 10339 | break; |
10451 | 10340 | } |
10452 | - case 18446744073709551166LLU: // 9999999928''''''''''''''' | |
10341 | + case 18446744073709551169LLU: // 999999993A''''''''''''''' | |
10453 | 10342 | { |
10454 | 10343 | // RELEASE temporary destructor-variable |
10455 | 10344 | (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2 |
@@ -10464,7 +10353,7 @@ | ||
10464 | 10353 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
10465 | 10354 | } |
10466 | 10355 | // ACCUMULATE ARGUMENTS - END |
10467 | - uint64_t return_to = 18446744073709551163LLU; | |
10356 | + uint64_t return_to = 18446744073709551166LLU; | |
10468 | 10357 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
10469 | 10358 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
10470 | 10359 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -10473,7 +10362,7 @@ | ||
10473 | 10362 | state.addr = 18446744073709551495LLU; // 999999998G''''''''''''''' |
10474 | 10363 | break; |
10475 | 10364 | } |
10476 | - case 18446744073709551163LLU: // 9999999925''''''''''''''' | |
10365 | + case 18446744073709551166LLU: // 9999999928''''''''''''''' | |
10477 | 10366 | { |
10478 | 10367 | // RELEASE temporary destructor-variable |
10479 | 10368 | (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2 |
@@ -10525,7 +10414,7 @@ | ||
10525 | 10414 | } |
10526 | 10415 | break; |
10527 | 10416 | } |
10528 | - case 18446744073709551162LLU: // 9999999924''''''''''''''' | |
10417 | + case 18446744073709551165LLU: // 9999999927''''''''''''''' | |
10529 | 10418 | { |
10530 | 10419 | { |
10531 | 10420 | uint64_t arg = tree_pop_move(&heap, 3LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))); |
@@ -10545,16 +10434,16 @@ | ||
10545 | 10434 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
10546 | 10435 | } |
10547 | 10436 | // ACCUMULATE ARGUMENTS - END |
10548 | - uint64_t return_to = 18446744073709551161LLU; | |
10437 | + uint64_t return_to = 18446744073709551164LLU; | |
10549 | 10438 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
10550 | 10439 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
10551 | 10440 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
10552 | 10441 | heap.data[0].elem1 = heap.data[0].elem0; |
10553 | 10442 | heap.data[0].elem0 = restore; |
10554 | - state.addr = 18446744073709551383LLU; // 999999996W''''''''''''''' | |
10443 | + state.addr = 18446744073709551386LLU; // 999999996Z''''''''''''''' | |
10555 | 10444 | break; |
10556 | 10445 | } |
10557 | - case 18446744073709551161LLU: // 9999999923''''''''''''''' | |
10446 | + case 18446744073709551164LLU: // 9999999926''''''''''''''' | |
10558 | 10447 | { |
10559 | 10448 | // RELEASE temporary destructor-variable |
10560 | 10449 | (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2 |
@@ -10613,7 +10502,7 @@ | ||
10613 | 10502 | } |
10614 | 10503 | break; |
10615 | 10504 | } |
10616 | - case 18446744073709551160LLU: // 9999999922''''''''''''''' | |
10505 | + case 18446744073709551163LLU: // 9999999925''''''''''''''' | |
10617 | 10506 | { |
10618 | 10507 | { |
10619 | 10508 | uint64_t arg = tree_pop_move(&heap, 4LLU, &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))); |
@@ -10640,16 +10529,16 @@ | ||
10640 | 10529 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
10641 | 10530 | } |
10642 | 10531 | // ACCUMULATE ARGUMENTS - END |
10643 | - uint64_t return_to = 18446744073709551159LLU; | |
10532 | + uint64_t return_to = 18446744073709551162LLU; | |
10644 | 10533 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
10645 | 10534 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
10646 | 10535 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
10647 | 10536 | heap.data[0].elem1 = heap.data[0].elem0; |
10648 | 10537 | heap.data[0].elem0 = restore; |
10649 | - state.addr = 18446744073709551200LLU; // 999999993e''''''''''''''' | |
10538 | + state.addr = 18446744073709551203LLU; // 999999993h''''''''''''''' | |
10650 | 10539 | break; |
10651 | 10540 | } |
10652 | - case 18446744073709551159LLU: // 9999999921''''''''''''''' | |
10541 | + case 18446744073709551162LLU: // 9999999924''''''''''''''' | |
10653 | 10542 | { |
10654 | 10543 | // RELEASE temporary destructor-variable |
10655 | 10544 | (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 2 |
@@ -10752,7 +10641,7 @@ | ||
10752 | 10641 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
10753 | 10642 | } |
10754 | 10643 | // ACCUMULATE ARGUMENTS - END |
10755 | - uint64_t return_to = 18446744073709551156LLU; | |
10644 | + uint64_t return_to = 18446744073709551159LLU; | |
10756 | 10645 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
10757 | 10646 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
10758 | 10647 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -10761,7 +10650,7 @@ | ||
10761 | 10650 | state.addr = 552446646280519680LLU; // copyu64___ |
10762 | 10651 | break; |
10763 | 10652 | } |
10764 | - case 18446744073709551156LLU: // 999999992y''''''''''''''' | |
10653 | + case 18446744073709551159LLU: // 9999999921''''''''''''''' | |
10765 | 10654 | { |
10766 | 10655 | { |
10767 | 10656 | uint64_t exchange = LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 7*/; |
@@ -10790,7 +10679,7 @@ | ||
10790 | 10679 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
10791 | 10680 | } |
10792 | 10681 | // ACCUMULATE ARGUMENTS - END |
10793 | - uint64_t return_to = 18446744073709551155LLU; | |
10682 | + uint64_t return_to = 18446744073709551158LLU; | |
10794 | 10683 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
10795 | 10684 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
10796 | 10685 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -10799,7 +10688,7 @@ | ||
10799 | 10688 | state.addr = 121779622511284459LLU; // FunctionCp |
10800 | 10689 | break; |
10801 | 10690 | } |
10802 | - case 18446744073709551155LLU: // 999999992x''''''''''''''' | |
10691 | + case 18446744073709551158LLU: // 9999999920''''''''''''''' | |
10803 | 10692 | { |
10804 | 10693 | { |
10805 | 10694 | uint64_t exchange = LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 7*/; |
@@ -10828,7 +10717,7 @@ | ||
10828 | 10717 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
10829 | 10718 | } |
10830 | 10719 | // ACCUMULATE ARGUMENTS - END |
10831 | - uint64_t return_to = 18446744073709551154LLU; | |
10720 | + uint64_t return_to = 18446744073709551157LLU; | |
10832 | 10721 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
10833 | 10722 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
10834 | 10723 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -10837,7 +10726,7 @@ | ||
10837 | 10726 | state.addr = 552446646280519680LLU; // copyu64___ |
10838 | 10727 | break; |
10839 | 10728 | } |
10840 | - case 18446744073709551154LLU: // 999999992w''''''''''''''' | |
10729 | + case 18446744073709551157LLU: // 999999992z''''''''''''''' | |
10841 | 10730 | { |
10842 | 10731 | { |
10843 | 10732 | uint64_t exchange = LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 7*/; |
@@ -10849,7 +10738,7 @@ | ||
10849 | 10738 | } |
10850 | 10739 | } |
10851 | 10740 | // ACCUMULATE ARGUMENTS - END |
10852 | - uint64_t return_to = 18446744073709551157LLU; | |
10741 | + uint64_t return_to = 18446744073709551160LLU; | |
10853 | 10742 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
10854 | 10743 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
10855 | 10744 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -10858,7 +10747,7 @@ | ||
10858 | 10747 | state.addr = 567601196335104000LLU; // defidfn___ |
10859 | 10748 | break; |
10860 | 10749 | } |
10861 | - case 18446744073709551157LLU: // 999999992z''''''''''''''' | |
10750 | + case 18446744073709551160LLU: // 9999999922''''''''''''''' | |
10862 | 10751 | { |
10863 | 10752 | // parameter-reference u64 defined___ goes out of scope |
10864 | 10753 | (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference defined___ at 5 |
@@ -10940,7 +10829,7 @@ | ||
10940 | 10829 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
10941 | 10830 | } |
10942 | 10831 | // ACCUMULATE ARGUMENTS - END |
10943 | - uint64_t return_to = 18446744073709551151LLU; | |
10832 | + uint64_t return_to = 18446744073709551154LLU; | |
10944 | 10833 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
10945 | 10834 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
10946 | 10835 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -10949,7 +10838,7 @@ | ||
10949 | 10838 | state.addr = 552446646280519680LLU; // copyu64___ |
10950 | 10839 | break; |
10951 | 10840 | } |
10952 | - case 18446744073709551151LLU: // 999999992t''''''''''''''' | |
10841 | + case 18446744073709551154LLU: // 999999992w''''''''''''''' | |
10953 | 10842 | { |
10954 | 10843 | { |
10955 | 10844 | uint64_t exchange = LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 8*/; |
@@ -10978,7 +10867,7 @@ | ||
10978 | 10867 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
10979 | 10868 | } |
10980 | 10869 | // ACCUMULATE ARGUMENTS - END |
10981 | - uint64_t return_to = 18446744073709551150LLU; | |
10870 | + uint64_t return_to = 18446744073709551153LLU; | |
10982 | 10871 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
10983 | 10872 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
10984 | 10873 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -10987,7 +10876,7 @@ | ||
10987 | 10876 | state.addr = 66057855622447104LLU; // CopyTK____ |
10988 | 10877 | break; |
10989 | 10878 | } |
10990 | - case 18446744073709551150LLU: // 999999992s''''''''''''''' | |
10879 | + case 18446744073709551153LLU: // 999999992v''''''''''''''' | |
10991 | 10880 | { |
10992 | 10881 | { |
10993 | 10882 | uint64_t exchange = LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 8*/; |
@@ -11016,7 +10905,7 @@ | ||
11016 | 10905 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
11017 | 10906 | } |
11018 | 10907 | // ACCUMULATE ARGUMENTS - END |
11019 | - uint64_t return_to = 18446744073709551149LLU; | |
10908 | + uint64_t return_to = 18446744073709551152LLU; | |
11020 | 10909 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
11021 | 10910 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
11022 | 10911 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -11025,7 +10914,7 @@ | ||
11025 | 10914 | state.addr = 552446646280519680LLU; // copyu64___ |
11026 | 10915 | break; |
11027 | 10916 | } |
11028 | - case 18446744073709551149LLU: // 999999992r''''''''''''''' | |
10917 | + case 18446744073709551152LLU: // 999999992u''''''''''''''' | |
11029 | 10918 | { |
11030 | 10919 | { |
11031 | 10920 | uint64_t exchange = LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 8*/; |
@@ -11054,7 +10943,7 @@ | ||
11054 | 10943 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
11055 | 10944 | } |
11056 | 10945 | // ACCUMULATE ARGUMENTS - END |
11057 | - uint64_t return_to = 18446744073709551148LLU; | |
10946 | + uint64_t return_to = 18446744073709551151LLU; | |
11058 | 10947 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
11059 | 10948 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
11060 | 10949 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -11063,7 +10952,7 @@ | ||
11063 | 10952 | state.addr = 552446646280519680LLU; // copyu64___ |
11064 | 10953 | break; |
11065 | 10954 | } |
11066 | - case 18446744073709551148LLU: // 999999992q''''''''''''''' | |
10955 | + case 18446744073709551151LLU: // 999999992t''''''''''''''' | |
11067 | 10956 | { |
11068 | 10957 | { |
11069 | 10958 | uint64_t exchange = LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 8*/; |
@@ -11075,7 +10964,7 @@ | ||
11075 | 10964 | } |
11076 | 10965 | } |
11077 | 10966 | // ACCUMULATE ARGUMENTS - END |
11078 | - uint64_t return_to = 18446744073709551152LLU; | |
10967 | + uint64_t return_to = 18446744073709551155LLU; | |
11079 | 10968 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)); |
11080 | 10969 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
11081 | 10970 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -11084,7 +10973,7 @@ | ||
11084 | 10973 | state.addr = 861504777589358592LLU; // typedef___ |
11085 | 10974 | break; |
11086 | 10975 | } |
11087 | - case 18446744073709551152LLU: // 999999992u''''''''''''''' | |
10976 | + case 18446744073709551155LLU: // 999999992x''''''''''''''' | |
11088 | 10977 | { |
11089 | 10978 | // parameter-reference u64 destraddr1 goes out of scope |
11090 | 10979 | (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference destraddr1 at 6 |
@@ -11117,10 +11006,10 @@ | ||
11117 | 11006 | uint64_t arg = 0; |
11118 | 11007 | LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
11119 | 11008 | } |
11120 | - state.addr = 18446744073709551147LLU; // 999999992p''''''''''''''' | |
11009 | + state.addr = 18446744073709551150LLU; // 999999992s''''''''''''''' | |
11121 | 11010 | break; |
11122 | 11011 | } |
11123 | - case 18446744073709551147LLU: // 999999992p''''''''''''''' | |
11012 | + case 18446744073709551150LLU: // 999999992s''''''''''''''' | |
11124 | 11013 | { |
11125 | 11014 | if(!*LOCAL_ACCESS(heap.data, 5LLU, 3LLU)) |
11126 | 11015 | { |
@@ -11127,7 +11016,7 @@ | ||
11127 | 11016 | (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 5 |
11128 | 11017 | (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4 |
11129 | 11018 | { |
11130 | - state.addr = 18446744073709551146LLU; // 999999992o''''''''''''''' | |
11019 | + state.addr = 18446744073709551149LLU; // 999999992r''''''''''''''' | |
11131 | 11020 | break; |
11132 | 11021 | } |
11133 | 11022 | } |
@@ -11138,25 +11027,25 @@ | ||
11138 | 11027 | LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
11139 | 11028 | } |
11140 | 11029 | *LOCAL_ACCESS(heap.data, 6LLU, 5LLU) = /*id________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 6LLU, 2LLU)) == /*elem______*/*access_heap(heap.data, tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 6LLU, 4LLU), 0LLU)); |
11141 | - state.addr = *LOCAL_ACCESS(heap.data, 6LLU, 5LLU) ? 18446744073709551145LLU : 18446744073709551144LLU; | |
11030 | + state.addr = *LOCAL_ACCESS(heap.data, 6LLU, 5LLU) ? 18446744073709551148LLU : 18446744073709551147LLU; | |
11142 | 11031 | (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 6 |
11143 | 11032 | break; |
11144 | 11033 | } |
11145 | - case 18446744073709551145LLU: // 999999992n''''''''''''''' | |
11034 | + case 18446744073709551148LLU: // 999999992q''''''''''''''' | |
11146 | 11035 | { |
11147 | 11036 | |
11148 | 11037 | *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 0LLU)) = 1; |
11149 | - state.addr = 18446744073709551144LLU; // 999999992m''''''''''''''' | |
11038 | + state.addr = 18446744073709551147LLU; // 999999992p''''''''''''''' | |
11150 | 11039 | break; |
11151 | 11040 | } |
11152 | - case 18446744073709551144LLU: // 999999992m''''''''''''''' | |
11041 | + case 18446744073709551147LLU: // 999999992p''''''''''''''' | |
11153 | 11042 | { |
11154 | 11043 | // parameter-reference defidfn___ elem______ goes out of scope |
11155 | 11044 | // parameter-reference list<defidfn___> fndefs____ goes out of scope |
11156 | - state.addr = 18446744073709551147LLU; // 999999992p''''''''''''''' | |
11045 | + state.addr = 18446744073709551150LLU; // 999999992s''''''''''''''' | |
11157 | 11046 | break; |
11158 | 11047 | } |
11159 | - case 18446744073709551146LLU: // 999999992o''''''''''''''' | |
11048 | + case 18446744073709551149LLU: // 999999992r''''''''''''''' | |
11160 | 11049 | { |
11161 | 11050 | // parameter-reference u64 id________ goes out of scope |
11162 | 11051 | (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id________ at 3 |
@@ -11187,10 +11076,10 @@ | ||
11187 | 11076 | uint64_t arg = 0; |
11188 | 11077 | LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
11189 | 11078 | } |
11190 | - state.addr = 18446744073709551143LLU; // 999999992l''''''''''''''' | |
11079 | + state.addr = 18446744073709551146LLU; // 999999992o''''''''''''''' | |
11191 | 11080 | break; |
11192 | 11081 | } |
11193 | - case 18446744073709551143LLU: // 999999992l''''''''''''''' | |
11082 | + case 18446744073709551146LLU: // 999999992o''''''''''''''' | |
11194 | 11083 | { |
11195 | 11084 | if(!*LOCAL_ACCESS(heap.data, 6LLU, 4LLU)) |
11196 | 11085 | { |
@@ -11197,7 +11086,7 @@ | ||
11197 | 11086 | (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 6 |
11198 | 11087 | (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 5 |
11199 | 11088 | { |
11200 | - state.addr = 18446744073709551142LLU; // 999999992k''''''''''''''' | |
11089 | + state.addr = 18446744073709551145LLU; // 999999992n''''''''''''''' | |
11201 | 11090 | break; |
11202 | 11091 | } |
11203 | 11092 | } |
@@ -11208,25 +11097,25 @@ | ||
11208 | 11097 | LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
11209 | 11098 | } |
11210 | 11099 | *LOCAL_ACCESS(heap.data, 7LLU, 6LLU) = /*id________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 7LLU, 2LLU)) == /*elem______*/*access_heap(heap.data, tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 7LLU, 5LLU), 0LLU)); |
11211 | - state.addr = *LOCAL_ACCESS(heap.data, 7LLU, 6LLU) ? 18446744073709551141LLU : 18446744073709551140LLU; | |
11100 | + state.addr = *LOCAL_ACCESS(heap.data, 7LLU, 6LLU) ? 18446744073709551144LLU : 18446744073709551143LLU; | |
11212 | 11101 | (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 7 |
11213 | 11102 | break; |
11214 | 11103 | } |
11215 | - case 18446744073709551141LLU: // 999999992j''''''''''''''' | |
11104 | + case 18446744073709551144LLU: // 999999992m''''''''''''''' | |
11216 | 11105 | { |
11217 | 11106 | |
11218 | 11107 | *LOCAL_ACCESS(heap.data, 6LLU, 3LLU) = 1; |
11219 | - state.addr = 18446744073709551140LLU; // 999999992i''''''''''''''' | |
11108 | + state.addr = 18446744073709551143LLU; // 999999992l''''''''''''''' | |
11220 | 11109 | break; |
11221 | 11110 | } |
11222 | - case 18446744073709551140LLU: // 999999992i''''''''''''''' | |
11111 | + case 18446744073709551143LLU: // 999999992l''''''''''''''' | |
11223 | 11112 | { |
11224 | 11113 | // parameter-reference typedef___ elem______ goes out of scope |
11225 | 11114 | // parameter-reference list<typedef___> typedefs__ goes out of scope |
11226 | - state.addr = 18446744073709551143LLU; // 999999992l''''''''''''''' | |
11115 | + state.addr = 18446744073709551146LLU; // 999999992o''''''''''''''' | |
11227 | 11116 | break; |
11228 | 11117 | } |
11229 | - case 18446744073709551142LLU: // 999999992k''''''''''''''' | |
11118 | + case 18446744073709551145LLU: // 999999992n''''''''''''''' | |
11230 | 11119 | { |
11231 | 11120 | *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU)) = /*found_____*/*LOCAL_ACCESS(heap.data, 4LLU, 3LLU); |
11232 | 11121 | // variable u64 found_____ goes out of scope |
@@ -11249,7 +11138,7 @@ | ||
11249 | 11138 | { |
11250 | 11139 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 2LLU))].elem0 != 0/*typeu64___*/) |
11251 | 11140 | { |
11252 | - state.addr = 18446744073709551139LLU; // 999999992h''''''''''''''' | |
11141 | + state.addr = 18446744073709551142LLU; // 999999992k''''''''''''''' | |
11253 | 11142 | break; |
11254 | 11143 | } |
11255 | 11144 | { |
@@ -11272,11 +11161,11 @@ | ||
11272 | 11161 | } |
11273 | 11162 | break; |
11274 | 11163 | } |
11275 | - case 18446744073709551139LLU: // 999999992h''''''''''''''' | |
11164 | + case 18446744073709551142LLU: // 999999992k''''''''''''''' | |
11276 | 11165 | { |
11277 | 11166 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 2LLU))].elem0 != 1/*typename__*/) |
11278 | 11167 | { |
11279 | - state.addr = 18446744073709551138LLU; // 999999992g''''''''''''''' | |
11168 | + state.addr = 18446744073709551141LLU; // 999999992j''''''''''''''' | |
11280 | 11169 | break; |
11281 | 11170 | } |
11282 | 11171 | { |
@@ -11301,7 +11190,7 @@ | ||
11301 | 11190 | LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
11302 | 11191 | } |
11303 | 11192 | // ACCUMULATE ARGUMENTS - END |
11304 | - uint64_t return_to = 18446744073709551137LLU; | |
11193 | + uint64_t return_to = 18446744073709551140LLU; | |
11305 | 11194 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)); |
11306 | 11195 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
11307 | 11196 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -11310,7 +11199,7 @@ | ||
11310 | 11199 | state.addr = 104588758373059296LLU; // ExistsType |
11311 | 11200 | break; |
11312 | 11201 | } |
11313 | - case 18446744073709551137LLU: // 999999992f''''''''''''''' | |
11202 | + case 18446744073709551140LLU: // 999999992i''''''''''''''' | |
11314 | 11203 | { |
11315 | 11204 | // parameter-reference u64 maintype__ goes out of scope |
11316 | 11205 | (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference maintype__ at 5 |
@@ -11329,11 +11218,11 @@ | ||
11329 | 11218 | } |
11330 | 11219 | break; |
11331 | 11220 | } |
11332 | - case 18446744073709551138LLU: // 999999992g''''''''''''''' | |
11221 | + case 18446744073709551141LLU: // 999999992j''''''''''''''' | |
11333 | 11222 | { |
11334 | 11223 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 2LLU))].elem0 != 2/*typelist__*/) |
11335 | 11224 | { |
11336 | - state.addr = 18446744073709551136LLU; // 999999992e''''''''''''''' | |
11225 | + state.addr = 18446744073709551139LLU; // 999999992h''''''''''''''' | |
11337 | 11226 | break; |
11338 | 11227 | } |
11339 | 11228 | { |
@@ -11354,17 +11243,17 @@ | ||
11354 | 11243 | LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
11355 | 11244 | } |
11356 | 11245 | *LOCAL_ACCESS(heap.data, 7LLU, 6LLU) = /*sym_______*/*LOCAL_ACCESS(heap.data, 7LLU, 5LLU) == /*subtype___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 7LLU, 4LLU)); |
11357 | - state.addr = *LOCAL_ACCESS(heap.data, 7LLU, 6LLU) ? 18446744073709551135LLU : 18446744073709551134LLU; | |
11246 | + state.addr = *LOCAL_ACCESS(heap.data, 7LLU, 6LLU) ? 18446744073709551138LLU : 18446744073709551137LLU; | |
11358 | 11247 | (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 7 |
11359 | 11248 | break; |
11360 | 11249 | } |
11361 | - case 18446744073709551135LLU: // 999999992d''''''''''''''' | |
11250 | + case 18446744073709551138LLU: // 999999992g''''''''''''''' | |
11362 | 11251 | { |
11363 | 11252 | *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 6LLU, 0LLU)) = 1LLU; |
11364 | - state.addr = 18446744073709551133LLU; // 999999992b''''''''''''''' | |
11253 | + state.addr = 18446744073709551136LLU; // 999999992e''''''''''''''' | |
11365 | 11254 | break; |
11366 | 11255 | } |
11367 | - case 18446744073709551134LLU: // 999999992c''''''''''''''' | |
11256 | + case 18446744073709551137LLU: // 999999992f''''''''''''''' | |
11368 | 11257 | { |
11369 | 11258 | // ACCUMULATE ARGUMENTS - BEGIN |
11370 | 11259 | { |
@@ -11380,7 +11269,7 @@ | ||
11380 | 11269 | LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
11381 | 11270 | } |
11382 | 11271 | // ACCUMULATE ARGUMENTS - END |
11383 | - uint64_t return_to = 18446744073709551132LLU; | |
11272 | + uint64_t return_to = 18446744073709551135LLU; | |
11384 | 11273 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)); |
11385 | 11274 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
11386 | 11275 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -11389,12 +11278,12 @@ | ||
11389 | 11278 | state.addr = 104588758373059296LLU; // ExistsType |
11390 | 11279 | break; |
11391 | 11280 | } |
11392 | - case 18446744073709551132LLU: // 999999992a''''''''''''''' | |
11281 | + case 18446744073709551135LLU: // 999999992d''''''''''''''' | |
11393 | 11282 | { |
11394 | - state.addr = 18446744073709551133LLU; // 999999992b''''''''''''''' | |
11283 | + state.addr = 18446744073709551136LLU; // 999999992e''''''''''''''' | |
11395 | 11284 | break; |
11396 | 11285 | } |
11397 | - case 18446744073709551133LLU: // 999999992b''''''''''''''' | |
11286 | + case 18446744073709551136LLU: // 999999992e''''''''''''''' | |
11398 | 11287 | { |
11399 | 11288 | // variable u64 sym_______ goes out of scope |
11400 | 11289 | // emitted destructur for type u64 |
@@ -11416,7 +11305,7 @@ | ||
11416 | 11305 | } |
11417 | 11306 | break; |
11418 | 11307 | } |
11419 | - case 18446744073709551136LLU: // 999999992e''''''''''''''' | |
11308 | + case 18446744073709551139LLU: // 999999992h''''''''''''''' | |
11420 | 11309 | { |
11421 | 11310 | fprintf(stderr, "INTERNAL COMPILER ERROR: missing pattern-match-case in definition of KnowType__\n"); |
11422 | 11311 | exit(-1); |
@@ -11426,7 +11315,7 @@ | ||
11426 | 11315 | { |
11427 | 11316 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU))].elem0 != 0/*typeu64___*/) |
11428 | 11317 | { |
11429 | - state.addr = 18446744073709551131LLU; // 999999992$''''''''''''''' | |
11318 | + state.addr = 18446744073709551134LLU; // 999999992c''''''''''''''' | |
11430 | 11319 | break; |
11431 | 11320 | } |
11432 | 11321 | { |
@@ -11451,11 +11340,11 @@ | ||
11451 | 11340 | } |
11452 | 11341 | break; |
11453 | 11342 | } |
11454 | - case 18446744073709551131LLU: // 999999992$''''''''''''''' | |
11343 | + case 18446744073709551134LLU: // 999999992c''''''''''''''' | |
11455 | 11344 | { |
11456 | 11345 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU))].elem0 != 1/*typename__*/) |
11457 | 11346 | { |
11458 | - state.addr = 18446744073709551130LLU; // 999999992Z''''''''''''''' | |
11347 | + state.addr = 18446744073709551133LLU; // 999999992b''''''''''''''' | |
11459 | 11348 | break; |
11460 | 11349 | } |
11461 | 11350 | { |
@@ -11480,7 +11369,7 @@ | ||
11480 | 11369 | LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
11481 | 11370 | } |
11482 | 11371 | // ACCUMULATE ARGUMENTS - END |
11483 | - uint64_t return_to = 18446744073709551129LLU; | |
11372 | + uint64_t return_to = 18446744073709551132LLU; | |
11484 | 11373 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)); |
11485 | 11374 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
11486 | 11375 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -11489,7 +11378,7 @@ | ||
11489 | 11378 | state.addr = 104588758373059296LLU; // ExistsType |
11490 | 11379 | break; |
11491 | 11380 | } |
11492 | - case 18446744073709551129LLU: // 999999992Y''''''''''''''' | |
11381 | + case 18446744073709551132LLU: // 999999992a''''''''''''''' | |
11493 | 11382 | { |
11494 | 11383 | // parameter-reference u64 __________ goes out of scope |
11495 | 11384 | (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference __________ at 6 |
@@ -11510,11 +11399,11 @@ | ||
11510 | 11399 | } |
11511 | 11400 | break; |
11512 | 11401 | } |
11513 | - case 18446744073709551130LLU: // 999999992Z''''''''''''''' | |
11402 | + case 18446744073709551133LLU: // 999999992b''''''''''''''' | |
11514 | 11403 | { |
11515 | 11404 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU))].elem0 != 2/*typelist__*/) |
11516 | 11405 | { |
11517 | - state.addr = 18446744073709551128LLU; // 999999992X''''''''''''''' | |
11406 | + state.addr = 18446744073709551131LLU; // 999999992$''''''''''''''' | |
11518 | 11407 | break; |
11519 | 11408 | } |
11520 | 11409 | { |
@@ -11535,17 +11424,17 @@ | ||
11535 | 11424 | LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
11536 | 11425 | } |
11537 | 11426 | *LOCAL_ACCESS(heap.data, 8LLU, 7LLU) = /*sym_______*/*LOCAL_ACCESS(heap.data, 8LLU, 6LLU) == /*subtype___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 8LLU, 5LLU)); |
11538 | - state.addr = *LOCAL_ACCESS(heap.data, 8LLU, 7LLU) ? 18446744073709551127LLU : 18446744073709551126LLU; | |
11427 | + state.addr = *LOCAL_ACCESS(heap.data, 8LLU, 7LLU) ? 18446744073709551130LLU : 18446744073709551129LLU; | |
11539 | 11428 | (void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 8 |
11540 | 11429 | break; |
11541 | 11430 | } |
11542 | - case 18446744073709551127LLU: // 999999992W''''''''''''''' | |
11431 | + case 18446744073709551130LLU: // 999999992Z''''''''''''''' | |
11543 | 11432 | { |
11544 | 11433 | *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 7LLU, 0LLU)) = 1LLU; |
11545 | - state.addr = 18446744073709551125LLU; // 999999992U''''''''''''''' | |
11434 | + state.addr = 18446744073709551128LLU; // 999999992X''''''''''''''' | |
11546 | 11435 | break; |
11547 | 11436 | } |
11548 | - case 18446744073709551126LLU: // 999999992V''''''''''''''' | |
11437 | + case 18446744073709551129LLU: // 999999992Y''''''''''''''' | |
11549 | 11438 | { |
11550 | 11439 | { |
11551 | 11440 | uint64_t arg = 0; |
@@ -11565,7 +11454,7 @@ | ||
11565 | 11454 | LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
11566 | 11455 | } |
11567 | 11456 | // ACCUMULATE ARGUMENTS - END |
11568 | - uint64_t return_to = 18446744073709551121LLU; | |
11457 | + uint64_t return_to = 18446744073709551124LLU; | |
11569 | 11458 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)); |
11570 | 11459 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
11571 | 11460 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -11574,30 +11463,30 @@ | ||
11574 | 11463 | state.addr = 104588758373059296LLU; // ExistsType |
11575 | 11464 | break; |
11576 | 11465 | } |
11577 | - case 18446744073709551121LLU: // 999999992Q''''''''''''''' | |
11466 | + case 18446744073709551124LLU: // 999999992T''''''''''''''' | |
11578 | 11467 | { |
11579 | - state.addr = *LOCAL_ACCESS(heap.data, 8LLU, 7LLU) ? 18446744073709551124LLU : 18446744073709551123LLU; | |
11468 | + state.addr = *LOCAL_ACCESS(heap.data, 8LLU, 7LLU) ? 18446744073709551127LLU : 18446744073709551126LLU; | |
11580 | 11469 | (void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 8 |
11581 | 11470 | break; |
11582 | 11471 | } |
11583 | - case 18446744073709551124LLU: // 999999992T''''''''''''''' | |
11472 | + case 18446744073709551127LLU: // 999999992W''''''''''''''' | |
11584 | 11473 | { |
11585 | 11474 | *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 7LLU, 0LLU)) = 1LLU; |
11586 | - state.addr = 18446744073709551122LLU; // 999999992R''''''''''''''' | |
11475 | + state.addr = 18446744073709551125LLU; // 999999992U''''''''''''''' | |
11587 | 11476 | break; |
11588 | 11477 | } |
11589 | - case 18446744073709551123LLU: // 999999992S''''''''''''''' | |
11478 | + case 18446744073709551126LLU: // 999999992V''''''''''''''' | |
11590 | 11479 | { |
11591 | 11480 | *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 7LLU, 0LLU)) = /*self______*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 7LLU, 3LLU)) == /*subtype___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 7LLU, 5LLU)); |
11592 | - state.addr = 18446744073709551122LLU; // 999999992R''''''''''''''' | |
11481 | + state.addr = 18446744073709551125LLU; // 999999992U''''''''''''''' | |
11593 | 11482 | break; |
11594 | 11483 | } |
11595 | - case 18446744073709551122LLU: // 999999992R''''''''''''''' | |
11484 | + case 18446744073709551125LLU: // 999999992U''''''''''''''' | |
11596 | 11485 | { |
11597 | - state.addr = 18446744073709551125LLU; // 999999992U''''''''''''''' | |
11486 | + state.addr = 18446744073709551128LLU; // 999999992X''''''''''''''' | |
11598 | 11487 | break; |
11599 | 11488 | } |
11600 | - case 18446744073709551125LLU: // 999999992U''''''''''''''' | |
11489 | + case 18446744073709551128LLU: // 999999992X''''''''''''''' | |
11601 | 11490 | { |
11602 | 11491 | // variable u64 sym_______ goes out of scope |
11603 | 11492 | // emitted destructur for type u64 |
@@ -11621,7 +11510,7 @@ | ||
11621 | 11510 | } |
11622 | 11511 | break; |
11623 | 11512 | } |
11624 | - case 18446744073709551128LLU: // 999999992X''''''''''''''' | |
11513 | + case 18446744073709551131LLU: // 999999992$''''''''''''''' | |
11625 | 11514 | { |
11626 | 11515 | fprintf(stderr, "INTERNAL COMPILER ERROR: missing pattern-match-case in definition of KnowTypeRC\n"); |
11627 | 11516 | exit(-1); |
@@ -11631,7 +11520,7 @@ | ||
11631 | 11520 | { |
11632 | 11521 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 0/*produce___*/) |
11633 | 11522 | { |
11634 | - state.addr = 18446744073709551120LLU; // 999999992P''''''''''''''' | |
11523 | + state.addr = 18446744073709551123LLU; // 999999992S''''''''''''''' | |
11635 | 11524 | break; |
11636 | 11525 | } |
11637 | 11526 | { |
@@ -11651,11 +11540,11 @@ | ||
11651 | 11540 | } |
11652 | 11541 | break; |
11653 | 11542 | } |
11654 | - case 18446744073709551120LLU: // 999999992P''''''''''''''' | |
11543 | + case 18446744073709551123LLU: // 999999992S''''''''''''''' | |
11655 | 11544 | { |
11656 | 11545 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 1/*consume___*/) |
11657 | 11546 | { |
11658 | - state.addr = 18446744073709551119LLU; // 999999992O''''''''''''''' | |
11547 | + state.addr = 18446744073709551122LLU; // 999999992R''''''''''''''' | |
11659 | 11548 | break; |
11660 | 11549 | } |
11661 | 11550 | { |
@@ -11675,11 +11564,11 @@ | ||
11675 | 11564 | } |
11676 | 11565 | break; |
11677 | 11566 | } |
11678 | - case 18446744073709551119LLU: // 999999992O''''''''''''''' | |
11567 | + case 18446744073709551122LLU: // 999999992R''''''''''''''' | |
11679 | 11568 | { |
11680 | 11569 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))].elem0 != 2/*maintain__*/) |
11681 | 11570 | { |
11682 | - state.addr = 18446744073709551118LLU; // 999999992N''''''''''''''' | |
11571 | + state.addr = 18446744073709551121LLU; // 999999992Q''''''''''''''' | |
11683 | 11572 | break; |
11684 | 11573 | } |
11685 | 11574 | { |
@@ -11699,7 +11588,7 @@ | ||
11699 | 11588 | } |
11700 | 11589 | break; |
11701 | 11590 | } |
11702 | - case 18446744073709551118LLU: // 999999992N''''''''''''''' | |
11591 | + case 18446744073709551121LLU: // 999999992Q''''''''''''''' | |
11703 | 11592 | { |
11704 | 11593 | fprintf(stderr, "INTERNAL COMPILER ERROR: missing pattern-match-case in definition of reportcont\n"); |
11705 | 11594 | exit(-1); |
@@ -11729,7 +11618,7 @@ | ||
11729 | 11618 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
11730 | 11619 | } |
11731 | 11620 | // ACCUMULATE ARGUMENTS - END |
11732 | - uint64_t return_to = 18446744073709551116LLU; | |
11621 | + uint64_t return_to = 18446744073709551119LLU; | |
11733 | 11622 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
11734 | 11623 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
11735 | 11624 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -11738,7 +11627,7 @@ | ||
11738 | 11627 | state.addr = 819847183514380911LLU; // reportcont |
11739 | 11628 | break; |
11740 | 11629 | } |
11741 | - case 18446744073709551116LLU: // 999999992L''''''''''''''' | |
11630 | + case 18446744073709551119LLU: // 999999992O''''''''''''''' | |
11742 | 11631 | { |
11743 | 11632 | { |
11744 | 11633 | uint64_t arg = 0; |
@@ -11745,17 +11634,17 @@ | ||
11745 | 11634 | LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
11746 | 11635 | } |
11747 | 11636 | *LOCAL_ACCESS(heap.data, 6LLU, 5LLU) = /*mutable___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 6LLU, 2LLU)); |
11748 | - state.addr = *LOCAL_ACCESS(heap.data, 6LLU, 5LLU) ? 18446744073709551115LLU : 18446744073709551114LLU; | |
11637 | + state.addr = *LOCAL_ACCESS(heap.data, 6LLU, 5LLU) ? 18446744073709551118LLU : 18446744073709551117LLU; | |
11749 | 11638 | (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 6 |
11750 | 11639 | break; |
11751 | 11640 | } |
11752 | - case 18446744073709551115LLU: // 999999992K''''''''''''''' | |
11641 | + case 18446744073709551118LLU: // 999999992N''''''''''''''' | |
11753 | 11642 | { |
11754 | 11643 | fprintf(stderr, "%s", "mut "); |
11755 | - state.addr = 18446744073709551114LLU; // 999999992J''''''''''''''' | |
11644 | + state.addr = 18446744073709551117LLU; // 999999992M''''''''''''''' | |
11756 | 11645 | break; |
11757 | 11646 | } |
11758 | - case 18446744073709551114LLU: // 999999992J''''''''''''''' | |
11647 | + case 18446744073709551117LLU: // 999999992M''''''''''''''' | |
11759 | 11648 | { |
11760 | 11649 | // ACCUMULATE ARGUMENTS - BEGIN |
11761 | 11650 | { |
@@ -11763,7 +11652,7 @@ | ||
11763 | 11652 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
11764 | 11653 | } |
11765 | 11654 | // ACCUMULATE ARGUMENTS - END |
11766 | - uint64_t return_to = 18446744073709551113LLU; | |
11655 | + uint64_t return_to = 18446744073709551116LLU; | |
11767 | 11656 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
11768 | 11657 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
11769 | 11658 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -11772,7 +11661,7 @@ | ||
11772 | 11661 | state.addr = 819847183518878432LLU; // reporttype |
11773 | 11662 | break; |
11774 | 11663 | } |
11775 | - case 18446744073709551113LLU: // 999999992I''''''''''''''' | |
11664 | + case 18446744073709551116LLU: // 999999992L''''''''''''''' | |
11776 | 11665 | { |
11777 | 11666 | { |
11778 | 11667 | uint64_t arg = 0; |
@@ -11779,17 +11668,17 @@ | ||
11779 | 11668 | LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
11780 | 11669 | } |
11781 | 11670 | *LOCAL_ACCESS(heap.data, 6LLU, 5LLU) = /*reference_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 6LLU, 4LLU)); |
11782 | - state.addr = *LOCAL_ACCESS(heap.data, 6LLU, 5LLU) ? 18446744073709551112LLU : 18446744073709551111LLU; | |
11671 | + state.addr = *LOCAL_ACCESS(heap.data, 6LLU, 5LLU) ? 18446744073709551115LLU : 18446744073709551114LLU; | |
11783 | 11672 | (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 6 |
11784 | 11673 | break; |
11785 | 11674 | } |
11786 | - case 18446744073709551112LLU: // 999999992H''''''''''''''' | |
11675 | + case 18446744073709551115LLU: // 999999992K''''''''''''''' | |
11787 | 11676 | { |
11788 | 11677 | fprintf(stderr, "%s", " #"); |
11789 | - state.addr = 18446744073709551111LLU; // 999999992G''''''''''''''' | |
11678 | + state.addr = 18446744073709551114LLU; // 999999992J''''''''''''''' | |
11790 | 11679 | break; |
11791 | 11680 | } |
11792 | - case 18446744073709551111LLU: // 999999992G''''''''''''''' | |
11681 | + case 18446744073709551114LLU: // 999999992J''''''''''''''' | |
11793 | 11682 | { |
11794 | 11683 | // parameter-reference u64 reference_ goes out of scope |
11795 | 11684 | (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference reference_ at 5 |
@@ -11829,7 +11718,7 @@ | ||
11829 | 11718 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
11830 | 11719 | } |
11831 | 11720 | // ACCUMULATE ARGUMENTS - END |
11832 | - uint64_t return_to = 18446744073709551109LLU; | |
11721 | + uint64_t return_to = 18446744073709551112LLU; | |
11833 | 11722 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
11834 | 11723 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
11835 | 11724 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -11838,7 +11727,7 @@ | ||
11838 | 11727 | state.addr = 819847183518878432LLU; // reporttype |
11839 | 11728 | break; |
11840 | 11729 | } |
11841 | - case 18446744073709551109LLU: // 999999992E''''''''''''''' | |
11730 | + case 18446744073709551112LLU: // 999999992H''''''''''''''' | |
11842 | 11731 | { |
11843 | 11732 | { |
11844 | 11733 | uint64_t arg = 0; |
@@ -11845,22 +11734,22 @@ | ||
11845 | 11734 | LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
11846 | 11735 | } |
11847 | 11736 | *LOCAL_ACCESS(heap.data, 5LLU, 4LLU) = /*reference_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 3LLU)); |
11848 | - state.addr = *LOCAL_ACCESS(heap.data, 5LLU, 4LLU) ? 18446744073709551108LLU : 18446744073709551107LLU; | |
11737 | + state.addr = *LOCAL_ACCESS(heap.data, 5LLU, 4LLU) ? 18446744073709551111LLU : 18446744073709551110LLU; | |
11849 | 11738 | (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 5 |
11850 | 11739 | break; |
11851 | 11740 | } |
11852 | - case 18446744073709551108LLU: // 999999992D''''''''''''''' | |
11741 | + case 18446744073709551111LLU: // 999999992G''''''''''''''' | |
11853 | 11742 | { |
11854 | - state.addr = 18446744073709551106LLU; // 999999992B''''''''''''''' | |
11743 | + state.addr = 18446744073709551109LLU; // 999999992E''''''''''''''' | |
11855 | 11744 | break; |
11856 | 11745 | } |
11857 | - case 18446744073709551107LLU: // 999999992C''''''''''''''' | |
11746 | + case 18446744073709551110LLU: // 999999992F''''''''''''''' | |
11858 | 11747 | { |
11859 | 11748 | fprintf(stderr, "%s", "#"); |
11860 | - state.addr = 18446744073709551106LLU; // 999999992B''''''''''''''' | |
11749 | + state.addr = 18446744073709551109LLU; // 999999992E''''''''''''''' | |
11861 | 11750 | break; |
11862 | 11751 | } |
11863 | - case 18446744073709551106LLU: // 999999992B''''''''''''''' | |
11752 | + case 18446744073709551109LLU: // 999999992E''''''''''''''' | |
11864 | 11753 | { |
11865 | 11754 | fprintf(stderr, "%s", "("); |
11866 | 11755 | fprintf(stderr, "%llu", (unsigned long long)/*idx_______*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU))); |
@@ -11897,7 +11786,7 @@ | ||
11897 | 11786 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
11898 | 11787 | } |
11899 | 11788 | // ACCUMULATE ARGUMENTS - END |
11900 | - uint64_t return_to = 18446744073709551104LLU; | |
11789 | + uint64_t return_to = 18446744073709551107LLU; | |
11901 | 11790 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
11902 | 11791 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
11903 | 11792 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -11906,7 +11795,7 @@ | ||
11906 | 11795 | state.addr = 819847183518878432LLU; // reporttype |
11907 | 11796 | break; |
11908 | 11797 | } |
11909 | - case 18446744073709551104LLU: // 999999992_''''''''''''''' | |
11798 | + case 18446744073709551107LLU: // 999999992C''''''''''''''' | |
11910 | 11799 | { |
11911 | 11800 | fprintf(stderr, "%s", " "); |
11912 | 11801 | printid(stderr, /*id________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU))); |
@@ -11931,11 +11820,11 @@ | ||
11931 | 11820 | LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
11932 | 11821 | } |
11933 | 11822 | *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /*safe______*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU)); |
11934 | - state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551103LLU : 18446744073709551102LLU; | |
11823 | + state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551106LLU : 18446744073709551105LLU; | |
11935 | 11824 | (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4 |
11936 | 11825 | break; |
11937 | 11826 | } |
11938 | - case 18446744073709551103LLU: // 9999999919''''''''''''''' | |
11827 | + case 18446744073709551106LLU: // 999999992B''''''''''''''' | |
11939 | 11828 | { |
11940 | 11829 | { |
11941 | 11830 | uint64_t arg = 0; |
@@ -11942,11 +11831,11 @@ | ||
11942 | 11831 | LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
11943 | 11832 | } |
11944 | 11833 | *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /*finite____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 1LLU)); |
11945 | - state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551100LLU : 18446744073709551099LLU; | |
11834 | + state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551103LLU : 18446744073709551102LLU; | |
11946 | 11835 | (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4 |
11947 | 11836 | break; |
11948 | 11837 | } |
11949 | - case 18446744073709551100LLU: // 9999999916''''''''''''''' | |
11838 | + case 18446744073709551103LLU: // 9999999919''''''''''''''' | |
11950 | 11839 | { |
11951 | 11840 | { |
11952 | 11841 | uint64_t arg = 0; |
@@ -11953,28 +11842,28 @@ | ||
11953 | 11842 | LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
11954 | 11843 | } |
11955 | 11844 | *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /*complete__*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU)); |
11956 | - state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551097LLU : 18446744073709551096LLU; | |
11845 | + state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551100LLU : 18446744073709551099LLU; | |
11957 | 11846 | (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4 |
11958 | 11847 | break; |
11959 | 11848 | } |
11960 | - case 18446744073709551097LLU: // 9999999913''''''''''''''' | |
11849 | + case 18446744073709551100LLU: // 9999999916''''''''''''''' | |
11961 | 11850 | { |
11962 | 11851 | fprintf(stderr, "%s", "total"); |
11963 | - state.addr = 18446744073709551095LLU; // 9999999911''''''''''''''' | |
11852 | + state.addr = 18446744073709551098LLU; // 9999999914''''''''''''''' | |
11964 | 11853 | break; |
11965 | 11854 | } |
11966 | - case 18446744073709551096LLU: // 9999999912''''''''''''''' | |
11855 | + case 18446744073709551099LLU: // 9999999915''''''''''''''' | |
11967 | 11856 | { |
11968 | 11857 | fprintf(stderr, "%s", "finite"); |
11969 | - state.addr = 18446744073709551095LLU; // 9999999911''''''''''''''' | |
11858 | + state.addr = 18446744073709551098LLU; // 9999999914''''''''''''''' | |
11970 | 11859 | break; |
11971 | 11860 | } |
11972 | - case 18446744073709551095LLU: // 9999999911''''''''''''''' | |
11861 | + case 18446744073709551098LLU: // 9999999914''''''''''''''' | |
11973 | 11862 | { |
11974 | - state.addr = 18446744073709551098LLU; // 9999999914''''''''''''''' | |
11863 | + state.addr = 18446744073709551101LLU; // 9999999917''''''''''''''' | |
11975 | 11864 | break; |
11976 | 11865 | } |
11977 | - case 18446744073709551099LLU: // 9999999915''''''''''''''' | |
11866 | + case 18446744073709551102LLU: // 9999999918''''''''''''''' | |
11978 | 11867 | { |
11979 | 11868 | { |
11980 | 11869 | uint64_t arg = 0; |
@@ -11981,39 +11870,39 @@ | ||
11981 | 11870 | LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
11982 | 11871 | } |
11983 | 11872 | *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /*complete__*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 0LLU)); |
11984 | - state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551094LLU : 18446744073709551093LLU; | |
11873 | + state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551097LLU : 18446744073709551096LLU; | |
11985 | 11874 | (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4 |
11986 | 11875 | break; |
11987 | 11876 | } |
11988 | - case 18446744073709551094LLU: // 9999999910''''''''''''''' | |
11877 | + case 18446744073709551097LLU: // 9999999913''''''''''''''' | |
11989 | 11878 | { |
11990 | 11879 | fprintf(stderr, "%s", "complete"); |
11991 | - state.addr = 18446744073709551092LLU; // 999999991y''''''''''''''' | |
11880 | + state.addr = 18446744073709551095LLU; // 9999999911''''''''''''''' | |
11992 | 11881 | break; |
11993 | 11882 | } |
11994 | - case 18446744073709551093LLU: // 999999991z''''''''''''''' | |
11883 | + case 18446744073709551096LLU: // 9999999912''''''''''''''' | |
11995 | 11884 | { |
11996 | 11885 | fprintf(stderr, "%s", "partial"); |
11997 | - state.addr = 18446744073709551092LLU; // 999999991y''''''''''''''' | |
11886 | + state.addr = 18446744073709551095LLU; // 9999999911''''''''''''''' | |
11998 | 11887 | break; |
11999 | 11888 | } |
12000 | - case 18446744073709551092LLU: // 999999991y''''''''''''''' | |
11889 | + case 18446744073709551095LLU: // 9999999911''''''''''''''' | |
12001 | 11890 | { |
12002 | - state.addr = 18446744073709551098LLU; // 9999999914''''''''''''''' | |
11891 | + state.addr = 18446744073709551101LLU; // 9999999917''''''''''''''' | |
12003 | 11892 | break; |
12004 | 11893 | } |
12005 | - case 18446744073709551098LLU: // 9999999914''''''''''''''' | |
11894 | + case 18446744073709551101LLU: // 9999999917''''''''''''''' | |
12006 | 11895 | { |
12007 | - state.addr = 18446744073709551101LLU; // 9999999917''''''''''''''' | |
11896 | + state.addr = 18446744073709551104LLU; // 999999992_''''''''''''''' | |
12008 | 11897 | break; |
12009 | 11898 | } |
12010 | - case 18446744073709551102LLU: // 9999999918''''''''''''''' | |
11899 | + case 18446744073709551105LLU: // 999999992A''''''''''''''' | |
12011 | 11900 | { |
12012 | 11901 | fprintf(stderr, "%s", "unsafe"); |
12013 | - state.addr = 18446744073709551101LLU; // 9999999917''''''''''''''' | |
11902 | + state.addr = 18446744073709551104LLU; // 999999992_''''''''''''''' | |
12014 | 11903 | break; |
12015 | 11904 | } |
12016 | - case 18446744073709551101LLU: // 9999999917''''''''''''''' | |
11905 | + case 18446744073709551104LLU: // 999999992_''''''''''''''' | |
12017 | 11906 | { |
12018 | 11907 | // parameter-reference u64 safe______ goes out of scope |
12019 | 11908 | (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference safe______ at 3 |
@@ -12045,7 +11934,7 @@ | ||
12045 | 11934 | LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
12046 | 11935 | } |
12047 | 11936 | // ACCUMULATE ARGUMENTS - END |
12048 | - uint64_t return_to = 18446744073709551091LLU; | |
11937 | + uint64_t return_to = 18446744073709551094LLU; | |
12049 | 11938 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)); |
12050 | 11939 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
12051 | 11940 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -12054,7 +11943,7 @@ | ||
12054 | 11943 | state.addr = 819847183514344320LLU; // reportcfs_ |
12055 | 11944 | break; |
12056 | 11945 | } |
12057 | - case 18446744073709551091LLU: // 999999991x''''''''''''''' | |
11946 | + case 18446744073709551094LLU: // 9999999910''''''''''''''' | |
12058 | 11947 | { |
12059 | 11948 | fprintf(stderr, "%s", " "); |
12060 | 11949 | fprintf(stderr, "%s", "("); |
@@ -12066,10 +11955,10 @@ | ||
12066 | 11955 | uint64_t arg = 0; |
12067 | 11956 | LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
12068 | 11957 | } |
12069 | - state.addr = 18446744073709551090LLU; // 999999991w''''''''''''''' | |
11958 | + state.addr = 18446744073709551093LLU; // 999999991z''''''''''''''' | |
12070 | 11959 | break; |
12071 | 11960 | } |
12072 | - case 18446744073709551090LLU: // 999999991w''''''''''''''' | |
11961 | + case 18446744073709551093LLU: // 999999991z''''''''''''''' | |
12073 | 11962 | { |
12074 | 11963 | if(!*LOCAL_ACCESS(heap.data, 5LLU, 3LLU)) |
12075 | 11964 | { |
@@ -12076,7 +11965,7 @@ | ||
12076 | 11965 | (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 5 |
12077 | 11966 | (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4 |
12078 | 11967 | { |
12079 | - state.addr = 18446744073709551089LLU; // 999999991v''''''''''''''' | |
11968 | + state.addr = 18446744073709551092LLU; // 999999991y''''''''''''''' | |
12080 | 11969 | break; |
12081 | 11970 | } |
12082 | 11971 | } |
@@ -12088,7 +11977,7 @@ | ||
12088 | 11977 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
12089 | 11978 | } |
12090 | 11979 | // ACCUMULATE ARGUMENTS - END |
12091 | - uint64_t return_to = 18446744073709551088LLU; | |
11980 | + uint64_t return_to = 18446744073709551091LLU; | |
12092 | 11981 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
12093 | 11982 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
12094 | 11983 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -12097,14 +11986,14 @@ | ||
12097 | 11986 | state.addr = 819847183518272384LLU; // reportres_ |
12098 | 11987 | break; |
12099 | 11988 | } |
12100 | - case 18446744073709551088LLU: // 999999991u''''''''''''''' | |
11989 | + case 18446744073709551091LLU: // 999999991x''''''''''''''' | |
12101 | 11990 | { |
12102 | 11991 | // parameter-reference resdest___ par_______ goes out of scope |
12103 | 11992 | // parameter-reference function__ kind______ goes out of scope |
12104 | - state.addr = 18446744073709551090LLU; // 999999991w''''''''''''''' | |
11993 | + state.addr = 18446744073709551093LLU; // 999999991z''''''''''''''' | |
12105 | 11994 | break; |
12106 | 11995 | } |
12107 | - case 18446744073709551089LLU: // 999999991v''''''''''''''' | |
11996 | + case 18446744073709551092LLU: // 999999991y''''''''''''''' | |
12108 | 11997 | { |
12109 | 11998 | fprintf(stderr, "%s", ") "); |
12110 | 11999 | printid(stderr, /*id________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 0LLU))); |
@@ -12117,10 +12006,10 @@ | ||
12117 | 12006 | uint64_t arg = 0; |
12118 | 12007 | LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
12119 | 12008 | } |
12120 | - state.addr = 18446744073709551087LLU; // 999999991t''''''''''''''' | |
12009 | + state.addr = 18446744073709551090LLU; // 999999991w''''''''''''''' | |
12121 | 12010 | break; |
12122 | 12011 | } |
12123 | - case 18446744073709551087LLU: // 999999991t''''''''''''''' | |
12012 | + case 18446744073709551090LLU: // 999999991w''''''''''''''' | |
12124 | 12013 | { |
12125 | 12014 | if(!*LOCAL_ACCESS(heap.data, 5LLU, 3LLU)) |
12126 | 12015 | { |
@@ -12127,7 +12016,7 @@ | ||
12127 | 12016 | (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 5 |
12128 | 12017 | (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4 |
12129 | 12018 | { |
12130 | - state.addr = 18446744073709551086LLU; // 999999991s''''''''''''''' | |
12019 | + state.addr = 18446744073709551089LLU; // 999999991v''''''''''''''' | |
12131 | 12020 | break; |
12132 | 12021 | } |
12133 | 12022 | } |
@@ -12139,7 +12028,7 @@ | ||
12139 | 12028 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
12140 | 12029 | } |
12141 | 12030 | // ACCUMULATE ARGUMENTS - END |
12142 | - uint64_t return_to = 18446744073709551085LLU; | |
12031 | + uint64_t return_to = 18446744073709551088LLU; | |
12143 | 12032 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
12144 | 12033 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
12145 | 12034 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -12148,15 +12037,15 @@ | ||
12148 | 12037 | state.addr = 819847183517731648LLU; // reportpar_ |
12149 | 12038 | break; |
12150 | 12039 | } |
12151 | - case 18446744073709551085LLU: // 999999991r''''''''''''''' | |
12040 | + case 18446744073709551088LLU: // 999999991u''''''''''''''' | |
12152 | 12041 | { |
12153 | 12042 | fprintf(stderr, "%s", " "); |
12154 | 12043 | // parameter-reference pardef____ par_______ goes out of scope |
12155 | 12044 | // parameter-reference function__ kind______ goes out of scope |
12156 | - state.addr = 18446744073709551087LLU; // 999999991t''''''''''''''' | |
12045 | + state.addr = 18446744073709551090LLU; // 999999991w''''''''''''''' | |
12157 | 12046 | break; |
12158 | 12047 | } |
12159 | - case 18446744073709551086LLU: // 999999991s''''''''''''''' | |
12048 | + case 18446744073709551089LLU: // 999999991v''''''''''''''' | |
12160 | 12049 | { |
12161 | 12050 | fprintf(stderr, "%s", ") "); |
12162 | 12051 | // ACCUMULATE ARGUMENTS - BEGIN |
@@ -12165,7 +12054,7 @@ | ||
12165 | 12054 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
12166 | 12055 | } |
12167 | 12056 | // ACCUMULATE ARGUMENTS - END |
12168 | - uint64_t return_to = 18446744073709551084LLU; | |
12057 | + uint64_t return_to = 18446744073709551087LLU; | |
12169 | 12058 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
12170 | 12059 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
12171 | 12060 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -12174,7 +12063,7 @@ | ||
12174 | 12063 | state.addr = 819847183517274112LLU; // reportnr__ |
12175 | 12064 | break; |
12176 | 12065 | } |
12177 | - case 18446744073709551084LLU: // 999999991q''''''''''''''' | |
12066 | + case 18446744073709551087LLU: // 999999991t''''''''''''''' | |
12178 | 12067 | { |
12179 | 12068 | fprintf(stderr, "%s", " "); |
12180 | 12069 | // ACCUMULATE ARGUMENTS - BEGIN |
@@ -12183,7 +12072,7 @@ | ||
12183 | 12072 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
12184 | 12073 | } |
12185 | 12074 | // ACCUMULATE ARGUMENTS - END |
12186 | - uint64_t return_to = 18446744073709551083LLU; | |
12075 | + uint64_t return_to = 18446744073709551086LLU; | |
12187 | 12076 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
12188 | 12077 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
12189 | 12078 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -12192,7 +12081,7 @@ | ||
12192 | 12081 | state.addr = 819847183517274112LLU; // reportnr__ |
12193 | 12082 | break; |
12194 | 12083 | } |
12195 | - case 18446744073709551083LLU: // 999999991p''''''''''''''' | |
12084 | + case 18446744073709551086LLU: // 999999991s''''''''''''''' | |
12196 | 12085 | { |
12197 | 12086 | fprintf(stderr, "%s", " "); |
12198 | 12087 | { |
@@ -12200,23 +12089,23 @@ | ||
12200 | 12089 | LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
12201 | 12090 | } |
12202 | 12091 | *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) = /*defined___*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 2LLU)); |
12203 | - state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551082LLU : 18446744073709551081LLU; | |
12092 | + state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709551085LLU : 18446744073709551084LLU; | |
12204 | 12093 | (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4 |
12205 | 12094 | break; |
12206 | 12095 | } |
12207 | - case 18446744073709551082LLU: // 999999991o''''''''''''''' | |
12096 | + case 18446744073709551085LLU: // 999999991r''''''''''''''' | |
12208 | 12097 | { |
12209 | 12098 | fprintf(stderr, "%s", "DEFINITION"); |
12210 | - state.addr = 18446744073709551080LLU; // 999999991m''''''''''''''' | |
12099 | + state.addr = 18446744073709551083LLU; // 999999991p''''''''''''''' | |
12211 | 12100 | break; |
12212 | 12101 | } |
12213 | - case 18446744073709551081LLU: // 999999991n''''''''''''''' | |
12102 | + case 18446744073709551084LLU: // 999999991q''''''''''''''' | |
12214 | 12103 | { |
12215 | 12104 | fprintf(stderr, "%s", "DECLARATION"); |
12216 | - state.addr = 18446744073709551080LLU; // 999999991m''''''''''''''' | |
12105 | + state.addr = 18446744073709551083LLU; // 999999991p''''''''''''''' | |
12217 | 12106 | break; |
12218 | 12107 | } |
12219 | - case 18446744073709551080LLU: // 999999991m''''''''''''''' | |
12108 | + case 18446744073709551083LLU: // 999999991p''''''''''''''' | |
12220 | 12109 | { |
12221 | 12110 | fprintf(stderr, "%s", " <- possibly REVERSED parameters!"); |
12222 | 12111 | fprintf(stderr, "%s", "\n"); |
@@ -12244,10 +12133,10 @@ | ||
12244 | 12133 | uint64_t arg = 0; |
12245 | 12134 | LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
12246 | 12135 | } |
12247 | - state.addr = 18446744073709551079LLU; // 999999991l''''''''''''''' | |
12136 | + state.addr = 18446744073709551082LLU; // 999999991o''''''''''''''' | |
12248 | 12137 | break; |
12249 | 12138 | } |
12250 | - case 18446744073709551079LLU: // 999999991l''''''''''''''' | |
12139 | + case 18446744073709551082LLU: // 999999991o''''''''''''''' | |
12251 | 12140 | { |
12252 | 12141 | if(!*LOCAL_ACCESS(heap.data, 4LLU, 2LLU)) |
12253 | 12142 | { |
@@ -12254,7 +12143,7 @@ | ||
12254 | 12143 | (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4 |
12255 | 12144 | (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 3 |
12256 | 12145 | { |
12257 | - state.addr = 18446744073709551078LLU; // 999999991k''''''''''''''' | |
12146 | + state.addr = 18446744073709551081LLU; // 999999991n''''''''''''''' | |
12258 | 12147 | break; |
12259 | 12148 | } |
12260 | 12149 | } |
@@ -12274,7 +12163,7 @@ | ||
12274 | 12163 | LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
12275 | 12164 | } |
12276 | 12165 | // ACCUMULATE ARGUMENTS - END |
12277 | - uint64_t return_to = 18446744073709551077LLU; | |
12166 | + uint64_t return_to = 18446744073709551080LLU; | |
12278 | 12167 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)); |
12279 | 12168 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
12280 | 12169 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -12283,14 +12172,14 @@ | ||
12283 | 12172 | state.addr = 819847183514601536LLU; // reportdef_ |
12284 | 12173 | break; |
12285 | 12174 | } |
12286 | - case 18446744073709551077LLU: // 999999991j''''''''''''''' | |
12175 | + case 18446744073709551080LLU: // 999999991m''''''''''''''' | |
12287 | 12176 | { |
12288 | 12177 | // parameter-reference defidfn___ def_______ goes out of scope |
12289 | 12178 | // parameter-reference list<defidfn___> fndefs____ goes out of scope |
12290 | - state.addr = 18446744073709551079LLU; // 999999991l''''''''''''''' | |
12179 | + state.addr = 18446744073709551082LLU; // 999999991o''''''''''''''' | |
12291 | 12180 | break; |
12292 | 12181 | } |
12293 | - case 18446744073709551078LLU: // 999999991k''''''''''''''' | |
12182 | + case 18446744073709551081LLU: // 999999991n''''''''''''''' | |
12294 | 12183 | { |
12295 | 12184 | // parameter-reference list<defidfn___> fndefs____ goes out of scope |
12296 | 12185 | (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference fndefs____ at 2 |
@@ -12324,10 +12213,10 @@ | ||
12324 | 12213 | uint64_t arg = 0; |
12325 | 12214 | LOCAL_PUSH_MOVE(&heap, 4, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
12326 | 12215 | } |
12327 | - state.addr = 18446744073709551075LLU; // 999999991h''''''''''''''' | |
12216 | + state.addr = 18446744073709551078LLU; // 999999991k''''''''''''''' | |
12328 | 12217 | break; |
12329 | 12218 | } |
12330 | - case 18446744073709551075LLU: // 999999991h''''''''''''''' | |
12219 | + case 18446744073709551078LLU: // 999999991k''''''''''''''' | |
12331 | 12220 | { |
12332 | 12221 | if(!*LOCAL_ACCESS(heap.data, 5LLU, 3LLU)) |
12333 | 12222 | { |
@@ -12334,7 +12223,7 @@ | ||
12334 | 12223 | (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 5 |
12335 | 12224 | (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4 |
12336 | 12225 | { |
12337 | - state.addr = 18446744073709551074LLU; // 999999991g''''''''''''''' | |
12226 | + state.addr = 18446744073709551077LLU; // 999999991j''''''''''''''' | |
12338 | 12227 | break; |
12339 | 12228 | } |
12340 | 12229 | } |
@@ -12349,7 +12238,7 @@ | ||
12349 | 12238 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
12350 | 12239 | } |
12351 | 12240 | // ACCUMULATE ARGUMENTS - END |
12352 | - uint64_t return_to = 18446744073709551073LLU; | |
12241 | + uint64_t return_to = 18446744073709551076LLU; | |
12353 | 12242 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
12354 | 12243 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
12355 | 12244 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -12358,14 +12247,14 @@ | ||
12358 | 12247 | state.addr = 819847183518878432LLU; // reporttype |
12359 | 12248 | break; |
12360 | 12249 | } |
12361 | - case 18446744073709551073LLU: // 999999991f''''''''''''''' | |
12250 | + case 18446744073709551076LLU: // 999999991i''''''''''''''' | |
12362 | 12251 | { |
12363 | 12252 | // parameter-reference elemdef___ elem______ goes out of scope |
12364 | 12253 | // parameter-reference list<elemdef___> elems_____ goes out of scope |
12365 | - state.addr = 18446744073709551075LLU; // 999999991h''''''''''''''' | |
12254 | + state.addr = 18446744073709551078LLU; // 999999991k''''''''''''''' | |
12366 | 12255 | break; |
12367 | 12256 | } |
12368 | - case 18446744073709551074LLU: // 999999991g''''''''''''''' | |
12257 | + case 18446744073709551077LLU: // 999999991j''''''''''''''' | |
12369 | 12258 | { |
12370 | 12259 | fprintf(stderr, "%s", ")"); |
12371 | 12260 | // parameter-reference list<elemdef___> elems_____ goes out of scope |
@@ -12386,7 +12275,7 @@ | ||
12386 | 12275 | { |
12387 | 12276 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 != 0/*tkstruct__*/) |
12388 | 12277 | { |
12389 | - state.addr = 18446744073709551072LLU; // 999999991e''''''''''''''' | |
12278 | + state.addr = 18446744073709551075LLU; // 999999991h''''''''''''''' | |
12390 | 12279 | break; |
12391 | 12280 | } |
12392 | 12281 | { |
@@ -12408,10 +12297,10 @@ | ||
12408 | 12297 | uint64_t arg = 0; |
12409 | 12298 | LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
12410 | 12299 | } |
12411 | - state.addr = 18446744073709551071LLU; // 999999991d''''''''''''''' | |
12300 | + state.addr = 18446744073709551074LLU; // 999999991g''''''''''''''' | |
12412 | 12301 | break; |
12413 | 12302 | } |
12414 | - case 18446744073709551071LLU: // 999999991d''''''''''''''' | |
12303 | + case 18446744073709551074LLU: // 999999991g''''''''''''''' | |
12415 | 12304 | { |
12416 | 12305 | if(!*LOCAL_ACCESS(heap.data, 6LLU, 4LLU)) |
12417 | 12306 | { |
@@ -12418,7 +12307,7 @@ | ||
12418 | 12307 | (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 6 |
12419 | 12308 | (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 5 |
12420 | 12309 | { |
12421 | - state.addr = 18446744073709551070LLU; // 999999991c''''''''''''''' | |
12310 | + state.addr = 18446744073709551073LLU; // 999999991f''''''''''''''' | |
12422 | 12311 | break; |
12423 | 12312 | } |
12424 | 12313 | } |
@@ -12430,7 +12319,7 @@ | ||
12430 | 12319 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
12431 | 12320 | } |
12432 | 12321 | // ACCUMULATE ARGUMENTS - END |
12433 | - uint64_t return_to = 18446744073709551069LLU; | |
12322 | + uint64_t return_to = 18446744073709551072LLU; | |
12434 | 12323 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
12435 | 12324 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
12436 | 12325 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -12439,15 +12328,15 @@ | ||
12439 | 12328 | state.addr = 819847183514892328LLU; // reportelem |
12440 | 12329 | break; |
12441 | 12330 | } |
12442 | - case 18446744073709551069LLU: // 999999991b''''''''''''''' | |
12331 | + case 18446744073709551072LLU: // 999999991e''''''''''''''' | |
12443 | 12332 | { |
12444 | 12333 | fprintf(stderr, "%s", " "); |
12445 | 12334 | // parameter-reference elemdef___ par_______ goes out of scope |
12446 | 12335 | // parameter-reference list<elemdef___> defpars___ goes out of scope |
12447 | - state.addr = 18446744073709551071LLU; // 999999991d''''''''''''''' | |
12336 | + state.addr = 18446744073709551074LLU; // 999999991g''''''''''''''' | |
12448 | 12337 | break; |
12449 | 12338 | } |
12450 | - case 18446744073709551070LLU: // 999999991c''''''''''''''' | |
12339 | + case 18446744073709551073LLU: // 999999991f''''''''''''''' | |
12451 | 12340 | { |
12452 | 12341 | fprintf(stderr, "%s", ");"); |
12453 | 12342 | // parameter-reference list<elemdef___> defpars___ goes out of scope |
@@ -12466,11 +12355,11 @@ | ||
12466 | 12355 | } |
12467 | 12356 | break; |
12468 | 12357 | } |
12469 | - case 18446744073709551072LLU: // 999999991e''''''''''''''' | |
12358 | + case 18446744073709551075LLU: // 999999991h''''''''''''''' | |
12470 | 12359 | { |
12471 | 12360 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 != 1/*tkunion___*/) |
12472 | 12361 | { |
12473 | - state.addr = 18446744073709551068LLU; // 999999991a''''''''''''''' | |
12362 | + state.addr = 18446744073709551071LLU; // 999999991d''''''''''''''' | |
12474 | 12363 | break; |
12475 | 12364 | } |
12476 | 12365 | { |
@@ -12492,10 +12381,10 @@ | ||
12492 | 12381 | uint64_t arg = 0; |
12493 | 12382 | LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
12494 | 12383 | } |
12495 | - state.addr = 18446744073709551067LLU; // 999999991$''''''''''''''' | |
12384 | + state.addr = 18446744073709551070LLU; // 999999991c''''''''''''''' | |
12496 | 12385 | break; |
12497 | 12386 | } |
12498 | - case 18446744073709551067LLU: // 999999991$''''''''''''''' | |
12387 | + case 18446744073709551070LLU: // 999999991c''''''''''''''' | |
12499 | 12388 | { |
12500 | 12389 | if(!*LOCAL_ACCESS(heap.data, 6LLU, 4LLU)) |
12501 | 12390 | { |
@@ -12502,7 +12391,7 @@ | ||
12502 | 12391 | (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 6 |
12503 | 12392 | (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 5 |
12504 | 12393 | { |
12505 | - state.addr = 18446744073709551066LLU; // 999999991Z''''''''''''''' | |
12394 | + state.addr = 18446744073709551069LLU; // 999999991b''''''''''''''' | |
12506 | 12395 | break; |
12507 | 12396 | } |
12508 | 12397 | } |
@@ -12515,7 +12404,7 @@ | ||
12515 | 12404 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
12516 | 12405 | } |
12517 | 12406 | // ACCUMULATE ARGUMENTS - END |
12518 | - uint64_t return_to = 18446744073709551065LLU; | |
12407 | + uint64_t return_to = 18446744073709551068LLU; | |
12519 | 12408 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
12520 | 12409 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
12521 | 12410 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -12524,14 +12413,14 @@ | ||
12524 | 12413 | state.addr = 325737967259227264LLU; // REPORTVAR_ |
12525 | 12414 | break; |
12526 | 12415 | } |
12527 | - case 18446744073709551065LLU: // 999999991Y''''''''''''''' | |
12416 | + case 18446744073709551068LLU: // 999999991a''''''''''''''' | |
12528 | 12417 | { |
12529 | 12418 | // parameter-reference variant___ constr____ goes out of scope |
12530 | 12419 | // parameter-reference list<variant___> constrs___ goes out of scope |
12531 | - state.addr = 18446744073709551067LLU; // 999999991$''''''''''''''' | |
12420 | + state.addr = 18446744073709551070LLU; // 999999991c''''''''''''''' | |
12532 | 12421 | break; |
12533 | 12422 | } |
12534 | - case 18446744073709551066LLU: // 999999991Z''''''''''''''' | |
12423 | + case 18446744073709551069LLU: // 999999991b''''''''''''''' | |
12535 | 12424 | { |
12536 | 12425 | fprintf(stderr, "%s", ";"); |
12537 | 12426 | // parameter-reference list<variant___> constrs___ goes out of scope |
@@ -12550,7 +12439,7 @@ | ||
12550 | 12439 | } |
12551 | 12440 | break; |
12552 | 12441 | } |
12553 | - case 18446744073709551068LLU: // 999999991a''''''''''''''' | |
12442 | + case 18446744073709551071LLU: // 999999991d''''''''''''''' | |
12554 | 12443 | { |
12555 | 12444 | fprintf(stderr, "INTERNAL COMPILER ERROR: missing pattern-match-case in definition of reporttyp_\n"); |
12556 | 12445 | exit(-1); |
@@ -12566,10 +12455,10 @@ | ||
12566 | 12455 | uint64_t arg = 0; |
12567 | 12456 | LOCAL_PUSH_MOVE(&heap, 3, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
12568 | 12457 | } |
12569 | - state.addr = 18446744073709551064LLU; // 999999991X''''''''''''''' | |
12458 | + state.addr = 18446744073709551067LLU; // 999999991$''''''''''''''' | |
12570 | 12459 | break; |
12571 | 12460 | } |
12572 | - case 18446744073709551064LLU: // 999999991X''''''''''''''' | |
12461 | + case 18446744073709551067LLU: // 999999991$''''''''''''''' | |
12573 | 12462 | { |
12574 | 12463 | if(!*LOCAL_ACCESS(heap.data, 4LLU, 2LLU)) |
12575 | 12464 | { |
@@ -12576,7 +12465,7 @@ | ||
12576 | 12465 | (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4 |
12577 | 12466 | (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 3 |
12578 | 12467 | { |
12579 | - state.addr = 18446744073709551063LLU; // 999999991W''''''''''''''' | |
12468 | + state.addr = 18446744073709551066LLU; // 999999991Z''''''''''''''' | |
12580 | 12469 | break; |
12581 | 12470 | } |
12582 | 12471 | } |
@@ -12593,7 +12482,7 @@ | ||
12593 | 12482 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
12594 | 12483 | } |
12595 | 12484 | // ACCUMULATE ARGUMENTS - END |
12596 | - uint64_t return_to = 18446744073709551062LLU; | |
12485 | + uint64_t return_to = 18446744073709551065LLU; | |
12597 | 12486 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
12598 | 12487 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
12599 | 12488 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -12602,7 +12491,7 @@ | ||
12602 | 12491 | state.addr = 819847183518878400LLU; // reporttyp_ |
12603 | 12492 | break; |
12604 | 12493 | } |
12605 | - case 18446744073709551062LLU: // 999999991V''''''''''''''' | |
12494 | + case 18446744073709551065LLU: // 999999991Y''''''''''''''' | |
12606 | 12495 | { |
12607 | 12496 | fprintf(stderr, "%s", " 0 "); |
12608 | 12497 | // ACCUMULATE ARGUMENTS - BEGIN |
@@ -12611,7 +12500,7 @@ | ||
12611 | 12500 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
12612 | 12501 | } |
12613 | 12502 | // ACCUMULATE ARGUMENTS - END |
12614 | - uint64_t return_to = 18446744073709551061LLU; | |
12503 | + uint64_t return_to = 18446744073709551064LLU; | |
12615 | 12504 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
12616 | 12505 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
12617 | 12506 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -12620,7 +12509,7 @@ | ||
12620 | 12509 | state.addr = 819847183517274112LLU; // reportnr__ |
12621 | 12510 | break; |
12622 | 12511 | } |
12623 | - case 18446744073709551061LLU: // 999999991U''''''''''''''' | |
12512 | + case 18446744073709551064LLU: // 999999991X''''''''''''''' | |
12624 | 12513 | { |
12625 | 12514 | { |
12626 | 12515 | uint64_t arg = tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 4LLU, 3LLU), 0LLU); |
@@ -12643,17 +12532,17 @@ | ||
12643 | 12532 | LOCAL_PUSH_MOVE(&heap, 8, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
12644 | 12533 | } |
12645 | 12534 | *LOCAL_ACCESS(heap.data, 9LLU, 8LLU) = /*destraddr_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 9LLU, 7LLU)); |
12646 | - state.addr = *LOCAL_ACCESS(heap.data, 9LLU, 8LLU) ? 18446744073709551060LLU : 18446744073709551059LLU; | |
12535 | + state.addr = *LOCAL_ACCESS(heap.data, 9LLU, 8LLU) ? 18446744073709551063LLU : 18446744073709551062LLU; | |
12647 | 12536 | (void)LOCAL_POP_MOVE(&heap, 9LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 9 |
12648 | 12537 | break; |
12649 | 12538 | } |
12650 | - case 18446744073709551060LLU: // 999999991T''''''''''''''' | |
12539 | + case 18446744073709551063LLU: // 999999991W''''''''''''''' | |
12651 | 12540 | { |
12652 | 12541 | fprintf(stderr, "%s", " capability release"); |
12653 | - state.addr = 18446744073709551059LLU; // 999999991S''''''''''''''' | |
12542 | + state.addr = 18446744073709551062LLU; // 999999991V''''''''''''''' | |
12654 | 12543 | break; |
12655 | 12544 | } |
12656 | - case 18446744073709551059LLU: // 999999991S''''''''''''''' | |
12545 | + case 18446744073709551062LLU: // 999999991V''''''''''''''' | |
12657 | 12546 | { |
12658 | 12547 | // parameter-reference u64 destraddr_ goes out of scope |
12659 | 12548 | (void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference destraddr_ at 8 |
@@ -12665,10 +12554,10 @@ | ||
12665 | 12554 | (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference id________ at 5 |
12666 | 12555 | // parameter-reference typedef___ def_______ goes out of scope |
12667 | 12556 | // parameter-reference list<typedef___> typedefs__ goes out of scope |
12668 | - state.addr = 18446744073709551064LLU; // 999999991X''''''''''''''' | |
12557 | + state.addr = 18446744073709551067LLU; // 999999991$''''''''''''''' | |
12669 | 12558 | break; |
12670 | 12559 | } |
12671 | - case 18446744073709551063LLU: // 999999991W''''''''''''''' | |
12560 | + case 18446744073709551066LLU: // 999999991Z''''''''''''''' | |
12672 | 12561 | { |
12673 | 12562 | // parameter-reference list<typedef___> typedefs__ goes out of scope |
12674 | 12563 | (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference typedefs__ at 2 |
@@ -12689,11 +12578,11 @@ | ||
12689 | 12578 | LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
12690 | 12579 | } |
12691 | 12580 | *LOCAL_ACCESS(heap.data, 7LLU, 6LLU) = /*complete__*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 7LLU, 3LLU)); |
12692 | - state.addr = *LOCAL_ACCESS(heap.data, 7LLU, 6LLU) ? 18446744073709551058LLU : 18446744073709551057LLU; | |
12581 | + state.addr = *LOCAL_ACCESS(heap.data, 7LLU, 6LLU) ? 18446744073709551061LLU : 18446744073709551060LLU; | |
12693 | 12582 | (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 7 |
12694 | 12583 | break; |
12695 | 12584 | } |
12696 | - case 18446744073709551058LLU: // 999999991R''''''''''''''' | |
12585 | + case 18446744073709551061LLU: // 999999991U''''''''''''''' | |
12697 | 12586 | { |
12698 | 12587 | { |
12699 | 12588 | uint64_t arg = 0; |
@@ -12709,7 +12598,7 @@ | ||
12709 | 12598 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
12710 | 12599 | } |
12711 | 12600 | // ACCUMULATE ARGUMENTS - END |
12712 | - uint64_t return_to = 18446744073709551053LLU; | |
12601 | + uint64_t return_to = 18446744073709551056LLU; | |
12713 | 12602 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
12714 | 12603 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
12715 | 12604 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -12718,18 +12607,18 @@ | ||
12718 | 12607 | state.addr = 606150496152849376LLU; // fncomplete |
12719 | 12608 | break; |
12720 | 12609 | } |
12721 | - case 18446744073709551053LLU: // 999999991M''''''''''''''' | |
12610 | + case 18446744073709551056LLU: // 999999991P''''''''''''''' | |
12722 | 12611 | { |
12723 | - state.addr = *LOCAL_ACCESS(heap.data, 7LLU, 6LLU) ? 18446744073709551056LLU : 18446744073709551055LLU; | |
12612 | + state.addr = *LOCAL_ACCESS(heap.data, 7LLU, 6LLU) ? 18446744073709551059LLU : 18446744073709551058LLU; | |
12724 | 12613 | (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 7 |
12725 | 12614 | break; |
12726 | 12615 | } |
12727 | - case 18446744073709551056LLU: // 999999991P''''''''''''''' | |
12616 | + case 18446744073709551059LLU: // 999999991S''''''''''''''' | |
12728 | 12617 | { |
12729 | - state.addr = 18446744073709551054LLU; // 999999991N''''''''''''''' | |
12618 | + state.addr = 18446744073709551057LLU; // 999999991Q''''''''''''''' | |
12730 | 12619 | break; |
12731 | 12620 | } |
12732 | - case 18446744073709551055LLU: // 999999991O''''''''''''''' | |
12621 | + case 18446744073709551058LLU: // 999999991R''''''''''''''' | |
12733 | 12622 | { |
12734 | 12623 | fprintf(stderr, "%s", "function "); |
12735 | 12624 | printid(stderr, /*def_id____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 6LLU, 0LLU))); |
@@ -12741,15 +12630,15 @@ | ||
12741 | 12630 | fprintf(stderr, "%s\n", ""); |
12742 | 12631 | exit(-1); |
12743 | 12632 | } |
12744 | - state.addr = 18446744073709551054LLU; // 999999991N''''''''''''''' | |
12633 | + state.addr = 18446744073709551057LLU; // 999999991Q''''''''''''''' | |
12745 | 12634 | break; |
12746 | 12635 | } |
12747 | - case 18446744073709551054LLU: // 999999991N''''''''''''''' | |
12636 | + case 18446744073709551057LLU: // 999999991Q''''''''''''''' | |
12748 | 12637 | { |
12749 | - state.addr = 18446744073709551057LLU; // 999999991Q''''''''''''''' | |
12638 | + state.addr = 18446744073709551060LLU; // 999999991T''''''''''''''' | |
12750 | 12639 | break; |
12751 | 12640 | } |
12752 | - case 18446744073709551057LLU: // 999999991Q''''''''''''''' | |
12641 | + case 18446744073709551060LLU: // 999999991T''''''''''''''' | |
12753 | 12642 | { |
12754 | 12643 | { |
12755 | 12644 | uint64_t arg = 0; |
@@ -12756,11 +12645,11 @@ | ||
12756 | 12645 | LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
12757 | 12646 | } |
12758 | 12647 | *LOCAL_ACCESS(heap.data, 7LLU, 6LLU) = /*finite____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 7LLU, 4LLU)); |
12759 | - state.addr = *LOCAL_ACCESS(heap.data, 7LLU, 6LLU) ? 18446744073709551052LLU : 18446744073709551051LLU; | |
12648 | + state.addr = *LOCAL_ACCESS(heap.data, 7LLU, 6LLU) ? 18446744073709551055LLU : 18446744073709551054LLU; | |
12760 | 12649 | (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 7 |
12761 | 12650 | break; |
12762 | 12651 | } |
12763 | - case 18446744073709551052LLU: // 999999991L''''''''''''''' | |
12652 | + case 18446744073709551055LLU: // 999999991O''''''''''''''' | |
12764 | 12653 | { |
12765 | 12654 | { |
12766 | 12655 | uint64_t arg = 0; |
@@ -12776,7 +12665,7 @@ | ||
12776 | 12665 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
12777 | 12666 | } |
12778 | 12667 | // ACCUMULATE ARGUMENTS - END |
12779 | - uint64_t return_to = 18446744073709551047LLU; | |
12668 | + uint64_t return_to = 18446744073709551050LLU; | |
12780 | 12669 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
12781 | 12670 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
12782 | 12671 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -12785,18 +12674,18 @@ | ||
12785 | 12674 | state.addr = 606163278933917696LLU; // fnfinite__ |
12786 | 12675 | break; |
12787 | 12676 | } |
12788 | - case 18446744073709551047LLU: // 999999991G''''''''''''''' | |
12677 | + case 18446744073709551050LLU: // 999999991J''''''''''''''' | |
12789 | 12678 | { |
12790 | - state.addr = *LOCAL_ACCESS(heap.data, 7LLU, 6LLU) ? 18446744073709551050LLU : 18446744073709551049LLU; | |
12679 | + state.addr = *LOCAL_ACCESS(heap.data, 7LLU, 6LLU) ? 18446744073709551053LLU : 18446744073709551052LLU; | |
12791 | 12680 | (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 7 |
12792 | 12681 | break; |
12793 | 12682 | } |
12794 | - case 18446744073709551050LLU: // 999999991J''''''''''''''' | |
12683 | + case 18446744073709551053LLU: // 999999991M''''''''''''''' | |
12795 | 12684 | { |
12796 | - state.addr = 18446744073709551048LLU; // 999999991H''''''''''''''' | |
12685 | + state.addr = 18446744073709551051LLU; // 999999991K''''''''''''''' | |
12797 | 12686 | break; |
12798 | 12687 | } |
12799 | - case 18446744073709551049LLU: // 999999991I''''''''''''''' | |
12688 | + case 18446744073709551052LLU: // 999999991L''''''''''''''' | |
12800 | 12689 | { |
12801 | 12690 | fprintf(stderr, "%s", "function "); |
12802 | 12691 | printid(stderr, /*def_id____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 6LLU, 0LLU))); |
@@ -12807,15 +12696,15 @@ | ||
12807 | 12696 | fprintf(stderr, "%s\n", ""); |
12808 | 12697 | exit(-1); |
12809 | 12698 | } |
12810 | - state.addr = 18446744073709551048LLU; // 999999991H''''''''''''''' | |
12699 | + state.addr = 18446744073709551051LLU; // 999999991K''''''''''''''' | |
12811 | 12700 | break; |
12812 | 12701 | } |
12813 | - case 18446744073709551048LLU: // 999999991H''''''''''''''' | |
12702 | + case 18446744073709551051LLU: // 999999991K''''''''''''''' | |
12814 | 12703 | { |
12815 | - state.addr = 18446744073709551051LLU; // 999999991K''''''''''''''' | |
12704 | + state.addr = 18446744073709551054LLU; // 999999991N''''''''''''''' | |
12816 | 12705 | break; |
12817 | 12706 | } |
12818 | - case 18446744073709551051LLU: // 999999991K''''''''''''''' | |
12707 | + case 18446744073709551054LLU: // 999999991N''''''''''''''' | |
12819 | 12708 | { |
12820 | 12709 | { |
12821 | 12710 | uint64_t arg = 0; |
@@ -12822,11 +12711,11 @@ | ||
12822 | 12711 | LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
12823 | 12712 | } |
12824 | 12713 | *LOCAL_ACCESS(heap.data, 7LLU, 6LLU) = /*safe______*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 7LLU, 5LLU)); |
12825 | - state.addr = *LOCAL_ACCESS(heap.data, 7LLU, 6LLU) ? 18446744073709551046LLU : 18446744073709551045LLU; | |
12714 | + state.addr = *LOCAL_ACCESS(heap.data, 7LLU, 6LLU) ? 18446744073709551049LLU : 18446744073709551048LLU; | |
12826 | 12715 | (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 7 |
12827 | 12716 | break; |
12828 | 12717 | } |
12829 | - case 18446744073709551046LLU: // 999999991F''''''''''''''' | |
12718 | + case 18446744073709551049LLU: // 999999991I''''''''''''''' | |
12830 | 12719 | { |
12831 | 12720 | { |
12832 | 12721 | uint64_t arg = 0; |
@@ -12842,7 +12731,7 @@ | ||
12842 | 12731 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
12843 | 12732 | } |
12844 | 12733 | // ACCUMULATE ARGUMENTS - END |
12845 | - uint64_t return_to = 18446744073709551041LLU; | |
12734 | + uint64_t return_to = 18446744073709551044LLU; | |
12846 | 12735 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
12847 | 12736 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
12848 | 12737 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -12851,18 +12740,18 @@ | ||
12851 | 12740 | state.addr = 606219895113252864LLU; // fnsafe____ |
12852 | 12741 | break; |
12853 | 12742 | } |
12854 | - case 18446744073709551041LLU: // 999999991A''''''''''''''' | |
12743 | + case 18446744073709551044LLU: // 999999991D''''''''''''''' | |
12855 | 12744 | { |
12856 | - state.addr = *LOCAL_ACCESS(heap.data, 7LLU, 6LLU) ? 18446744073709551044LLU : 18446744073709551043LLU; | |
12745 | + state.addr = *LOCAL_ACCESS(heap.data, 7LLU, 6LLU) ? 18446744073709551047LLU : 18446744073709551046LLU; | |
12857 | 12746 | (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 7 |
12858 | 12747 | break; |
12859 | 12748 | } |
12860 | - case 18446744073709551044LLU: // 999999991D''''''''''''''' | |
12749 | + case 18446744073709551047LLU: // 999999991G''''''''''''''' | |
12861 | 12750 | { |
12862 | - state.addr = 18446744073709551042LLU; // 999999991B''''''''''''''' | |
12751 | + state.addr = 18446744073709551045LLU; // 999999991E''''''''''''''' | |
12863 | 12752 | break; |
12864 | 12753 | } |
12865 | - case 18446744073709551043LLU: // 999999991C''''''''''''''' | |
12754 | + case 18446744073709551046LLU: // 999999991F''''''''''''''' | |
12866 | 12755 | { |
12867 | 12756 | fprintf(stderr, "%s", "function "); |
12868 | 12757 | printid(stderr, /*def_id____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 6LLU, 0LLU))); |
@@ -12873,15 +12762,15 @@ | ||
12873 | 12762 | fprintf(stderr, "%s\n", ""); |
12874 | 12763 | exit(-1); |
12875 | 12764 | } |
12876 | - state.addr = 18446744073709551042LLU; // 999999991B''''''''''''''' | |
12765 | + state.addr = 18446744073709551045LLU; // 999999991E''''''''''''''' | |
12877 | 12766 | break; |
12878 | 12767 | } |
12879 | - case 18446744073709551042LLU: // 999999991B''''''''''''''' | |
12768 | + case 18446744073709551045LLU: // 999999991E''''''''''''''' | |
12880 | 12769 | { |
12881 | - state.addr = 18446744073709551045LLU; // 999999991E''''''''''''''' | |
12770 | + state.addr = 18446744073709551048LLU; // 999999991H''''''''''''''' | |
12882 | 12771 | break; |
12883 | 12772 | } |
12884 | - case 18446744073709551045LLU: // 999999991E''''''''''''''' | |
12773 | + case 18446744073709551048LLU: // 999999991H''''''''''''''' | |
12885 | 12774 | { |
12886 | 12775 | // parameter-reference u64 safe______ goes out of scope |
12887 | 12776 | (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference safe______ at 6 |
@@ -12931,7 +12820,7 @@ | ||
12931 | 12820 | LOCAL_PUSH_MOVE(&heap, 5LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
12932 | 12821 | } |
12933 | 12822 | // ACCUMULATE ARGUMENTS - END |
12934 | - uint64_t return_to = 18446744073709551040LLU; | |
12823 | + uint64_t return_to = 18446744073709551043LLU; | |
12935 | 12824 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 6LLU, 0/*address of closure-in-construction*/, 0)); |
12936 | 12825 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
12937 | 12826 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 6LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -12940,7 +12829,7 @@ | ||
12940 | 12829 | state.addr = 567600662901349312LLU; // defassert_ |
12941 | 12830 | break; |
12942 | 12831 | } |
12943 | - case 18446744073709551040LLU: // 999999991_''''''''''''''' | |
12832 | + case 18446744073709551043LLU: // 999999991C''''''''''''''' | |
12944 | 12833 | { |
12945 | 12834 | |
12946 | 12835 | *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 10LLU, 8LLU)) = /*fn________*/*access_heap(heap.data, tree_elem_addr(heap.data, 7LLU, *LOCAL_ACCESS(heap.data, 10LLU, 1LLU), 3LLU)); |
@@ -12954,10 +12843,10 @@ | ||
12954 | 12843 | uint64_t arg = 0; |
12955 | 12844 | LOCAL_PUSH_MOVE(&heap, 11, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
12956 | 12845 | } |
12957 | - state.addr = 18446744073709551039LLU; // 9999999909''''''''''''''' | |
12846 | + state.addr = 18446744073709551042LLU; // 999999991B''''''''''''''' | |
12958 | 12847 | break; |
12959 | 12848 | } |
12960 | - case 18446744073709551039LLU: // 9999999909''''''''''''''' | |
12849 | + case 18446744073709551042LLU: // 999999991B''''''''''''''' | |
12961 | 12850 | { |
12962 | 12851 | if(!*LOCAL_ACCESS(heap.data, 12LLU, 10LLU)) |
12963 | 12852 | { |
@@ -12964,7 +12853,7 @@ | ||
12964 | 12853 | (void)LOCAL_POP_MOVE(&heap, 12LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 12 |
12965 | 12854 | (void)LOCAL_POP_MOVE(&heap, 11LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 11 |
12966 | 12855 | { |
12967 | - state.addr = 18446744073709551038LLU; // 9999999908''''''''''''''' | |
12856 | + state.addr = 18446744073709551041LLU; // 999999991A''''''''''''''' | |
12968 | 12857 | break; |
12969 | 12858 | } |
12970 | 12859 | } |
@@ -12997,7 +12886,7 @@ | ||
12997 | 12886 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
12998 | 12887 | } |
12999 | 12888 | // ACCUMULATE ARGUMENTS - END |
13000 | - uint64_t return_to = 18446744073709551033LLU; | |
12889 | + uint64_t return_to = 18446744073709551036LLU; | |
13001 | 12890 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
13002 | 12891 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
13003 | 12892 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -13006,7 +12895,7 @@ | ||
13006 | 12895 | state.addr = 367395560426147840LLU; // TYPECOPY__ |
13007 | 12896 | break; |
13008 | 12897 | } |
13009 | - case 18446744073709551033LLU: // 9999999903''''''''''''''' | |
12898 | + case 18446744073709551036LLU: // 9999999906''''''''''''''' | |
13010 | 12899 | { |
13011 | 12900 | { |
13012 | 12901 | uint64_t exchange = LOCAL_POP_MOVE(&heap, 15LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 15*/; |
@@ -13035,7 +12924,7 @@ | ||
13035 | 12924 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
13036 | 12925 | } |
13037 | 12926 | // ACCUMULATE ARGUMENTS - END |
13038 | - uint64_t return_to = 18446744073709551032LLU; | |
12927 | + uint64_t return_to = 18446744073709551035LLU; | |
13039 | 12928 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
13040 | 12929 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
13041 | 12930 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -13044,7 +12933,7 @@ | ||
13044 | 12933 | state.addr = 552446646280519680LLU; // copyu64___ |
13045 | 12934 | break; |
13046 | 12935 | } |
13047 | - case 18446744073709551032LLU: // 9999999902''''''''''''''' | |
12936 | + case 18446744073709551035LLU: // 9999999905''''''''''''''' | |
13048 | 12937 | { |
13049 | 12938 | { |
13050 | 12939 | uint64_t exchange = LOCAL_POP_MOVE(&heap, 15LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 15*/; |
@@ -13073,7 +12962,7 @@ | ||
13073 | 12962 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
13074 | 12963 | } |
13075 | 12964 | // ACCUMULATE ARGUMENTS - END |
13076 | - uint64_t return_to = 18446744073709551031LLU; | |
12965 | + uint64_t return_to = 18446744073709551034LLU; | |
13077 | 12966 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
13078 | 12967 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
13079 | 12968 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -13082,7 +12971,7 @@ | ||
13082 | 12971 | state.addr = 552446646280519680LLU; // copyu64___ |
13083 | 12972 | break; |
13084 | 12973 | } |
13085 | - case 18446744073709551031LLU: // 9999999901''''''''''''''' | |
12974 | + case 18446744073709551034LLU: // 9999999904''''''''''''''' | |
13086 | 12975 | { |
13087 | 12976 | { |
13088 | 12977 | uint64_t exchange = LOCAL_POP_MOVE(&heap, 15LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 15*/; |
@@ -13094,7 +12983,7 @@ | ||
13094 | 12983 | } |
13095 | 12984 | } |
13096 | 12985 | // ACCUMULATE ARGUMENTS - END |
13097 | - uint64_t return_to = 18446744073709551034LLU; | |
12986 | + uint64_t return_to = 18446744073709551037LLU; | |
13098 | 12987 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
13099 | 12988 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
13100 | 12989 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -13103,12 +12992,12 @@ | ||
13103 | 12992 | state.addr = 819859607768530944LLU; // resdest___ |
13104 | 12993 | break; |
13105 | 12994 | } |
13106 | - case 18446744073709551034LLU: // 9999999904''''''''''''''' | |
12995 | + case 18446744073709551037LLU: // 9999999907''''''''''''''' | |
13107 | 12996 | { |
13108 | - state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 13LLU, 12LLU), &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 13LLU, 6LLU)), 8) ? 18446744073709551037LLU : 18446744073709551036LLU; | |
12997 | + state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 13LLU, 12LLU), &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 13LLU, 6LLU)), 8) ? 18446744073709551040LLU : 18446744073709551039LLU; | |
13109 | 12998 | break; |
13110 | 12999 | } |
13111 | - case 18446744073709551037LLU: // 9999999907''''''''''''''' | |
13000 | + case 18446744073709551040LLU: // 999999991_''''''''''''''' | |
13112 | 13001 | { |
13113 | 13002 | fprintf(stderr, "%s", "pushing par "); |
13114 | 13003 | // ACCUMULATE ARGUMENTS - BEGIN |
@@ -13117,7 +13006,7 @@ | ||
13117 | 13006 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
13118 | 13007 | } |
13119 | 13008 | // ACCUMULATE ARGUMENTS - END |
13120 | - uint64_t return_to = 18446744073709551030LLU; | |
13009 | + uint64_t return_to = 18446744073709551033LLU; | |
13121 | 13010 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
13122 | 13011 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
13123 | 13012 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -13126,7 +13015,7 @@ | ||
13126 | 13015 | state.addr = 819847183518272384LLU; // reportres_ |
13127 | 13016 | break; |
13128 | 13017 | } |
13129 | - case 18446744073709551030LLU: // 9999999900''''''''''''''' | |
13018 | + case 18446744073709551033LLU: // 9999999903''''''''''''''' | |
13130 | 13019 | { |
13131 | 13020 | fprintf(stderr, "%s", "\n"); |
13132 | 13021 | { |
@@ -13140,7 +13029,7 @@ | ||
13140 | 13029 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
13141 | 13030 | } |
13142 | 13031 | // ACCUMULATE ARGUMENTS - END |
13143 | - uint64_t return_to = 18446744073709551029LLU; | |
13032 | + uint64_t return_to = 18446744073709551032LLU; | |
13144 | 13033 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
13145 | 13034 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
13146 | 13035 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -13149,26 +13038,26 @@ | ||
13149 | 13038 | state.addr = 18446744073709551534LLU; // 999999998s''''''''''''''' |
13150 | 13039 | break; |
13151 | 13040 | } |
13152 | - case 18446744073709551029LLU: // 999999990z''''''''''''''' | |
13041 | + case 18446744073709551032LLU: // 9999999902''''''''''''''' | |
13153 | 13042 | { |
13154 | 13043 | // parameter resdest___ new_______ goes out of scope |
13155 | - state.addr = 18446744073709551035LLU; // 9999999905''''''''''''''' | |
13044 | + state.addr = 18446744073709551038LLU; // 9999999908''''''''''''''' | |
13156 | 13045 | break; |
13157 | 13046 | } |
13158 | - case 18446744073709551036LLU: // 9999999906''''''''''''''' | |
13047 | + case 18446744073709551039LLU: // 9999999909''''''''''''''' | |
13159 | 13048 | { |
13160 | - state.addr = 18446744073709551035LLU; // 9999999905''''''''''''''' | |
13049 | + state.addr = 18446744073709551038LLU; // 9999999908''''''''''''''' | |
13161 | 13050 | break; |
13162 | 13051 | } |
13163 | - case 18446744073709551035LLU: // 9999999905''''''''''''''' | |
13052 | + case 18446744073709551038LLU: // 9999999908''''''''''''''' | |
13164 | 13053 | { |
13165 | 13054 | (void)LOCAL_POP_MOVE(&heap, 13LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 13 |
13166 | 13055 | // parameter-reference resdest___ par_______ goes out of scope |
13167 | 13056 | // parameter-reference function__ fn________ goes out of scope |
13168 | - state.addr = 18446744073709551039LLU; // 9999999909''''''''''''''' | |
13057 | + state.addr = 18446744073709551042LLU; // 999999991B''''''''''''''' | |
13169 | 13058 | break; |
13170 | 13059 | } |
13171 | - case 18446744073709551038LLU: // 9999999908''''''''''''''' | |
13060 | + case 18446744073709551041LLU: // 999999991A''''''''''''''' | |
13172 | 13061 | { |
13173 | 13062 | { |
13174 | 13063 | uint64_t arg = /*fn________*/*access_heap(heap.data, tree_elem_addr(heap.data, 7LLU, *LOCAL_ACCESS(heap.data, 10LLU, 1LLU), 1LLU)); |
@@ -13178,10 +13067,10 @@ | ||
13178 | 13067 | uint64_t arg = 0; |
13179 | 13068 | LOCAL_PUSH_MOVE(&heap, 11, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
13180 | 13069 | } |
13181 | - state.addr = 18446744073709551028LLU; // 999999990y''''''''''''''' | |
13070 | + state.addr = 18446744073709551031LLU; // 9999999901''''''''''''''' | |
13182 | 13071 | break; |
13183 | 13072 | } |
13184 | - case 18446744073709551028LLU: // 999999990y''''''''''''''' | |
13073 | + case 18446744073709551031LLU: // 9999999901''''''''''''''' | |
13185 | 13074 | { |
13186 | 13075 | if(!*LOCAL_ACCESS(heap.data, 12LLU, 10LLU)) |
13187 | 13076 | { |
@@ -13188,7 +13077,7 @@ | ||
13188 | 13077 | (void)LOCAL_POP_MOVE(&heap, 12LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 12 |
13189 | 13078 | (void)LOCAL_POP_MOVE(&heap, 11LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 11 |
13190 | 13079 | { |
13191 | - state.addr = 18446744073709551027LLU; // 999999990x''''''''''''''' | |
13080 | + state.addr = 18446744073709551030LLU; // 9999999900''''''''''''''' | |
13192 | 13081 | break; |
13193 | 13082 | } |
13194 | 13083 | } |
@@ -13221,7 +13110,7 @@ | ||
13221 | 13110 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
13222 | 13111 | } |
13223 | 13112 | // ACCUMULATE ARGUMENTS - END |
13224 | - uint64_t return_to = 18446744073709551022LLU; | |
13113 | + uint64_t return_to = 18446744073709551025LLU; | |
13225 | 13114 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
13226 | 13115 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
13227 | 13116 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -13230,7 +13119,7 @@ | ||
13230 | 13119 | state.addr = 367395560426147840LLU; // TYPECOPY__ |
13231 | 13120 | break; |
13232 | 13121 | } |
13233 | - case 18446744073709551022LLU: // 999999990s''''''''''''''' | |
13122 | + case 18446744073709551025LLU: // 999999990v''''''''''''''' | |
13234 | 13123 | { |
13235 | 13124 | { |
13236 | 13125 | uint64_t exchange = LOCAL_POP_MOVE(&heap, 15LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 15*/; |
@@ -13259,7 +13148,7 @@ | ||
13259 | 13148 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
13260 | 13149 | } |
13261 | 13150 | // ACCUMULATE ARGUMENTS - END |
13262 | - uint64_t return_to = 18446744073709551021LLU; | |
13151 | + uint64_t return_to = 18446744073709551024LLU; | |
13263 | 13152 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
13264 | 13153 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
13265 | 13154 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -13268,7 +13157,7 @@ | ||
13268 | 13157 | state.addr = 552446646280519680LLU; // copyu64___ |
13269 | 13158 | break; |
13270 | 13159 | } |
13271 | - case 18446744073709551021LLU: // 999999990r''''''''''''''' | |
13160 | + case 18446744073709551024LLU: // 999999990u''''''''''''''' | |
13272 | 13161 | { |
13273 | 13162 | { |
13274 | 13163 | uint64_t exchange = LOCAL_POP_MOVE(&heap, 15LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 15*/; |
@@ -13297,7 +13186,7 @@ | ||
13297 | 13186 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
13298 | 13187 | } |
13299 | 13188 | // ACCUMULATE ARGUMENTS - END |
13300 | - uint64_t return_to = 18446744073709551020LLU; | |
13189 | + uint64_t return_to = 18446744073709551023LLU; | |
13301 | 13190 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
13302 | 13191 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
13303 | 13192 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -13306,7 +13195,7 @@ | ||
13306 | 13195 | state.addr = 58555672873677120LLU; // CPBALANCE_ |
13307 | 13196 | break; |
13308 | 13197 | } |
13309 | - case 18446744073709551020LLU: // 999999990q''''''''''''''' | |
13198 | + case 18446744073709551023LLU: // 999999990t''''''''''''''' | |
13310 | 13199 | { |
13311 | 13200 | { |
13312 | 13201 | uint64_t exchange = LOCAL_POP_MOVE(&heap, 15LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 15*/; |
@@ -13335,7 +13224,7 @@ | ||
13335 | 13224 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
13336 | 13225 | } |
13337 | 13226 | // ACCUMULATE ARGUMENTS - END |
13338 | - uint64_t return_to = 18446744073709551019LLU; | |
13227 | + uint64_t return_to = 18446744073709551022LLU; | |
13339 | 13228 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
13340 | 13229 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
13341 | 13230 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -13344,7 +13233,7 @@ | ||
13344 | 13233 | state.addr = 552446646280519680LLU; // copyu64___ |
13345 | 13234 | break; |
13346 | 13235 | } |
13347 | - case 18446744073709551019LLU: // 999999990p''''''''''''''' | |
13236 | + case 18446744073709551022LLU: // 999999990s''''''''''''''' | |
13348 | 13237 | { |
13349 | 13238 | { |
13350 | 13239 | uint64_t exchange = LOCAL_POP_MOVE(&heap, 15LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 15*/; |
@@ -13356,7 +13245,7 @@ | ||
13356 | 13245 | } |
13357 | 13246 | } |
13358 | 13247 | // ACCUMULATE ARGUMENTS - END |
13359 | - uint64_t return_to = 18446744073709551023LLU; | |
13248 | + uint64_t return_to = 18446744073709551026LLU; | |
13360 | 13249 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)); |
13361 | 13250 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
13362 | 13251 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -13365,12 +13254,12 @@ | ||
13365 | 13254 | state.addr = 782700512565788672LLU; // pardef____ |
13366 | 13255 | break; |
13367 | 13256 | } |
13368 | - case 18446744073709551023LLU: // 999999990t''''''''''''''' | |
13257 | + case 18446744073709551026LLU: // 999999990w''''''''''''''' | |
13369 | 13258 | { |
13370 | - state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 13LLU, 12LLU), &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 13LLU, 7LLU)), 11) ? 18446744073709551026LLU : 18446744073709551025LLU; | |
13259 | + state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 13LLU, 12LLU), &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 13LLU, 7LLU)), 11) ? 18446744073709551029LLU : 18446744073709551028LLU; | |
13371 | 13260 | break; |
13372 | 13261 | } |
13373 | - case 18446744073709551026LLU: // 999999990w''''''''''''''' | |
13262 | + case 18446744073709551029LLU: // 999999990z''''''''''''''' | |
13374 | 13263 | { |
13375 | 13264 | fprintf(stderr, "%s", "[defunpack] pushing par "); |
13376 | 13265 | // ACCUMULATE ARGUMENTS - BEGIN |
@@ -13379,7 +13268,7 @@ | ||
13379 | 13268 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
13380 | 13269 | } |
13381 | 13270 | // ACCUMULATE ARGUMENTS - END |
13382 | - uint64_t return_to = 18446744073709551018LLU; | |
13271 | + uint64_t return_to = 18446744073709551021LLU; | |
13383 | 13272 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
13384 | 13273 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
13385 | 13274 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -13388,7 +13277,7 @@ | ||
13388 | 13277 | state.addr = 819847183518878432LLU; // reporttype |
13389 | 13278 | break; |
13390 | 13279 | } |
13391 | - case 18446744073709551018LLU: // 999999990o''''''''''''''' | |
13280 | + case 18446744073709551021LLU: // 999999990r''''''''''''''' | |
13392 | 13281 | { |
13393 | 13282 | fprintf(stderr, "%s", "\n"); |
13394 | 13283 | { |
@@ -13402,7 +13291,7 @@ | ||
13402 | 13291 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
13403 | 13292 | } |
13404 | 13293 | // ACCUMULATE ARGUMENTS - END |
13405 | - uint64_t return_to = 18446744073709551017LLU; | |
13294 | + uint64_t return_to = 18446744073709551020LLU; | |
13406 | 13295 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
13407 | 13296 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
13408 | 13297 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -13411,26 +13300,26 @@ | ||
13411 | 13300 | state.addr = 18446744073709551468LLU; // 999999997q''''''''''''''' |
13412 | 13301 | break; |
13413 | 13302 | } |
13414 | - case 18446744073709551017LLU: // 999999990n''''''''''''''' | |
13303 | + case 18446744073709551020LLU: // 999999990q''''''''''''''' | |
13415 | 13304 | { |
13416 | 13305 | // parameter pardef____ new_______ goes out of scope |
13417 | - state.addr = 18446744073709551024LLU; // 999999990u''''''''''''''' | |
13306 | + state.addr = 18446744073709551027LLU; // 999999990x''''''''''''''' | |
13418 | 13307 | break; |
13419 | 13308 | } |
13420 | - case 18446744073709551025LLU: // 999999990v''''''''''''''' | |
13309 | + case 18446744073709551028LLU: // 999999990y''''''''''''''' | |
13421 | 13310 | { |
13422 | - state.addr = 18446744073709551024LLU; // 999999990u''''''''''''''' | |
13311 | + state.addr = 18446744073709551027LLU; // 999999990x''''''''''''''' | |
13423 | 13312 | break; |
13424 | 13313 | } |
13425 | - case 18446744073709551024LLU: // 999999990u''''''''''''''' | |
13314 | + case 18446744073709551027LLU: // 999999990x''''''''''''''' | |
13426 | 13315 | { |
13427 | 13316 | (void)LOCAL_POP_MOVE(&heap, 13LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 13 |
13428 | 13317 | // parameter-reference pardef____ par_______ goes out of scope |
13429 | 13318 | // parameter-reference function__ fn________ goes out of scope |
13430 | - state.addr = 18446744073709551028LLU; // 999999990y''''''''''''''' | |
13319 | + state.addr = 18446744073709551031LLU; // 9999999901''''''''''''''' | |
13431 | 13320 | break; |
13432 | 13321 | } |
13433 | - case 18446744073709551027LLU: // 999999990x''''''''''''''' | |
13322 | + case 18446744073709551030LLU: // 9999999900''''''''''''''' | |
13434 | 13323 | { |
13435 | 13324 | // parameter-reference u64 sizeonheap goes out of scope |
13436 | 13325 | (void)LOCAL_POP_MOVE(&heap, 10LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference sizeonheap at 10 |
@@ -13536,10 +13425,10 @@ | ||
13536 | 13425 | uint64_t arg = 0; |
13537 | 13426 | LOCAL_PUSH_MOVE(&heap, 18, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
13538 | 13427 | } |
13539 | - state.addr = 18446744073709551015LLU; // 999999990l''''''''''''''' | |
13428 | + state.addr = 18446744073709551018LLU; // 999999990o''''''''''''''' | |
13540 | 13429 | break; |
13541 | 13430 | } |
13542 | - case 18446744073709551015LLU: // 999999990l''''''''''''''' | |
13431 | + case 18446744073709551018LLU: // 999999990o''''''''''''''' | |
13543 | 13432 | { |
13544 | 13433 | if(!*LOCAL_ACCESS(heap.data, 19LLU, 17LLU)) |
13545 | 13434 | { |
@@ -13546,7 +13435,7 @@ | ||
13546 | 13435 | (void)LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 19 |
13547 | 13436 | (void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 18 |
13548 | 13437 | { |
13549 | - state.addr = 18446744073709551014LLU; // 999999990k''''''''''''''' | |
13438 | + state.addr = 18446744073709551017LLU; // 999999990n''''''''''''''' | |
13550 | 13439 | break; |
13551 | 13440 | } |
13552 | 13441 | } |
@@ -13579,7 +13468,7 @@ | ||
13579 | 13468 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
13580 | 13469 | } |
13581 | 13470 | // ACCUMULATE ARGUMENTS - END |
13582 | - uint64_t return_to = 18446744073709551009LLU; | |
13471 | + uint64_t return_to = 18446744073709551012LLU; | |
13583 | 13472 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
13584 | 13473 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
13585 | 13474 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -13588,7 +13477,7 @@ | ||
13588 | 13477 | state.addr = 367395560426147840LLU; // TYPECOPY__ |
13589 | 13478 | break; |
13590 | 13479 | } |
13591 | - case 18446744073709551009LLU: // 999999990f''''''''''''''' | |
13480 | + case 18446744073709551012LLU: // 999999990i''''''''''''''' | |
13592 | 13481 | { |
13593 | 13482 | { |
13594 | 13483 | uint64_t exchange = LOCAL_POP_MOVE(&heap, 22LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 22*/; |
@@ -13617,7 +13506,7 @@ | ||
13617 | 13506 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
13618 | 13507 | } |
13619 | 13508 | // ACCUMULATE ARGUMENTS - END |
13620 | - uint64_t return_to = 18446744073709551008LLU; | |
13509 | + uint64_t return_to = 18446744073709551011LLU; | |
13621 | 13510 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
13622 | 13511 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
13623 | 13512 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -13626,7 +13515,7 @@ | ||
13626 | 13515 | state.addr = 552446646280519680LLU; // copyu64___ |
13627 | 13516 | break; |
13628 | 13517 | } |
13629 | - case 18446744073709551008LLU: // 999999990e''''''''''''''' | |
13518 | + case 18446744073709551011LLU: // 999999990h''''''''''''''' | |
13630 | 13519 | { |
13631 | 13520 | { |
13632 | 13521 | uint64_t exchange = LOCAL_POP_MOVE(&heap, 22LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 22*/; |
@@ -13655,7 +13544,7 @@ | ||
13655 | 13544 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
13656 | 13545 | } |
13657 | 13546 | // ACCUMULATE ARGUMENTS - END |
13658 | - uint64_t return_to = 18446744073709551007LLU; | |
13547 | + uint64_t return_to = 18446744073709551010LLU; | |
13659 | 13548 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
13660 | 13549 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
13661 | 13550 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -13664,7 +13553,7 @@ | ||
13664 | 13553 | state.addr = 58555672873677120LLU; // CPBALANCE_ |
13665 | 13554 | break; |
13666 | 13555 | } |
13667 | - case 18446744073709551007LLU: // 999999990d''''''''''''''' | |
13556 | + case 18446744073709551010LLU: // 999999990g''''''''''''''' | |
13668 | 13557 | { |
13669 | 13558 | { |
13670 | 13559 | uint64_t exchange = LOCAL_POP_MOVE(&heap, 22LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 22*/; |
@@ -13693,7 +13582,7 @@ | ||
13693 | 13582 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
13694 | 13583 | } |
13695 | 13584 | // ACCUMULATE ARGUMENTS - END |
13696 | - uint64_t return_to = 18446744073709551006LLU; | |
13585 | + uint64_t return_to = 18446744073709551009LLU; | |
13697 | 13586 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
13698 | 13587 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
13699 | 13588 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -13702,7 +13591,7 @@ | ||
13702 | 13591 | state.addr = 552446646280519680LLU; // copyu64___ |
13703 | 13592 | break; |
13704 | 13593 | } |
13705 | - case 18446744073709551006LLU: // 999999990c''''''''''''''' | |
13594 | + case 18446744073709551009LLU: // 999999990f''''''''''''''' | |
13706 | 13595 | { |
13707 | 13596 | { |
13708 | 13597 | uint64_t exchange = LOCAL_POP_MOVE(&heap, 22LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 22*/; |
@@ -13714,7 +13603,7 @@ | ||
13714 | 13603 | } |
13715 | 13604 | } |
13716 | 13605 | // ACCUMULATE ARGUMENTS - END |
13717 | - uint64_t return_to = 18446744073709551010LLU; | |
13606 | + uint64_t return_to = 18446744073709551013LLU; | |
13718 | 13607 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)); |
13719 | 13608 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
13720 | 13609 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -13723,12 +13612,12 @@ | ||
13723 | 13612 | state.addr = 782700512565788672LLU; // pardef____ |
13724 | 13613 | break; |
13725 | 13614 | } |
13726 | - case 18446744073709551010LLU: // 999999990g''''''''''''''' | |
13615 | + case 18446744073709551013LLU: // 999999990j''''''''''''''' | |
13727 | 13616 | { |
13728 | - state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 20LLU, 19LLU), &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 20LLU, 4LLU)), 11) ? 18446744073709551013LLU : 18446744073709551012LLU; | |
13617 | + state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 20LLU, 19LLU), &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 20LLU, 4LLU)), 11) ? 18446744073709551016LLU : 18446744073709551015LLU; | |
13729 | 13618 | break; |
13730 | 13619 | } |
13731 | - case 18446744073709551013LLU: // 999999990j''''''''''''''' | |
13620 | + case 18446744073709551016LLU: // 999999990m''''''''''''''' | |
13732 | 13621 | { |
13733 | 13622 | fprintf(stderr, "%s", "pushing par "); |
13734 | 13623 | // ACCUMULATE ARGUMENTS - BEGIN |
@@ -13737,7 +13626,7 @@ | ||
13737 | 13626 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
13738 | 13627 | } |
13739 | 13628 | // ACCUMULATE ARGUMENTS - END |
13740 | - uint64_t return_to = 18446744073709551005LLU; | |
13629 | + uint64_t return_to = 18446744073709551008LLU; | |
13741 | 13630 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
13742 | 13631 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
13743 | 13632 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -13746,7 +13635,7 @@ | ||
13746 | 13635 | state.addr = 819847183518878432LLU; // reporttype |
13747 | 13636 | break; |
13748 | 13637 | } |
13749 | - case 18446744073709551005LLU: // 999999990b''''''''''''''' | |
13638 | + case 18446744073709551008LLU: // 999999990e''''''''''''''' | |
13750 | 13639 | { |
13751 | 13640 | fprintf(stderr, "%s", "\n"); |
13752 | 13641 | { |
@@ -13760,7 +13649,7 @@ | ||
13760 | 13649 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
13761 | 13650 | } |
13762 | 13651 | // ACCUMULATE ARGUMENTS - END |
13763 | - uint64_t return_to = 18446744073709551004LLU; | |
13652 | + uint64_t return_to = 18446744073709551007LLU; | |
13764 | 13653 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
13765 | 13654 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
13766 | 13655 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -13769,26 +13658,26 @@ | ||
13769 | 13658 | state.addr = 18446744073709551468LLU; // 999999997q''''''''''''''' |
13770 | 13659 | break; |
13771 | 13660 | } |
13772 | - case 18446744073709551004LLU: // 999999990a''''''''''''''' | |
13661 | + case 18446744073709551007LLU: // 999999990d''''''''''''''' | |
13773 | 13662 | { |
13774 | 13663 | // parameter pardef____ new_______ goes out of scope |
13775 | - state.addr = 18446744073709551011LLU; // 999999990h''''''''''''''' | |
13664 | + state.addr = 18446744073709551014LLU; // 999999990k''''''''''''''' | |
13776 | 13665 | break; |
13777 | 13666 | } |
13778 | - case 18446744073709551012LLU: // 999999990i''''''''''''''' | |
13667 | + case 18446744073709551015LLU: // 999999990l''''''''''''''' | |
13779 | 13668 | { |
13780 | - state.addr = 18446744073709551011LLU; // 999999990h''''''''''''''' | |
13669 | + state.addr = 18446744073709551014LLU; // 999999990k''''''''''''''' | |
13781 | 13670 | break; |
13782 | 13671 | } |
13783 | - case 18446744073709551011LLU: // 999999990h''''''''''''''' | |
13672 | + case 18446744073709551014LLU: // 999999990k''''''''''''''' | |
13784 | 13673 | { |
13785 | 13674 | (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 20 |
13786 | 13675 | // parameter-reference pardef____ par_______ goes out of scope |
13787 | 13676 | // parameter-reference list<pardef____> defpars1__ goes out of scope |
13788 | - state.addr = 18446744073709551015LLU; // 999999990l''''''''''''''' | |
13677 | + state.addr = 18446744073709551018LLU; // 999999990o''''''''''''''' | |
13789 | 13678 | break; |
13790 | 13679 | } |
13791 | - case 18446744073709551014LLU: // 999999990k''''''''''''''' | |
13680 | + case 18446744073709551017LLU: // 999999990n''''''''''''''' | |
13792 | 13681 | { |
13793 | 13682 | { |
13794 | 13683 | uint64_t arg = /*respars1__*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 17LLU, 10LLU)); |
@@ -13798,10 +13687,10 @@ | ||
13798 | 13687 | uint64_t arg = 0; |
13799 | 13688 | LOCAL_PUSH_MOVE(&heap, 18, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
13800 | 13689 | } |
13801 | - state.addr = 18446744073709551003LLU; // 999999990$''''''''''''''' | |
13690 | + state.addr = 18446744073709551006LLU; // 999999990c''''''''''''''' | |
13802 | 13691 | break; |
13803 | 13692 | } |
13804 | - case 18446744073709551003LLU: // 999999990$''''''''''''''' | |
13693 | + case 18446744073709551006LLU: // 999999990c''''''''''''''' | |
13805 | 13694 | { |
13806 | 13695 | if(!*LOCAL_ACCESS(heap.data, 19LLU, 17LLU)) |
13807 | 13696 | { |
@@ -13808,7 +13697,7 @@ | ||
13808 | 13697 | (void)LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 19 |
13809 | 13698 | (void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 18 |
13810 | 13699 | { |
13811 | - state.addr = 18446744073709551002LLU; // 999999990Z''''''''''''''' | |
13700 | + state.addr = 18446744073709551005LLU; // 999999990b''''''''''''''' | |
13812 | 13701 | break; |
13813 | 13702 | } |
13814 | 13703 | } |
@@ -13841,7 +13730,7 @@ | ||
13841 | 13730 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
13842 | 13731 | } |
13843 | 13732 | // ACCUMULATE ARGUMENTS - END |
13844 | - uint64_t return_to = 18446744073709550997LLU; | |
13733 | + uint64_t return_to = 18446744073709551000LLU; | |
13845 | 13734 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
13846 | 13735 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
13847 | 13736 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -13850,7 +13739,7 @@ | ||
13850 | 13739 | state.addr = 367395560426147840LLU; // TYPECOPY__ |
13851 | 13740 | break; |
13852 | 13741 | } |
13853 | - case 18446744073709550997LLU: // 999999990U''''''''''''''' | |
13742 | + case 18446744073709551000LLU: // 999999990X''''''''''''''' | |
13854 | 13743 | { |
13855 | 13744 | { |
13856 | 13745 | uint64_t exchange = LOCAL_POP_MOVE(&heap, 22LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 22*/; |
@@ -13879,7 +13768,7 @@ | ||
13879 | 13768 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
13880 | 13769 | } |
13881 | 13770 | // ACCUMULATE ARGUMENTS - END |
13882 | - uint64_t return_to = 18446744073709550996LLU; | |
13771 | + uint64_t return_to = 18446744073709550999LLU; | |
13883 | 13772 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
13884 | 13773 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
13885 | 13774 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -13888,7 +13777,7 @@ | ||
13888 | 13777 | state.addr = 552446646280519680LLU; // copyu64___ |
13889 | 13778 | break; |
13890 | 13779 | } |
13891 | - case 18446744073709550996LLU: // 999999990T''''''''''''''' | |
13780 | + case 18446744073709550999LLU: // 999999990W''''''''''''''' | |
13892 | 13781 | { |
13893 | 13782 | { |
13894 | 13783 | uint64_t exchange = LOCAL_POP_MOVE(&heap, 22LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 22*/; |
@@ -13917,7 +13806,7 @@ | ||
13917 | 13806 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
13918 | 13807 | } |
13919 | 13808 | // ACCUMULATE ARGUMENTS - END |
13920 | - uint64_t return_to = 18446744073709550995LLU; | |
13809 | + uint64_t return_to = 18446744073709550998LLU; | |
13921 | 13810 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
13922 | 13811 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
13923 | 13812 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -13926,7 +13815,7 @@ | ||
13926 | 13815 | state.addr = 552446646280519680LLU; // copyu64___ |
13927 | 13816 | break; |
13928 | 13817 | } |
13929 | - case 18446744073709550995LLU: // 999999990S''''''''''''''' | |
13818 | + case 18446744073709550998LLU: // 999999990V''''''''''''''' | |
13930 | 13819 | { |
13931 | 13820 | { |
13932 | 13821 | uint64_t exchange = LOCAL_POP_MOVE(&heap, 22LLU, &(heap.data[0].elem1)/*address of current closure*/) /* RELEASE temporary reference at 22*/; |
@@ -13938,7 +13827,7 @@ | ||
13938 | 13827 | } |
13939 | 13828 | } |
13940 | 13829 | // ACCUMULATE ARGUMENTS - END |
13941 | - uint64_t return_to = 18446744073709550998LLU; | |
13830 | + uint64_t return_to = 18446744073709551001LLU; | |
13942 | 13831 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
13943 | 13832 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
13944 | 13833 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -13947,12 +13836,12 @@ | ||
13947 | 13836 | state.addr = 819859607768530944LLU; // resdest___ |
13948 | 13837 | break; |
13949 | 13838 | } |
13950 | - case 18446744073709550998LLU: // 999999990V''''''''''''''' | |
13839 | + case 18446744073709551001LLU: // 999999990Y''''''''''''''' | |
13951 | 13840 | { |
13952 | - state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 20LLU, 19LLU), &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 20LLU, 3LLU)), 8) ? 18446744073709551001LLU : 18446744073709551000LLU; | |
13841 | + state.addr = !list_push_move(&heap, &*LOCAL_ACCESS(heap.data, 20LLU, 19LLU), &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 20LLU, 3LLU)), 8) ? 18446744073709551004LLU : 18446744073709551003LLU; | |
13953 | 13842 | break; |
13954 | 13843 | } |
13955 | - case 18446744073709551001LLU: // 999999990Y''''''''''''''' | |
13844 | + case 18446744073709551004LLU: // 999999990a''''''''''''''' | |
13956 | 13845 | { |
13957 | 13846 | fprintf(stderr, "%s", "pushing par "); |
13958 | 13847 | // ACCUMULATE ARGUMENTS - BEGIN |
@@ -13961,7 +13850,7 @@ | ||
13961 | 13850 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
13962 | 13851 | } |
13963 | 13852 | // ACCUMULATE ARGUMENTS - END |
13964 | - uint64_t return_to = 18446744073709550994LLU; | |
13853 | + uint64_t return_to = 18446744073709550997LLU; | |
13965 | 13854 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
13966 | 13855 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
13967 | 13856 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -13970,7 +13859,7 @@ | ||
13970 | 13859 | state.addr = 819847183518272384LLU; // reportres_ |
13971 | 13860 | break; |
13972 | 13861 | } |
13973 | - case 18446744073709550994LLU: // 999999990R''''''''''''''' | |
13862 | + case 18446744073709550997LLU: // 999999990U''''''''''''''' | |
13974 | 13863 | { |
13975 | 13864 | fprintf(stderr, "%s", "\n"); |
13976 | 13865 | { |
@@ -13984,7 +13873,7 @@ | ||
13984 | 13873 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
13985 | 13874 | } |
13986 | 13875 | // ACCUMULATE ARGUMENTS - END |
13987 | - uint64_t return_to = 18446744073709550993LLU; | |
13876 | + uint64_t return_to = 18446744073709550996LLU; | |
13988 | 13877 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
13989 | 13878 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
13990 | 13879 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -13993,26 +13882,26 @@ | ||
13993 | 13882 | state.addr = 18446744073709551534LLU; // 999999998s''''''''''''''' |
13994 | 13883 | break; |
13995 | 13884 | } |
13996 | - case 18446744073709550993LLU: // 999999990Q''''''''''''''' | |
13885 | + case 18446744073709550996LLU: // 999999990T''''''''''''''' | |
13997 | 13886 | { |
13998 | 13887 | // parameter resdest___ new_______ goes out of scope |
13999 | - state.addr = 18446744073709550999LLU; // 999999990W''''''''''''''' | |
13888 | + state.addr = 18446744073709551002LLU; // 999999990Z''''''''''''''' | |
14000 | 13889 | break; |
14001 | 13890 | } |
14002 | - case 18446744073709551000LLU: // 999999990X''''''''''''''' | |
13891 | + case 18446744073709551003LLU: // 999999990$''''''''''''''' | |
14003 | 13892 | { |
14004 | - state.addr = 18446744073709550999LLU; // 999999990W''''''''''''''' | |
13893 | + state.addr = 18446744073709551002LLU; // 999999990Z''''''''''''''' | |
14005 | 13894 | break; |
14006 | 13895 | } |
14007 | - case 18446744073709550999LLU: // 999999990W''''''''''''''' | |
13896 | + case 18446744073709551002LLU: // 999999990Z''''''''''''''' | |
14008 | 13897 | { |
14009 | 13898 | (void)LOCAL_POP_MOVE(&heap, 20LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 20 |
14010 | 13899 | // parameter-reference resdest___ par_______ goes out of scope |
14011 | 13900 | // parameter-reference list<resdest___> respars1__ goes out of scope |
14012 | - state.addr = 18446744073709551003LLU; // 999999990$''''''''''''''' | |
13901 | + state.addr = 18446744073709551006LLU; // 999999990c''''''''''''''' | |
14013 | 13902 | break; |
14014 | 13903 | } |
14015 | - case 18446744073709551002LLU: // 999999990Z''''''''''''''' | |
13904 | + case 18446744073709551005LLU: // 999999990b''''''''''''''' | |
14016 | 13905 | { |
14017 | 13906 | // parameter-reference u64 safe1_____ goes out of scope |
14018 | 13907 | (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference safe1_____ at 17 |
@@ -14071,10 +13960,10 @@ | ||
14071 | 13960 | uint64_t arg = 0; |
14072 | 13961 | LOCAL_PUSH_MOVE(&heap, 12, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
14073 | 13962 | } |
14074 | - state.addr = 18446744073709550992LLU; // 999999990P''''''''''''''' | |
13963 | + state.addr = 18446744073709550995LLU; // 999999990S''''''''''''''' | |
14075 | 13964 | break; |
14076 | 13965 | } |
14077 | - case 18446744073709550992LLU: // 999999990P''''''''''''''' | |
13966 | + case 18446744073709550995LLU: // 999999990S''''''''''''''' | |
14078 | 13967 | { |
14079 | 13968 | if(!*LOCAL_ACCESS(heap.data, 13LLU, 11LLU)) |
14080 | 13969 | { |
@@ -14081,7 +13970,7 @@ | ||
14081 | 13970 | (void)LOCAL_POP_MOVE(&heap, 13LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 13 |
14082 | 13971 | (void)LOCAL_POP_MOVE(&heap, 12LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 12 |
14083 | 13972 | { |
14084 | - state.addr = 18446744073709550991LLU; // 999999990O''''''''''''''' | |
13973 | + state.addr = 18446744073709550994LLU; // 999999990R''''''''''''''' | |
14085 | 13974 | break; |
14086 | 13975 | } |
14087 | 13976 | } |
@@ -14092,11 +13981,11 @@ | ||
14092 | 13981 | LOCAL_PUSH_MOVE(&heap, 13, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
14093 | 13982 | } |
14094 | 13983 | *LOCAL_ACCESS(heap.data, 14LLU, 13LLU) = /*id________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 14LLU, 2LLU)) == /*elem______*/*access_heap(heap.data, tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 14LLU, 12LLU), 0LLU)); |
14095 | - state.addr = *LOCAL_ACCESS(heap.data, 14LLU, 13LLU) ? 18446744073709550990LLU : 18446744073709550989LLU; | |
13984 | + state.addr = *LOCAL_ACCESS(heap.data, 14LLU, 13LLU) ? 18446744073709550993LLU : 18446744073709550992LLU; | |
14096 | 13985 | (void)LOCAL_POP_MOVE(&heap, 14LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 14 |
14097 | 13986 | break; |
14098 | 13987 | } |
14099 | - case 18446744073709550990LLU: // 999999990N''''''''''''''' | |
13988 | + case 18446744073709550993LLU: // 999999990Q''''''''''''''' | |
14100 | 13989 | { |
14101 | 13990 | |
14102 | 13991 | *LOCAL_ACCESS(heap.data, 13LLU, 10LLU) = 0; |
@@ -14142,7 +14031,7 @@ | ||
14142 | 14031 | LOCAL_PUSH_MOVE(&heap, 9LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
14143 | 14032 | } |
14144 | 14033 | // ACCUMULATE ARGUMENTS - END |
14145 | - uint64_t return_to = 18446744073709550988LLU; | |
14034 | + uint64_t return_to = 18446744073709550991LLU; | |
14146 | 14035 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 10LLU, 0/*address of closure-in-construction*/, 0)); |
14147 | 14036 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
14148 | 14037 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 10LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -14151,19 +14040,19 @@ | ||
14151 | 14040 | state.addr = 567602031870732672LLU; // defunpack_ |
14152 | 14041 | break; |
14153 | 14042 | } |
14154 | - case 18446744073709550988LLU: // 999999990L''''''''''''''' | |
14043 | + case 18446744073709550991LLU: // 999999990O''''''''''''''' | |
14155 | 14044 | { |
14156 | - state.addr = 18446744073709550989LLU; // 999999990M''''''''''''''' | |
14045 | + state.addr = 18446744073709550992LLU; // 999999990P''''''''''''''' | |
14157 | 14046 | break; |
14158 | 14047 | } |
14159 | - case 18446744073709550989LLU: // 999999990M''''''''''''''' | |
14048 | + case 18446744073709550992LLU: // 999999990P''''''''''''''' | |
14160 | 14049 | { |
14161 | 14050 | // parameter-reference defidfn___ elem______ goes out of scope |
14162 | 14051 | // parameter-reference list<defidfn___> fndefs____ goes out of scope |
14163 | - state.addr = 18446744073709550992LLU; // 999999990P''''''''''''''' | |
14052 | + state.addr = 18446744073709550995LLU; // 999999990S''''''''''''''' | |
14164 | 14053 | break; |
14165 | 14054 | } |
14166 | - case 18446744073709550991LLU: // 999999990O''''''''''''''' | |
14055 | + case 18446744073709550994LLU: // 999999990R''''''''''''''' | |
14167 | 14056 | { |
14168 | 14057 | { |
14169 | 14058 | uint64_t arg = 0; |
@@ -14170,11 +14059,11 @@ | ||
14170 | 14059 | LOCAL_PUSH_MOVE(&heap, 11, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
14171 | 14060 | } |
14172 | 14061 | *LOCAL_ACCESS(heap.data, 12LLU, 11LLU) = /*notfound__*/*LOCAL_ACCESS(heap.data, 12LLU, 10LLU); |
14173 | - state.addr = *LOCAL_ACCESS(heap.data, 12LLU, 11LLU) ? 18446744073709550987LLU : 18446744073709550986LLU; | |
14062 | + state.addr = *LOCAL_ACCESS(heap.data, 12LLU, 11LLU) ? 18446744073709550990LLU : 18446744073709550989LLU; | |
14174 | 14063 | (void)LOCAL_POP_MOVE(&heap, 12LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 12 |
14175 | 14064 | break; |
14176 | 14065 | } |
14177 | - case 18446744073709550987LLU: // 999999990K''''''''''''''' | |
14066 | + case 18446744073709550990LLU: // 999999990N''''''''''''''' | |
14178 | 14067 | { |
14179 | 14068 | // ACCUMULATE ARGUMENTS - BEGIN |
14180 | 14069 | { |
@@ -14186,7 +14075,7 @@ | ||
14186 | 14075 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
14187 | 14076 | } |
14188 | 14077 | // ACCUMULATE ARGUMENTS - END |
14189 | - uint64_t return_to = 18446744073709550985LLU; | |
14078 | + uint64_t return_to = 18446744073709550988LLU; | |
14190 | 14079 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
14191 | 14080 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
14192 | 14081 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -14195,7 +14084,7 @@ | ||
14195 | 14084 | state.addr = 819847183514601582LLU; // reportdefs |
14196 | 14085 | break; |
14197 | 14086 | } |
14198 | - case 18446744073709550985LLU: // 999999990I''''''''''''''' | |
14087 | + case 18446744073709550988LLU: // 999999990L''''''''''''''' | |
14199 | 14088 | { |
14200 | 14089 | // ACCUMULATE ARGUMENTS - BEGIN |
14201 | 14090 | { |
@@ -14203,7 +14092,7 @@ | ||
14203 | 14092 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
14204 | 14093 | } |
14205 | 14094 | // ACCUMULATE ARGUMENTS - END |
14206 | - uint64_t return_to = 18446744073709550984LLU; | |
14095 | + uint64_t return_to = 18446744073709550987LLU; | |
14207 | 14096 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
14208 | 14097 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
14209 | 14098 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -14212,7 +14101,7 @@ | ||
14212 | 14101 | state.addr = 819847183515949359LLU; // reportinit |
14213 | 14102 | break; |
14214 | 14103 | } |
14215 | - case 18446744073709550984LLU: // 999999990H''''''''''''''' | |
14104 | + case 18446744073709550987LLU: // 999999990K''''''''''''''' | |
14216 | 14105 | { |
14217 | 14106 | fprintf(stderr, "%s", "no such function "); |
14218 | 14107 | printid(stderr, /*id________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 11LLU, 2LLU))); |
@@ -14220,10 +14109,10 @@ | ||
14220 | 14109 | fprintf(stderr, "%s\n", ""); |
14221 | 14110 | exit(-1); |
14222 | 14111 | } |
14223 | - state.addr = 18446744073709550986LLU; // 999999990J''''''''''''''' | |
14112 | + state.addr = 18446744073709550989LLU; // 999999990M''''''''''''''' | |
14224 | 14113 | break; |
14225 | 14114 | } |
14226 | - case 18446744073709550986LLU: // 999999990J''''''''''''''' | |
14115 | + case 18446744073709550989LLU: // 999999990M''''''''''''''' | |
14227 | 14116 | { |
14228 | 14117 | // variable u64 notfound__ goes out of scope |
14229 | 14118 | // emitted destructur for type u64 |
@@ -14271,10 +14160,10 @@ | ||
14271 | 14160 | uint64_t arg = 0; |
14272 | 14161 | LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
14273 | 14162 | } |
14274 | - state.addr = 18446744073709550983LLU; // 999999990G''''''''''''''' | |
14163 | + state.addr = 18446744073709550986LLU; // 999999990J''''''''''''''' | |
14275 | 14164 | break; |
14276 | 14165 | } |
14277 | - case 18446744073709550983LLU: // 999999990G''''''''''''''' | |
14166 | + case 18446744073709550986LLU: // 999999990J''''''''''''''' | |
14278 | 14167 | { |
14279 | 14168 | if(!*LOCAL_ACCESS(heap.data, 7LLU, 5LLU)) |
14280 | 14169 | { |
@@ -14281,7 +14170,7 @@ | ||
14281 | 14170 | (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 7 |
14282 | 14171 | (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 6 |
14283 | 14172 | { |
14284 | - state.addr = 18446744073709550982LLU; // 999999990F''''''''''''''' | |
14173 | + state.addr = 18446744073709550985LLU; // 999999990I''''''''''''''' | |
14285 | 14174 | break; |
14286 | 14175 | } |
14287 | 14176 | } |
@@ -14292,11 +14181,11 @@ | ||
14292 | 14181 | LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
14293 | 14182 | } |
14294 | 14183 | *LOCAL_ACCESS(heap.data, 8LLU, 7LLU) = /*id________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 8LLU, 3LLU)) == /*elem______*/*access_heap(heap.data, tree_elem_addr(heap.data, 3LLU, *LOCAL_ACCESS(heap.data, 8LLU, 6LLU), 0LLU)); |
14295 | - state.addr = *LOCAL_ACCESS(heap.data, 8LLU, 7LLU) ? 18446744073709550981LLU : 18446744073709550980LLU; | |
14184 | + state.addr = *LOCAL_ACCESS(heap.data, 8LLU, 7LLU) ? 18446744073709550984LLU : 18446744073709550983LLU; | |
14296 | 14185 | (void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 8 |
14297 | 14186 | break; |
14298 | 14187 | } |
14299 | - case 18446744073709550981LLU: // 999999990E''''''''''''''' | |
14188 | + case 18446744073709550984LLU: // 999999990H''''''''''''''' | |
14300 | 14189 | { |
14301 | 14190 | |
14302 | 14191 | *LOCAL_ACCESS(heap.data, 7LLU, 4LLU) = 0; |
@@ -14314,7 +14203,7 @@ | ||
14314 | 14203 | LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
14315 | 14204 | } |
14316 | 14205 | // ACCUMULATE ARGUMENTS - END |
14317 | - uint64_t return_to = 18446744073709550979LLU; | |
14206 | + uint64_t return_to = 18446744073709550982LLU; | |
14318 | 14207 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)); |
14319 | 14208 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
14320 | 14209 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -14323,19 +14212,19 @@ | ||
14323 | 14212 | state.addr = 606150499514712064LLU; // fncopy____ |
14324 | 14213 | break; |
14325 | 14214 | } |
14326 | - case 18446744073709550979LLU: // 999999990C''''''''''''''' | |
14215 | + case 18446744073709550982LLU: // 999999990F''''''''''''''' | |
14327 | 14216 | { |
14328 | - state.addr = 18446744073709550980LLU; // 999999990D''''''''''''''' | |
14217 | + state.addr = 18446744073709550983LLU; // 999999990G''''''''''''''' | |
14329 | 14218 | break; |
14330 | 14219 | } |
14331 | - case 18446744073709550980LLU: // 999999990D''''''''''''''' | |
14220 | + case 18446744073709550983LLU: // 999999990G''''''''''''''' | |
14332 | 14221 | { |
14333 | 14222 | // parameter-reference defidfn___ elem______ goes out of scope |
14334 | 14223 | // parameter-reference list<defidfn___> fndefs____ goes out of scope |
14335 | - state.addr = 18446744073709550983LLU; // 999999990G''''''''''''''' | |
14224 | + state.addr = 18446744073709550986LLU; // 999999990J''''''''''''''' | |
14336 | 14225 | break; |
14337 | 14226 | } |
14338 | - case 18446744073709550982LLU: // 999999990F''''''''''''''' | |
14227 | + case 18446744073709550985LLU: // 999999990I''''''''''''''' | |
14339 | 14228 | { |
14340 | 14229 | { |
14341 | 14230 | uint64_t arg = 0; |
@@ -14342,11 +14231,11 @@ | ||
14342 | 14231 | LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
14343 | 14232 | } |
14344 | 14233 | *LOCAL_ACCESS(heap.data, 6LLU, 5LLU) = /*notfound__*/*LOCAL_ACCESS(heap.data, 6LLU, 4LLU); |
14345 | - state.addr = *LOCAL_ACCESS(heap.data, 6LLU, 5LLU) ? 18446744073709550978LLU : 18446744073709550977LLU; | |
14234 | + state.addr = *LOCAL_ACCESS(heap.data, 6LLU, 5LLU) ? 18446744073709550981LLU : 18446744073709550980LLU; | |
14346 | 14235 | (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 6 |
14347 | 14236 | break; |
14348 | 14237 | } |
14349 | - case 18446744073709550978LLU: // 999999990B''''''''''''''' | |
14238 | + case 18446744073709550981LLU: // 999999990E''''''''''''''' | |
14350 | 14239 | { |
14351 | 14240 | // ACCUMULATE ARGUMENTS - BEGIN |
14352 | 14241 | { |
@@ -14358,7 +14247,7 @@ | ||
14358 | 14247 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
14359 | 14248 | } |
14360 | 14249 | // ACCUMULATE ARGUMENTS - END |
14361 | - uint64_t return_to = 18446744073709550976LLU; | |
14250 | + uint64_t return_to = 18446744073709550979LLU; | |
14362 | 14251 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
14363 | 14252 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
14364 | 14253 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -14367,7 +14256,7 @@ | ||
14367 | 14256 | state.addr = 819847183514601582LLU; // reportdefs |
14368 | 14257 | break; |
14369 | 14258 | } |
14370 | - case 18446744073709550976LLU: // 999999990_''''''''''''''' | |
14259 | + case 18446744073709550979LLU: // 999999990C''''''''''''''' | |
14371 | 14260 | { |
14372 | 14261 | // ACCUMULATE ARGUMENTS - BEGIN |
14373 | 14262 | { |
@@ -14375,7 +14264,7 @@ | ||
14375 | 14264 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
14376 | 14265 | } |
14377 | 14266 | // ACCUMULATE ARGUMENTS - END |
14378 | - uint64_t return_to = 18446744073709550975LLU; | |
14267 | + uint64_t return_to = 18446744073709550978LLU; | |
14379 | 14268 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
14380 | 14269 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
14381 | 14270 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -14384,7 +14273,7 @@ | ||
14384 | 14273 | state.addr = 819847183515949359LLU; // reportinit |
14385 | 14274 | break; |
14386 | 14275 | } |
14387 | - case 18446744073709550975LLU: // 99999999z9''''''''''''''' | |
14276 | + case 18446744073709550978LLU: // 999999990B''''''''''''''' | |
14388 | 14277 | { |
14389 | 14278 | fprintf(stderr, "%s", "no such function "); |
14390 | 14279 | printid(stderr, /*id________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 3LLU))); |
@@ -14392,10 +14281,10 @@ | ||
14392 | 14281 | fprintf(stderr, "%s\n", ""); |
14393 | 14282 | exit(-1); |
14394 | 14283 | } |
14395 | - state.addr = 18446744073709550977LLU; // 999999990A''''''''''''''' | |
14284 | + state.addr = 18446744073709550980LLU; // 999999990D''''''''''''''' | |
14396 | 14285 | break; |
14397 | 14286 | } |
14398 | - case 18446744073709550977LLU: // 999999990A''''''''''''''' | |
14287 | + case 18446744073709550980LLU: // 999999990D''''''''''''''' | |
14399 | 14288 | { |
14400 | 14289 | // variable u64 notfound__ goes out of scope |
14401 | 14290 | // emitted destructur for type u64 |
@@ -14431,10 +14320,10 @@ | ||
14431 | 14320 | uint64_t arg = 0; |
14432 | 14321 | LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
14433 | 14322 | } |
14434 | - state.addr = 18446744073709550974LLU; // 99999999z8''''''''''''''' | |
14323 | + state.addr = 18446744073709550977LLU; // 999999990A''''''''''''''' | |
14435 | 14324 | break; |
14436 | 14325 | } |
14437 | - case 18446744073709550974LLU: // 99999999z8''''''''''''''' | |
14326 | + case 18446744073709550977LLU: // 999999990A''''''''''''''' | |
14438 | 14327 | { |
14439 | 14328 | if(!*LOCAL_ACCESS(heap.data, 7LLU, 5LLU)) |
14440 | 14329 | { |
@@ -14441,7 +14330,7 @@ | ||
14441 | 14330 | (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 7 |
14442 | 14331 | (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 6 |
14443 | 14332 | { |
14444 | - state.addr = 18446744073709550973LLU; // 99999999z7''''''''''''''' | |
14333 | + state.addr = 18446744073709550976LLU; // 999999990_''''''''''''''' | |
14445 | 14334 | break; |
14446 | 14335 | } |
14447 | 14336 | } |
@@ -14452,11 +14341,11 @@ | ||
14452 | 14341 | LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
14453 | 14342 | } |
14454 | 14343 | *LOCAL_ACCESS(heap.data, 8LLU, 7LLU) = /*notfound__*/*LOCAL_ACCESS(heap.data, 8LLU, 4LLU); |
14455 | - state.addr = *LOCAL_ACCESS(heap.data, 8LLU, 7LLU) ? 18446744073709550972LLU : 18446744073709550971LLU; | |
14344 | + state.addr = *LOCAL_ACCESS(heap.data, 8LLU, 7LLU) ? 18446744073709550975LLU : 18446744073709550974LLU; | |
14456 | 14345 | (void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 8 |
14457 | 14346 | break; |
14458 | 14347 | } |
14459 | - case 18446744073709550972LLU: // 99999999z6''''''''''''''' | |
14348 | + case 18446744073709550975LLU: // 99999999z9''''''''''''''' | |
14460 | 14349 | { |
14461 | 14350 | { |
14462 | 14351 | uint64_t arg = 0; |
@@ -14463,11 +14352,11 @@ | ||
14463 | 14352 | LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
14464 | 14353 | } |
14465 | 14354 | *LOCAL_ACCESS(heap.data, 8LLU, 7LLU) = /*id________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 8LLU, 3LLU)) == /*elem______*/*access_heap(heap.data, tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 8LLU, 6LLU), 0LLU)); |
14466 | - state.addr = *LOCAL_ACCESS(heap.data, 8LLU, 7LLU) ? 18446744073709550970LLU : 18446744073709550969LLU; | |
14355 | + state.addr = *LOCAL_ACCESS(heap.data, 8LLU, 7LLU) ? 18446744073709550973LLU : 18446744073709550972LLU; | |
14467 | 14356 | (void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 8 |
14468 | 14357 | break; |
14469 | 14358 | } |
14470 | - case 18446744073709550970LLU: // 99999999z4''''''''''''''' | |
14359 | + case 18446744073709550973LLU: // 99999999z7''''''''''''''' | |
14471 | 14360 | { |
14472 | 14361 | |
14473 | 14362 | *LOCAL_ACCESS(heap.data, 7LLU, 4LLU) = 0; |
@@ -14479,16 +14368,16 @@ | ||
14479 | 14368 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
14480 | 14369 | } |
14481 | 14370 | // ACCUMULATE ARGUMENTS - END |
14482 | - uint64_t return_to = 18446744073709550968LLU; | |
14371 | + uint64_t return_to = 18446744073709550971LLU; | |
14483 | 14372 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
14484 | 14373 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
14485 | 14374 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
14486 | 14375 | heap.data[0].elem1 = heap.data[0].elem0; |
14487 | 14376 | heap.data[0].elem0 = restore; |
14488 | - state.addr = 18446744073709551160LLU; // 9999999922''''''''''''''' | |
14377 | + state.addr = 18446744073709551163LLU; // 9999999925''''''''''''''' | |
14489 | 14378 | break; |
14490 | 14379 | } |
14491 | - case 18446744073709550968LLU: // 99999999z2''''''''''''''' | |
14380 | + case 18446744073709550971LLU: // 99999999z5''''''''''''''' | |
14492 | 14381 | { |
14493 | 14382 | // ACCUMULATE ARGUMENTS - BEGIN |
14494 | 14383 | { |
@@ -14500,7 +14389,7 @@ | ||
14500 | 14389 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
14501 | 14390 | } |
14502 | 14391 | // ACCUMULATE ARGUMENTS - END |
14503 | - uint64_t return_to = 18446744073709550967LLU; | |
14392 | + uint64_t return_to = 18446744073709550970LLU; | |
14504 | 14393 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
14505 | 14394 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
14506 | 14395 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -14509,24 +14398,24 @@ | ||
14509 | 14398 | state.addr = 58638376207779904LLU; // CPTypeDef_ |
14510 | 14399 | break; |
14511 | 14400 | } |
14512 | - case 18446744073709550967LLU: // 99999999z1''''''''''''''' | |
14401 | + case 18446744073709550970LLU: // 99999999z4''''''''''''''' | |
14513 | 14402 | { |
14514 | - state.addr = 18446744073709550969LLU; // 99999999z3''''''''''''''' | |
14403 | + state.addr = 18446744073709550972LLU; // 99999999z6''''''''''''''' | |
14515 | 14404 | break; |
14516 | 14405 | } |
14517 | - case 18446744073709550969LLU: // 99999999z3''''''''''''''' | |
14406 | + case 18446744073709550972LLU: // 99999999z6''''''''''''''' | |
14518 | 14407 | { |
14519 | - state.addr = 18446744073709550971LLU; // 99999999z5''''''''''''''' | |
14408 | + state.addr = 18446744073709550974LLU; // 99999999z8''''''''''''''' | |
14520 | 14409 | break; |
14521 | 14410 | } |
14522 | - case 18446744073709550971LLU: // 99999999z5''''''''''''''' | |
14411 | + case 18446744073709550974LLU: // 99999999z8''''''''''''''' | |
14523 | 14412 | { |
14524 | 14413 | // parameter-reference typedef___ elem______ goes out of scope |
14525 | 14414 | // parameter-reference list<typedef___> typedefs__ goes out of scope |
14526 | - state.addr = 18446744073709550974LLU; // 99999999z8''''''''''''''' | |
14415 | + state.addr = 18446744073709550977LLU; // 999999990A''''''''''''''' | |
14527 | 14416 | break; |
14528 | 14417 | } |
14529 | - case 18446744073709550973LLU: // 99999999z7''''''''''''''' | |
14418 | + case 18446744073709550976LLU: // 999999990_''''''''''''''' | |
14530 | 14419 | { |
14531 | 14420 | { |
14532 | 14421 | uint64_t arg = 0; |
@@ -14533,11 +14422,11 @@ | ||
14533 | 14422 | LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
14534 | 14423 | } |
14535 | 14424 | *LOCAL_ACCESS(heap.data, 6LLU, 5LLU) = /*notfound__*/*LOCAL_ACCESS(heap.data, 6LLU, 4LLU); |
14536 | - state.addr = *LOCAL_ACCESS(heap.data, 6LLU, 5LLU) ? 18446744073709550966LLU : 18446744073709550965LLU; | |
14425 | + state.addr = *LOCAL_ACCESS(heap.data, 6LLU, 5LLU) ? 18446744073709550969LLU : 18446744073709550968LLU; | |
14537 | 14426 | (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 6 |
14538 | 14427 | break; |
14539 | 14428 | } |
14540 | - case 18446744073709550966LLU: // 99999999z0''''''''''''''' | |
14429 | + case 18446744073709550969LLU: // 99999999z3''''''''''''''' | |
14541 | 14430 | { |
14542 | 14431 | // ACCUMULATE ARGUMENTS - BEGIN |
14543 | 14432 | { |
@@ -14549,7 +14438,7 @@ | ||
14549 | 14438 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
14550 | 14439 | } |
14551 | 14440 | // ACCUMULATE ARGUMENTS - END |
14552 | - uint64_t return_to = 18446744073709550964LLU; | |
14441 | + uint64_t return_to = 18446744073709550967LLU; | |
14553 | 14442 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
14554 | 14443 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
14555 | 14444 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -14558,7 +14447,7 @@ | ||
14558 | 14447 | state.addr = 819847183518878446LLU; // reporttyps |
14559 | 14448 | break; |
14560 | 14449 | } |
14561 | - case 18446744073709550964LLU: // 99999999zy''''''''''''''' | |
14450 | + case 18446744073709550967LLU: // 99999999z1''''''''''''''' | |
14562 | 14451 | { |
14563 | 14452 | // ACCUMULATE ARGUMENTS - BEGIN |
14564 | 14453 | { |
@@ -14566,7 +14455,7 @@ | ||
14566 | 14455 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
14567 | 14456 | } |
14568 | 14457 | // ACCUMULATE ARGUMENTS - END |
14569 | - uint64_t return_to = 18446744073709550963LLU; | |
14458 | + uint64_t return_to = 18446744073709550966LLU; | |
14570 | 14459 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
14571 | 14460 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
14572 | 14461 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -14575,7 +14464,7 @@ | ||
14575 | 14464 | state.addr = 819847183515949359LLU; // reportinit |
14576 | 14465 | break; |
14577 | 14466 | } |
14578 | - case 18446744073709550963LLU: // 99999999zx''''''''''''''' | |
14467 | + case 18446744073709550966LLU: // 99999999z0''''''''''''''' | |
14579 | 14468 | { |
14580 | 14469 | fprintf(stderr, "%s", "no such type "); |
14581 | 14470 | printid(stderr, /*id________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 3LLU))); |
@@ -14583,10 +14472,10 @@ | ||
14583 | 14472 | fprintf(stderr, "%s\n", ""); |
14584 | 14473 | exit(-1); |
14585 | 14474 | } |
14586 | - state.addr = 18446744073709550965LLU; // 99999999zz''''''''''''''' | |
14475 | + state.addr = 18446744073709550968LLU; // 99999999z2''''''''''''''' | |
14587 | 14476 | break; |
14588 | 14477 | } |
14589 | - case 18446744073709550965LLU: // 99999999zz''''''''''''''' | |
14478 | + case 18446744073709550968LLU: // 99999999z2''''''''''''''' | |
14590 | 14479 | { |
14591 | 14480 | // variable u64 notfound__ goes out of scope |
14592 | 14481 | // emitted destructur for type u64 |
@@ -14627,7 +14516,7 @@ | ||
14627 | 14516 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
14628 | 14517 | } |
14629 | 14518 | // ACCUMULATE ARGUMENTS - END |
14630 | - uint64_t return_to = 18446744073709550962LLU; | |
14519 | + uint64_t return_to = 18446744073709550965LLU; | |
14631 | 14520 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
14632 | 14521 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
14633 | 14522 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -14636,7 +14525,7 @@ | ||
14636 | 14525 | state.addr = 857578368147320832LLU; // tkstruct__ |
14637 | 14526 | break; |
14638 | 14527 | } |
14639 | - case 18446744073709550962LLU: // 99999999zw''''''''''''''' | |
14528 | + case 18446744073709550965LLU: // 99999999zz''''''''''''''' | |
14640 | 14529 | { |
14641 | 14530 | // variable list<elemdef___> defpars___ goes out of scope |
14642 | 14531 | // (uninitialized -> no destructor-call) |
@@ -14654,10 +14543,10 @@ | ||
14654 | 14543 | uint64_t arg = 0; |
14655 | 14544 | LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
14656 | 14545 | } |
14657 | - state.addr = 18446744073709550961LLU; // 99999999zv''''''''''''''' | |
14546 | + state.addr = 18446744073709550964LLU; // 99999999zy''''''''''''''' | |
14658 | 14547 | break; |
14659 | 14548 | } |
14660 | - case 18446744073709550961LLU: // 99999999zv''''''''''''''' | |
14549 | + case 18446744073709550964LLU: // 99999999zy''''''''''''''' | |
14661 | 14550 | { |
14662 | 14551 | if(!*LOCAL_ACCESS(heap.data, 8LLU, 6LLU)) |
14663 | 14552 | { |
@@ -14664,7 +14553,7 @@ | ||
14664 | 14553 | (void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 8 |
14665 | 14554 | (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 7 |
14666 | 14555 | { |
14667 | - state.addr = 18446744073709550960LLU; // 99999999zu''''''''''''''' | |
14556 | + state.addr = 18446744073709550963LLU; // 99999999zx''''''''''''''' | |
14668 | 14557 | break; |
14669 | 14558 | } |
14670 | 14559 | } |
@@ -14675,11 +14564,11 @@ | ||
14675 | 14564 | LOCAL_PUSH_MOVE(&heap, 8, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
14676 | 14565 | } |
14677 | 14566 | *LOCAL_ACCESS(heap.data, 9LLU, 8LLU) = /*notfound__*/*LOCAL_ACCESS(heap.data, 9LLU, 5LLU); |
14678 | - state.addr = *LOCAL_ACCESS(heap.data, 9LLU, 8LLU) ? 18446744073709550959LLU : 18446744073709550958LLU; | |
14567 | + state.addr = *LOCAL_ACCESS(heap.data, 9LLU, 8LLU) ? 18446744073709550962LLU : 18446744073709550961LLU; | |
14679 | 14568 | (void)LOCAL_POP_MOVE(&heap, 9LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 9 |
14680 | 14569 | break; |
14681 | 14570 | } |
14682 | - case 18446744073709550959LLU: // 99999999zt''''''''''''''' | |
14571 | + case 18446744073709550962LLU: // 99999999zw''''''''''''''' | |
14683 | 14572 | { |
14684 | 14573 | { |
14685 | 14574 | uint64_t arg = 0; |
@@ -14686,11 +14575,11 @@ | ||
14686 | 14575 | LOCAL_PUSH_MOVE(&heap, 8, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
14687 | 14576 | } |
14688 | 14577 | *LOCAL_ACCESS(heap.data, 9LLU, 8LLU) = /*id________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 9LLU, 3LLU)) == /*elem______*/*access_heap(heap.data, tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 9LLU, 7LLU), 0LLU)); |
14689 | - state.addr = *LOCAL_ACCESS(heap.data, 9LLU, 8LLU) ? 18446744073709550957LLU : 18446744073709550956LLU; | |
14578 | + state.addr = *LOCAL_ACCESS(heap.data, 9LLU, 8LLU) ? 18446744073709550960LLU : 18446744073709550959LLU; | |
14690 | 14579 | (void)LOCAL_POP_MOVE(&heap, 9LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 9 |
14691 | 14580 | break; |
14692 | 14581 | } |
14693 | - case 18446744073709550957LLU: // 99999999zr''''''''''''''' | |
14582 | + case 18446744073709550960LLU: // 99999999zu''''''''''''''' | |
14694 | 14583 | { |
14695 | 14584 | |
14696 | 14585 | *LOCAL_ACCESS(heap.data, 8LLU, 5LLU) = 0; |
@@ -14702,16 +14591,16 @@ | ||
14702 | 14591 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
14703 | 14592 | } |
14704 | 14593 | // ACCUMULATE ARGUMENTS - END |
14705 | - uint64_t return_to = 18446744073709550955LLU; | |
14594 | + uint64_t return_to = 18446744073709550958LLU; | |
14706 | 14595 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
14707 | 14596 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
14708 | 14597 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
14709 | 14598 | heap.data[0].elem1 = heap.data[0].elem0; |
14710 | 14599 | heap.data[0].elem0 = restore; |
14711 | - state.addr = 18446744073709551200LLU; // 999999993e''''''''''''''' | |
14600 | + state.addr = 18446744073709551203LLU; // 999999993h''''''''''''''' | |
14712 | 14601 | break; |
14713 | 14602 | } |
14714 | - case 18446744073709550955LLU: // 99999999zp''''''''''''''' | |
14603 | + case 18446744073709550958LLU: // 99999999zs''''''''''''''' | |
14715 | 14604 | { |
14716 | 14605 | // ACCUMULATE ARGUMENTS - BEGIN |
14717 | 14606 | { |
@@ -14723,7 +14612,7 @@ | ||
14723 | 14612 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
14724 | 14613 | } |
14725 | 14614 | // ACCUMULATE ARGUMENTS - END |
14726 | - uint64_t return_to = 18446744073709550954LLU; | |
14615 | + uint64_t return_to = 18446744073709550957LLU; | |
14727 | 14616 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
14728 | 14617 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
14729 | 14618 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -14732,24 +14621,24 @@ | ||
14732 | 14621 | state.addr = 66057855622447104LLU; // CopyTK____ |
14733 | 14622 | break; |
14734 | 14623 | } |
14735 | - case 18446744073709550954LLU: // 99999999zo''''''''''''''' | |
14624 | + case 18446744073709550957LLU: // 99999999zr''''''''''''''' | |
14736 | 14625 | { |
14737 | - state.addr = 18446744073709550956LLU; // 99999999zq''''''''''''''' | |
14626 | + state.addr = 18446744073709550959LLU; // 99999999zt''''''''''''''' | |
14738 | 14627 | break; |
14739 | 14628 | } |
14740 | - case 18446744073709550956LLU: // 99999999zq''''''''''''''' | |
14629 | + case 18446744073709550959LLU: // 99999999zt''''''''''''''' | |
14741 | 14630 | { |
14742 | - state.addr = 18446744073709550958LLU; // 99999999zs''''''''''''''' | |
14631 | + state.addr = 18446744073709550961LLU; // 99999999zv''''''''''''''' | |
14743 | 14632 | break; |
14744 | 14633 | } |
14745 | - case 18446744073709550958LLU: // 99999999zs''''''''''''''' | |
14634 | + case 18446744073709550961LLU: // 99999999zv''''''''''''''' | |
14746 | 14635 | { |
14747 | 14636 | // parameter-reference typedef___ elem______ goes out of scope |
14748 | 14637 | // parameter-reference list<typedef___> typedefs__ goes out of scope |
14749 | - state.addr = 18446744073709550961LLU; // 99999999zv''''''''''''''' | |
14638 | + state.addr = 18446744073709550964LLU; // 99999999zy''''''''''''''' | |
14750 | 14639 | break; |
14751 | 14640 | } |
14752 | - case 18446744073709550960LLU: // 99999999zu''''''''''''''' | |
14641 | + case 18446744073709550963LLU: // 99999999zx''''''''''''''' | |
14753 | 14642 | { |
14754 | 14643 | { |
14755 | 14644 | uint64_t arg = 0; |
@@ -14756,11 +14645,11 @@ | ||
14756 | 14645 | LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
14757 | 14646 | } |
14758 | 14647 | *LOCAL_ACCESS(heap.data, 7LLU, 6LLU) = /*notfound__*/*LOCAL_ACCESS(heap.data, 7LLU, 5LLU); |
14759 | - state.addr = *LOCAL_ACCESS(heap.data, 7LLU, 6LLU) ? 18446744073709550953LLU : 18446744073709550952LLU; | |
14648 | + state.addr = *LOCAL_ACCESS(heap.data, 7LLU, 6LLU) ? 18446744073709550956LLU : 18446744073709550955LLU; | |
14760 | 14649 | (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 7 |
14761 | 14650 | break; |
14762 | 14651 | } |
14763 | - case 18446744073709550953LLU: // 99999999zn''''''''''''''' | |
14652 | + case 18446744073709550956LLU: // 99999999zq''''''''''''''' | |
14764 | 14653 | { |
14765 | 14654 | // ACCUMULATE ARGUMENTS - BEGIN |
14766 | 14655 | { |
@@ -14772,7 +14661,7 @@ | ||
14772 | 14661 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
14773 | 14662 | } |
14774 | 14663 | // ACCUMULATE ARGUMENTS - END |
14775 | - uint64_t return_to = 18446744073709550951LLU; | |
14664 | + uint64_t return_to = 18446744073709550954LLU; | |
14776 | 14665 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
14777 | 14666 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
14778 | 14667 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -14781,7 +14670,7 @@ | ||
14781 | 14670 | state.addr = 819847183518878446LLU; // reporttyps |
14782 | 14671 | break; |
14783 | 14672 | } |
14784 | - case 18446744073709550951LLU: // 99999999zl''''''''''''''' | |
14673 | + case 18446744073709550954LLU: // 99999999zo''''''''''''''' | |
14785 | 14674 | { |
14786 | 14675 | // ACCUMULATE ARGUMENTS - BEGIN |
14787 | 14676 | { |
@@ -14789,7 +14678,7 @@ | ||
14789 | 14678 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
14790 | 14679 | } |
14791 | 14680 | // ACCUMULATE ARGUMENTS - END |
14792 | - uint64_t return_to = 18446744073709550950LLU; | |
14681 | + uint64_t return_to = 18446744073709550953LLU; | |
14793 | 14682 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
14794 | 14683 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
14795 | 14684 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -14798,7 +14687,7 @@ | ||
14798 | 14687 | state.addr = 819847183515949359LLU; // reportinit |
14799 | 14688 | break; |
14800 | 14689 | } |
14801 | - case 18446744073709550950LLU: // 99999999zk''''''''''''''' | |
14690 | + case 18446744073709550953LLU: // 99999999zn''''''''''''''' | |
14802 | 14691 | { |
14803 | 14692 | fprintf(stderr, "%s", "no such type "); |
14804 | 14693 | printid(stderr, /*id________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 6LLU, 3LLU))); |
@@ -14806,10 +14695,10 @@ | ||
14806 | 14695 | fprintf(stderr, "%s\n", ""); |
14807 | 14696 | exit(-1); |
14808 | 14697 | } |
14809 | - state.addr = 18446744073709550952LLU; // 99999999zm''''''''''''''' | |
14698 | + state.addr = 18446744073709550955LLU; // 99999999zp''''''''''''''' | |
14810 | 14699 | break; |
14811 | 14700 | } |
14812 | - case 18446744073709550952LLU: // 99999999zm''''''''''''''' | |
14701 | + case 18446744073709550955LLU: // 99999999zp''''''''''''''' | |
14813 | 14702 | { |
14814 | 14703 | swap(&*LOCAL_ACCESS(heap.data, 6LLU, 4LLU), &*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 6LLU, 0LLU))); // result |
14815 | 14704 | // variable u64 notfound__ goes out of scope |
@@ -14850,10 +14739,10 @@ | ||
14850 | 14739 | uint64_t arg = 0; |
14851 | 14740 | LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
14852 | 14741 | } |
14853 | - state.addr = 18446744073709550949LLU; // 99999999zj''''''''''''''' | |
14742 | + state.addr = 18446744073709550952LLU; // 99999999zm''''''''''''''' | |
14854 | 14743 | break; |
14855 | 14744 | } |
14856 | - case 18446744073709550949LLU: // 99999999zj''''''''''''''' | |
14745 | + case 18446744073709550952LLU: // 99999999zm''''''''''''''' | |
14857 | 14746 | { |
14858 | 14747 | if(!*LOCAL_ACCESS(heap.data, 7LLU, 5LLU)) |
14859 | 14748 | { |
@@ -14860,7 +14749,7 @@ | ||
14860 | 14749 | (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 7 |
14861 | 14750 | (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 6 |
14862 | 14751 | { |
14863 | - state.addr = 18446744073709550948LLU; // 99999999zi''''''''''''''' | |
14752 | + state.addr = 18446744073709550951LLU; // 99999999zl''''''''''''''' | |
14864 | 14753 | break; |
14865 | 14754 | } |
14866 | 14755 | } |
@@ -14871,11 +14760,11 @@ | ||
14871 | 14760 | LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
14872 | 14761 | } |
14873 | 14762 | *LOCAL_ACCESS(heap.data, 8LLU, 7LLU) = /*notfound__*/*LOCAL_ACCESS(heap.data, 8LLU, 4LLU); |
14874 | - state.addr = *LOCAL_ACCESS(heap.data, 8LLU, 7LLU) ? 18446744073709550947LLU : 18446744073709550946LLU; | |
14763 | + state.addr = *LOCAL_ACCESS(heap.data, 8LLU, 7LLU) ? 18446744073709550950LLU : 18446744073709550949LLU; | |
14875 | 14764 | (void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 8 |
14876 | 14765 | break; |
14877 | 14766 | } |
14878 | - case 18446744073709550947LLU: // 99999999zh''''''''''''''' | |
14767 | + case 18446744073709550950LLU: // 99999999zk''''''''''''''' | |
14879 | 14768 | { |
14880 | 14769 | { |
14881 | 14770 | uint64_t arg = 0; |
@@ -14882,32 +14771,32 @@ | ||
14882 | 14771 | LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
14883 | 14772 | } |
14884 | 14773 | *LOCAL_ACCESS(heap.data, 8LLU, 7LLU) = /*id________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 8LLU, 3LLU)) == /*elem______*/*access_heap(heap.data, tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 8LLU, 6LLU), 0LLU)); |
14885 | - state.addr = *LOCAL_ACCESS(heap.data, 8LLU, 7LLU) ? 18446744073709550945LLU : 18446744073709550944LLU; | |
14774 | + state.addr = *LOCAL_ACCESS(heap.data, 8LLU, 7LLU) ? 18446744073709550948LLU : 18446744073709550947LLU; | |
14886 | 14775 | (void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 8 |
14887 | 14776 | break; |
14888 | 14777 | } |
14889 | - case 18446744073709550945LLU: // 99999999zf''''''''''''''' | |
14778 | + case 18446744073709550948LLU: // 99999999zi''''''''''''''' | |
14890 | 14779 | { |
14891 | 14780 | |
14892 | 14781 | *LOCAL_ACCESS(heap.data, 7LLU, 4LLU) = 0; |
14893 | 14782 | |
14894 | 14783 | *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 7LLU, 0LLU)) = /*elem______*/*access_heap(heap.data, tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 7LLU, 6LLU), 3LLU)); |
14895 | - state.addr = 18446744073709550944LLU; // 99999999ze''''''''''''''' | |
14784 | + state.addr = 18446744073709550947LLU; // 99999999zh''''''''''''''' | |
14896 | 14785 | break; |
14897 | 14786 | } |
14898 | - case 18446744073709550944LLU: // 99999999ze''''''''''''''' | |
14787 | + case 18446744073709550947LLU: // 99999999zh''''''''''''''' | |
14899 | 14788 | { |
14900 | - state.addr = 18446744073709550946LLU; // 99999999zg''''''''''''''' | |
14789 | + state.addr = 18446744073709550949LLU; // 99999999zj''''''''''''''' | |
14901 | 14790 | break; |
14902 | 14791 | } |
14903 | - case 18446744073709550946LLU: // 99999999zg''''''''''''''' | |
14792 | + case 18446744073709550949LLU: // 99999999zj''''''''''''''' | |
14904 | 14793 | { |
14905 | 14794 | // parameter-reference typedef___ elem______ goes out of scope |
14906 | 14795 | // parameter-reference list<typedef___> typedefs__ goes out of scope |
14907 | - state.addr = 18446744073709550949LLU; // 99999999zj''''''''''''''' | |
14796 | + state.addr = 18446744073709550952LLU; // 99999999zm''''''''''''''' | |
14908 | 14797 | break; |
14909 | 14798 | } |
14910 | - case 18446744073709550948LLU: // 99999999zi''''''''''''''' | |
14799 | + case 18446744073709550951LLU: // 99999999zl''''''''''''''' | |
14911 | 14800 | { |
14912 | 14801 | { |
14913 | 14802 | uint64_t arg = 0; |
@@ -14914,11 +14803,11 @@ | ||
14914 | 14803 | LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
14915 | 14804 | } |
14916 | 14805 | *LOCAL_ACCESS(heap.data, 6LLU, 5LLU) = /*notfound__*/*LOCAL_ACCESS(heap.data, 6LLU, 4LLU); |
14917 | - state.addr = *LOCAL_ACCESS(heap.data, 6LLU, 5LLU) ? 18446744073709550943LLU : 18446744073709550942LLU; | |
14806 | + state.addr = *LOCAL_ACCESS(heap.data, 6LLU, 5LLU) ? 18446744073709550946LLU : 18446744073709550945LLU; | |
14918 | 14807 | (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 6 |
14919 | 14808 | break; |
14920 | 14809 | } |
14921 | - case 18446744073709550943LLU: // 99999999zd''''''''''''''' | |
14810 | + case 18446744073709550946LLU: // 99999999zg''''''''''''''' | |
14922 | 14811 | { |
14923 | 14812 | // ACCUMULATE ARGUMENTS - BEGIN |
14924 | 14813 | { |
@@ -14930,7 +14819,7 @@ | ||
14930 | 14819 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
14931 | 14820 | } |
14932 | 14821 | // ACCUMULATE ARGUMENTS - END |
14933 | - uint64_t return_to = 18446744073709550941LLU; | |
14822 | + uint64_t return_to = 18446744073709550944LLU; | |
14934 | 14823 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
14935 | 14824 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
14936 | 14825 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -14939,7 +14828,7 @@ | ||
14939 | 14828 | state.addr = 819847183518878446LLU; // reporttyps |
14940 | 14829 | break; |
14941 | 14830 | } |
14942 | - case 18446744073709550941LLU: // 99999999zb''''''''''''''' | |
14831 | + case 18446744073709550944LLU: // 99999999ze''''''''''''''' | |
14943 | 14832 | { |
14944 | 14833 | // ACCUMULATE ARGUMENTS - BEGIN |
14945 | 14834 | { |
@@ -14947,7 +14836,7 @@ | ||
14947 | 14836 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
14948 | 14837 | } |
14949 | 14838 | // ACCUMULATE ARGUMENTS - END |
14950 | - uint64_t return_to = 18446744073709550940LLU; | |
14839 | + uint64_t return_to = 18446744073709550943LLU; | |
14951 | 14840 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
14952 | 14841 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
14953 | 14842 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -14956,7 +14845,7 @@ | ||
14956 | 14845 | state.addr = 819847183515949359LLU; // reportinit |
14957 | 14846 | break; |
14958 | 14847 | } |
14959 | - case 18446744073709550940LLU: // 99999999za''''''''''''''' | |
14848 | + case 18446744073709550943LLU: // 99999999zd''''''''''''''' | |
14960 | 14849 | { |
14961 | 14850 | fprintf(stderr, "%s", "no such type "); |
14962 | 14851 | printid(stderr, /*id________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 5LLU, 3LLU))); |
@@ -14964,10 +14853,10 @@ | ||
14964 | 14853 | fprintf(stderr, "%s\n", ""); |
14965 | 14854 | exit(-1); |
14966 | 14855 | } |
14967 | - state.addr = 18446744073709550942LLU; // 99999999zc''''''''''''''' | |
14856 | + state.addr = 18446744073709550945LLU; // 99999999zf''''''''''''''' | |
14968 | 14857 | break; |
14969 | 14858 | } |
14970 | - case 18446744073709550942LLU: // 99999999zc''''''''''''''' | |
14859 | + case 18446744073709550945LLU: // 99999999zf''''''''''''''' | |
14971 | 14860 | { |
14972 | 14861 | // variable u64 notfound__ goes out of scope |
14973 | 14862 | // emitted destructur for type u64 |
@@ -15008,10 +14897,10 @@ | ||
15008 | 14897 | uint64_t arg = 0; |
15009 | 14898 | LOCAL_PUSH_MOVE(&heap, 7, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
15010 | 14899 | } |
15011 | - state.addr = 18446744073709550939LLU; // 99999999z$''''''''''''''' | |
14900 | + state.addr = 18446744073709550942LLU; // 99999999zc''''''''''''''' | |
15012 | 14901 | break; |
15013 | 14902 | } |
15014 | - case 18446744073709550939LLU: // 99999999z$''''''''''''''' | |
14903 | + case 18446744073709550942LLU: // 99999999zc''''''''''''''' | |
15015 | 14904 | { |
15016 | 14905 | if(!*LOCAL_ACCESS(heap.data, 8LLU, 6LLU)) |
15017 | 14906 | { |
@@ -15018,7 +14907,7 @@ | ||
15018 | 14907 | (void)LOCAL_POP_MOVE(&heap, 8LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 8 |
15019 | 14908 | (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 7 |
15020 | 14909 | { |
15021 | - state.addr = 18446744073709550938LLU; // 99999999zZ''''''''''''''' | |
14910 | + state.addr = 18446744073709550941LLU; // 99999999zb''''''''''''''' | |
15022 | 14911 | break; |
15023 | 14912 | } |
15024 | 14913 | } |
@@ -15029,27 +14918,27 @@ | ||
15029 | 14918 | LOCAL_PUSH_MOVE(&heap, 8, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
15030 | 14919 | } |
15031 | 14920 | *LOCAL_ACCESS(heap.data, 9LLU, 8LLU) = /*id________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 9LLU, 3LLU)) == /*elem______*/*access_heap(heap.data, tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 9LLU, 7LLU), 0LLU)); |
15032 | - state.addr = *LOCAL_ACCESS(heap.data, 9LLU, 8LLU) ? 18446744073709550937LLU : 18446744073709550936LLU; | |
14921 | + state.addr = *LOCAL_ACCESS(heap.data, 9LLU, 8LLU) ? 18446744073709550940LLU : 18446744073709550939LLU; | |
15033 | 14922 | (void)LOCAL_POP_MOVE(&heap, 9LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 9 |
15034 | 14923 | break; |
15035 | 14924 | } |
15036 | - case 18446744073709550937LLU: // 99999999zY''''''''''''''' | |
14925 | + case 18446744073709550940LLU: // 99999999za''''''''''''''' | |
15037 | 14926 | { |
15038 | 14927 | |
15039 | 14928 | *LOCAL_ACCESS(heap.data, 8LLU, 5LLU) = 0; |
15040 | 14929 | |
15041 | 14930 | *LOCAL_ACCESS(heap.data, 8LLU, 4LLU) = /*elem______*/*access_heap(heap.data, tree_elem_addr(heap.data, 4LLU, *LOCAL_ACCESS(heap.data, 8LLU, 7LLU), 2LLU)); |
15042 | - state.addr = 18446744073709550936LLU; // 99999999zX''''''''''''''' | |
14931 | + state.addr = 18446744073709550939LLU; // 99999999z$''''''''''''''' | |
15043 | 14932 | break; |
15044 | 14933 | } |
15045 | - case 18446744073709550936LLU: // 99999999zX''''''''''''''' | |
14934 | + case 18446744073709550939LLU: // 99999999z$''''''''''''''' | |
15046 | 14935 | { |
15047 | 14936 | // parameter-reference typedef___ elem______ goes out of scope |
15048 | 14937 | // parameter-reference list<typedef___> typedefs__ goes out of scope |
15049 | - state.addr = 18446744073709550939LLU; // 99999999z$''''''''''''''' | |
14938 | + state.addr = 18446744073709550942LLU; // 99999999zc''''''''''''''' | |
15050 | 14939 | break; |
15051 | 14940 | } |
15052 | - case 18446744073709550938LLU: // 99999999zZ''''''''''''''' | |
14941 | + case 18446744073709550941LLU: // 99999999zb''''''''''''''' | |
15053 | 14942 | { |
15054 | 14943 | { |
15055 | 14944 | uint64_t arg = 0; |
@@ -15056,11 +14945,11 @@ | ||
15056 | 14945 | LOCAL_PUSH_MOVE(&heap, 6, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
15057 | 14946 | } |
15058 | 14947 | *LOCAL_ACCESS(heap.data, 7LLU, 6LLU) = /*notfound__*/*LOCAL_ACCESS(heap.data, 7LLU, 5LLU); |
15059 | - state.addr = *LOCAL_ACCESS(heap.data, 7LLU, 6LLU) ? 18446744073709550935LLU : 18446744073709550934LLU; | |
14948 | + state.addr = *LOCAL_ACCESS(heap.data, 7LLU, 6LLU) ? 18446744073709550938LLU : 18446744073709550937LLU; | |
15060 | 14949 | (void)LOCAL_POP_MOVE(&heap, 7LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 7 |
15061 | 14950 | break; |
15062 | 14951 | } |
15063 | - case 18446744073709550935LLU: // 99999999zW''''''''''''''' | |
14952 | + case 18446744073709550938LLU: // 99999999zZ''''''''''''''' | |
15064 | 14953 | { |
15065 | 14954 | // ACCUMULATE ARGUMENTS - BEGIN |
15066 | 14955 | { |
@@ -15072,7 +14961,7 @@ | ||
15072 | 14961 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
15073 | 14962 | } |
15074 | 14963 | // ACCUMULATE ARGUMENTS - END |
15075 | - uint64_t return_to = 18446744073709550933LLU; | |
14964 | + uint64_t return_to = 18446744073709550936LLU; | |
15076 | 14965 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
15077 | 14966 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
15078 | 14967 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -15081,7 +14970,7 @@ | ||
15081 | 14970 | state.addr = 819847183518878446LLU; // reporttyps |
15082 | 14971 | break; |
15083 | 14972 | } |
15084 | - case 18446744073709550933LLU: // 99999999zU''''''''''''''' | |
14973 | + case 18446744073709550936LLU: // 99999999zX''''''''''''''' | |
15085 | 14974 | { |
15086 | 14975 | // ACCUMULATE ARGUMENTS - BEGIN |
15087 | 14976 | { |
@@ -15089,7 +14978,7 @@ | ||
15089 | 14978 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
15090 | 14979 | } |
15091 | 14980 | // ACCUMULATE ARGUMENTS - END |
15092 | - uint64_t return_to = 18446744073709550932LLU; | |
14981 | + uint64_t return_to = 18446744073709550935LLU; | |
15093 | 14982 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
15094 | 14983 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
15095 | 14984 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -15098,7 +14987,7 @@ | ||
15098 | 14987 | state.addr = 819847183515949359LLU; // reportinit |
15099 | 14988 | break; |
15100 | 14989 | } |
15101 | - case 18446744073709550932LLU: // 99999999zT''''''''''''''' | |
14990 | + case 18446744073709550935LLU: // 99999999zW''''''''''''''' | |
15102 | 14991 | { |
15103 | 14992 | fprintf(stderr, "%s", "no such type "); |
15104 | 14993 | printid(stderr, /*id________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 6LLU, 3LLU))); |
@@ -15106,10 +14995,10 @@ | ||
15106 | 14995 | fprintf(stderr, "%s\n", ""); |
15107 | 14996 | exit(-1); |
15108 | 14997 | } |
15109 | - state.addr = 18446744073709550934LLU; // 99999999zV''''''''''''''' | |
14998 | + state.addr = 18446744073709550937LLU; // 99999999zY''''''''''''''' | |
15110 | 14999 | break; |
15111 | 15000 | } |
15112 | - case 18446744073709550934LLU: // 99999999zV''''''''''''''' | |
15001 | + case 18446744073709550937LLU: // 99999999zY''''''''''''''' | |
15113 | 15002 | { |
15114 | 15003 | *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 6LLU, 0LLU)) = /*sizeonheap*/*LOCAL_ACCESS(heap.data, 6LLU, 4LLU); |
15115 | 15004 | // variable u64 notfound__ goes out of scope |
@@ -15142,7 +15031,7 @@ | ||
15142 | 15031 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
15143 | 15032 | } |
15144 | 15033 | // ACCUMULATE ARGUMENTS - END |
15145 | - uint64_t return_to = 18446744073709550931LLU; | |
15034 | + uint64_t return_to = 18446744073709550934LLU; | |
15146 | 15035 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
15147 | 15036 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
15148 | 15037 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -15151,7 +15040,7 @@ | ||
15151 | 15040 | state.addr = 787446708300855296LLU; // printtype_ |
15152 | 15041 | break; |
15153 | 15042 | } |
15154 | - case 18446744073709550931LLU: // 99999999zS''''''''''''''' | |
15043 | + case 18446744073709550934LLU: // 99999999zV''''''''''''''' | |
15155 | 15044 | { |
15156 | 15045 | // parameter-reference elemdef___ elem______ goes out of scope |
15157 | 15046 | (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference elem______ at 1 |
@@ -15171,7 +15060,7 @@ | ||
15171 | 15060 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
15172 | 15061 | } |
15173 | 15062 | // ACCUMULATE ARGUMENTS - END |
15174 | - uint64_t return_to = 18446744073709550930LLU; | |
15063 | + uint64_t return_to = 18446744073709550933LLU; | |
15175 | 15064 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
15176 | 15065 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
15177 | 15066 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -15180,7 +15069,7 @@ | ||
15180 | 15069 | state.addr = 787446708300855296LLU; // printtype_ |
15181 | 15070 | break; |
15182 | 15071 | } |
15183 | - case 18446744073709550930LLU: // 99999999zR''''''''''''''' | |
15072 | + case 18446744073709550933LLU: // 99999999zU''''''''''''''' | |
15184 | 15073 | { |
15185 | 15074 | // parameter-reference pardef____ par_______ goes out of scope |
15186 | 15075 | (void)LOCAL_POP_MOVE(&heap, 1LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference par_______ at 1 |
@@ -15246,7 +15135,7 @@ | ||
15246 | 15135 | LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
15247 | 15136 | } |
15248 | 15137 | // ACCUMULATE ARGUMENTS - END |
15249 | - uint64_t return_to = 18446744073709550929LLU; | |
15138 | + uint64_t return_to = 18446744073709550932LLU; | |
15250 | 15139 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
15251 | 15140 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
15252 | 15141 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -15255,7 +15144,7 @@ | ||
15255 | 15144 | state.addr = 62098104378497011LLU; // CalcVarIdx |
15256 | 15145 | break; |
15257 | 15146 | } |
15258 | - case 18446744073709550929LLU: // 99999999zQ''''''''''''''' | |
15147 | + case 18446744073709550932LLU: // 99999999zT''''''''''''''' | |
15259 | 15148 | { |
15260 | 15149 | // ACCUMULATE ARGUMENTS - BEGIN |
15261 | 15150 | { |
@@ -15263,7 +15152,7 @@ | ||
15263 | 15152 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
15264 | 15153 | } |
15265 | 15154 | // ACCUMULATE ARGUMENTS - END |
15266 | - uint64_t return_to = 18446744073709550928LLU; | |
15155 | + uint64_t return_to = 18446744073709550931LLU; | |
15267 | 15156 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
15268 | 15157 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
15269 | 15158 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -15272,7 +15161,7 @@ | ||
15272 | 15161 | state.addr = 787446708198178816LLU; // printnr___ |
15273 | 15162 | break; |
15274 | 15163 | } |
15275 | - case 18446744073709550928LLU: // 99999999zP''''''''''''''' | |
15164 | + case 18446744073709550931LLU: // 99999999zS''''''''''''''' | |
15276 | 15165 | { |
15277 | 15166 | // variable u64 index_____ goes out of scope |
15278 | 15167 | // emitted destructur for type u64 |
@@ -15315,7 +15204,7 @@ | ||
15315 | 15204 | LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
15316 | 15205 | } |
15317 | 15206 | // ACCUMULATE ARGUMENTS - END |
15318 | - uint64_t return_to = 18446744073709550927LLU; | |
15207 | + uint64_t return_to = 18446744073709550930LLU; | |
15319 | 15208 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
15320 | 15209 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
15321 | 15210 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -15324,7 +15213,7 @@ | ||
15324 | 15213 | state.addr = 62098104378497011LLU; // CalcVarIdx |
15325 | 15214 | break; |
15326 | 15215 | } |
15327 | - case 18446744073709550927LLU: // 99999999zO''''''''''''''' | |
15216 | + case 18446744073709550930LLU: // 99999999zR''''''''''''''' | |
15328 | 15217 | { |
15329 | 15218 | fprintf(stdout, "%s", "*LOCAL_ACCESS(heap.data, "); |
15330 | 15219 | // ACCUMULATE ARGUMENTS - BEGIN |
@@ -15333,7 +15222,7 @@ | ||
15333 | 15222 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
15334 | 15223 | } |
15335 | 15224 | // ACCUMULATE ARGUMENTS - END |
15336 | - uint64_t return_to = 18446744073709550926LLU; | |
15225 | + uint64_t return_to = 18446744073709550929LLU; | |
15337 | 15226 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
15338 | 15227 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
15339 | 15228 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -15342,7 +15231,7 @@ | ||
15342 | 15231 | state.addr = 787446708198178816LLU; // printnr___ |
15343 | 15232 | break; |
15344 | 15233 | } |
15345 | - case 18446744073709550926LLU: // 99999999zN''''''''''''''' | |
15234 | + case 18446744073709550929LLU: // 99999999zQ''''''''''''''' | |
15346 | 15235 | { |
15347 | 15236 | fprintf(stdout, "%s", ", "); |
15348 | 15237 | // ACCUMULATE ARGUMENTS - BEGIN |
@@ -15351,7 +15240,7 @@ | ||
15351 | 15240 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
15352 | 15241 | } |
15353 | 15242 | // ACCUMULATE ARGUMENTS - END |
15354 | - uint64_t return_to = 18446744073709550925LLU; | |
15243 | + uint64_t return_to = 18446744073709550928LLU; | |
15355 | 15244 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
15356 | 15245 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
15357 | 15246 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -15360,7 +15249,7 @@ | ||
15360 | 15249 | state.addr = 787446708198178816LLU; // printnr___ |
15361 | 15250 | break; |
15362 | 15251 | } |
15363 | - case 18446744073709550925LLU: // 99999999zM''''''''''''''' | |
15252 | + case 18446744073709550928LLU: // 99999999zP''''''''''''''' | |
15364 | 15253 | { |
15365 | 15254 | fprintf(stdout, "%s", ")"); |
15366 | 15255 | // variable u64 size______ goes out of scope |
@@ -15406,7 +15295,7 @@ | ||
15406 | 15295 | LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
15407 | 15296 | } |
15408 | 15297 | // ACCUMULATE ARGUMENTS - END |
15409 | - uint64_t return_to = 18446744073709550924LLU; | |
15298 | + uint64_t return_to = 18446744073709550927LLU; | |
15410 | 15299 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
15411 | 15300 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
15412 | 15301 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -15415,7 +15304,7 @@ | ||
15415 | 15304 | state.addr = 62098104378497011LLU; // CalcVarIdx |
15416 | 15305 | break; |
15417 | 15306 | } |
15418 | - case 18446744073709550924LLU: // 99999999zL''''''''''''''' | |
15307 | + case 18446744073709550927LLU: // 99999999zO''''''''''''''' | |
15419 | 15308 | { |
15420 | 15309 | fprintf(stdout, "%s", "*access_heap(heap.data, *LOCAL_ACCESS(heap.data, "); |
15421 | 15310 | // ACCUMULATE ARGUMENTS - BEGIN |
@@ -15424,7 +15313,7 @@ | ||
15424 | 15313 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
15425 | 15314 | } |
15426 | 15315 | // ACCUMULATE ARGUMENTS - END |
15427 | - uint64_t return_to = 18446744073709550923LLU; | |
15316 | + uint64_t return_to = 18446744073709550926LLU; | |
15428 | 15317 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
15429 | 15318 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
15430 | 15319 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -15433,7 +15322,7 @@ | ||
15433 | 15322 | state.addr = 787446708198178816LLU; // printnr___ |
15434 | 15323 | break; |
15435 | 15324 | } |
15436 | - case 18446744073709550923LLU: // 99999999zK''''''''''''''' | |
15325 | + case 18446744073709550926LLU: // 99999999zN''''''''''''''' | |
15437 | 15326 | { |
15438 | 15327 | fprintf(stdout, "%s", ", "); |
15439 | 15328 | // ACCUMULATE ARGUMENTS - BEGIN |
@@ -15442,7 +15331,7 @@ | ||
15442 | 15331 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
15443 | 15332 | } |
15444 | 15333 | // ACCUMULATE ARGUMENTS - END |
15445 | - uint64_t return_to = 18446744073709550922LLU; | |
15334 | + uint64_t return_to = 18446744073709550925LLU; | |
15446 | 15335 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
15447 | 15336 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
15448 | 15337 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -15451,7 +15340,7 @@ | ||
15451 | 15340 | state.addr = 787446708198178816LLU; // printnr___ |
15452 | 15341 | break; |
15453 | 15342 | } |
15454 | - case 18446744073709550922LLU: // 99999999zJ''''''''''''''' | |
15343 | + case 18446744073709550925LLU: // 99999999zM''''''''''''''' | |
15455 | 15344 | { |
15456 | 15345 | fprintf(stdout, "%s", "))"); |
15457 | 15346 | // variable u64 size______ goes out of scope |
@@ -15497,7 +15386,7 @@ | ||
15497 | 15386 | LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
15498 | 15387 | } |
15499 | 15388 | // ACCUMULATE ARGUMENTS - END |
15500 | - uint64_t return_to = 18446744073709550921LLU; | |
15389 | + uint64_t return_to = 18446744073709550924LLU; | |
15501 | 15390 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
15502 | 15391 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
15503 | 15392 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -15506,7 +15395,7 @@ | ||
15506 | 15395 | state.addr = 62098104378497011LLU; // CalcVarIdx |
15507 | 15396 | break; |
15508 | 15397 | } |
15509 | - case 18446744073709550921LLU: // 99999999zI''''''''''''''' | |
15398 | + case 18446744073709550924LLU: // 99999999zL''''''''''''''' | |
15510 | 15399 | { |
15511 | 15400 | fprintf(stdout, "%s", "LOCAL_ACCESS_ADDR(heap.data, "); |
15512 | 15401 | // ACCUMULATE ARGUMENTS - BEGIN |
@@ -15515,7 +15404,7 @@ | ||
15515 | 15404 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
15516 | 15405 | } |
15517 | 15406 | // ACCUMULATE ARGUMENTS - END |
15518 | - uint64_t return_to = 18446744073709550920LLU; | |
15407 | + uint64_t return_to = 18446744073709550923LLU; | |
15519 | 15408 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
15520 | 15409 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
15521 | 15410 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -15524,7 +15413,7 @@ | ||
15524 | 15413 | state.addr = 787446708198178816LLU; // printnr___ |
15525 | 15414 | break; |
15526 | 15415 | } |
15527 | - case 18446744073709550920LLU: // 99999999zH''''''''''''''' | |
15416 | + case 18446744073709550923LLU: // 99999999zK''''''''''''''' | |
15528 | 15417 | { |
15529 | 15418 | fprintf(stdout, "%s", ", "); |
15530 | 15419 | // ACCUMULATE ARGUMENTS - BEGIN |
@@ -15533,7 +15422,7 @@ | ||
15533 | 15422 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
15534 | 15423 | } |
15535 | 15424 | // ACCUMULATE ARGUMENTS - END |
15536 | - uint64_t return_to = 18446744073709550919LLU; | |
15425 | + uint64_t return_to = 18446744073709550922LLU; | |
15537 | 15426 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
15538 | 15427 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
15539 | 15428 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -15542,7 +15431,7 @@ | ||
15542 | 15431 | state.addr = 787446708198178816LLU; // printnr___ |
15543 | 15432 | break; |
15544 | 15433 | } |
15545 | - case 18446744073709550919LLU: // 99999999zG''''''''''''''' | |
15434 | + case 18446744073709550922LLU: // 99999999zJ''''''''''''''' | |
15546 | 15435 | { |
15547 | 15436 | fprintf(stdout, "%s", ")"); |
15548 | 15437 | // variable u64 size______ goes out of scope |
@@ -15588,7 +15477,7 @@ | ||
15588 | 15477 | LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
15589 | 15478 | } |
15590 | 15479 | // ACCUMULATE ARGUMENTS - END |
15591 | - uint64_t return_to = 18446744073709550918LLU; | |
15480 | + uint64_t return_to = 18446744073709550921LLU; | |
15592 | 15481 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
15593 | 15482 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
15594 | 15483 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -15597,7 +15486,7 @@ | ||
15597 | 15486 | state.addr = 62098104378497011LLU; // CalcVarIdx |
15598 | 15487 | break; |
15599 | 15488 | } |
15600 | - case 18446744073709550918LLU: // 99999999zF''''''''''''''' | |
15489 | + case 18446744073709550921LLU: // 99999999zI''''''''''''''' | |
15601 | 15490 | { |
15602 | 15491 | fprintf(stdout, "%s", "*LOCAL_ACCESS(heap.data, "); |
15603 | 15492 | // ACCUMULATE ARGUMENTS - BEGIN |
@@ -15606,7 +15495,7 @@ | ||
15606 | 15495 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
15607 | 15496 | } |
15608 | 15497 | // ACCUMULATE ARGUMENTS - END |
15609 | - uint64_t return_to = 18446744073709550917LLU; | |
15498 | + uint64_t return_to = 18446744073709550920LLU; | |
15610 | 15499 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
15611 | 15500 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
15612 | 15501 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -15615,7 +15504,7 @@ | ||
15615 | 15504 | state.addr = 787446708198178816LLU; // printnr___ |
15616 | 15505 | break; |
15617 | 15506 | } |
15618 | - case 18446744073709550917LLU: // 99999999zE''''''''''''''' | |
15507 | + case 18446744073709550920LLU: // 99999999zH''''''''''''''' | |
15619 | 15508 | { |
15620 | 15509 | fprintf(stdout, "%s", ", "); |
15621 | 15510 | // ACCUMULATE ARGUMENTS - BEGIN |
@@ -15624,7 +15513,7 @@ | ||
15624 | 15513 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
15625 | 15514 | } |
15626 | 15515 | // ACCUMULATE ARGUMENTS - END |
15627 | - uint64_t return_to = 18446744073709550916LLU; | |
15516 | + uint64_t return_to = 18446744073709550919LLU; | |
15628 | 15517 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
15629 | 15518 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
15630 | 15519 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -15633,7 +15522,7 @@ | ||
15633 | 15522 | state.addr = 787446708198178816LLU; // printnr___ |
15634 | 15523 | break; |
15635 | 15524 | } |
15636 | - case 18446744073709550916LLU: // 99999999zD''''''''''''''' | |
15525 | + case 18446744073709550919LLU: // 99999999zG''''''''''''''' | |
15637 | 15526 | { |
15638 | 15527 | fprintf(stdout, "%s", ")"); |
15639 | 15528 | // variable u64 size______ goes out of scope |
@@ -15662,11 +15551,11 @@ | ||
15662 | 15551 | LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
15663 | 15552 | } |
15664 | 15553 | *LOCAL_ACCESS(heap.data, 6LLU, 5LLU) = /*INDIRECT__*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 6LLU, 4LLU)); |
15665 | - state.addr = *LOCAL_ACCESS(heap.data, 6LLU, 5LLU) ? 18446744073709550915LLU : 18446744073709550914LLU; | |
15554 | + state.addr = *LOCAL_ACCESS(heap.data, 6LLU, 5LLU) ? 18446744073709550918LLU : 18446744073709550917LLU; | |
15666 | 15555 | (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 6 |
15667 | 15556 | break; |
15668 | 15557 | } |
15669 | - case 18446744073709550915LLU: // 99999999zC''''''''''''''' | |
15558 | + case 18446744073709550918LLU: // 99999999zF''''''''''''''' | |
15670 | 15559 | { |
15671 | 15560 | // ACCUMULATE ARGUMENTS - BEGIN |
15672 | 15561 | { |
@@ -15686,7 +15575,7 @@ | ||
15686 | 15575 | LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
15687 | 15576 | } |
15688 | 15577 | // ACCUMULATE ARGUMENTS - END |
15689 | - uint64_t return_to = 18446744073709550912LLU; | |
15578 | + uint64_t return_to = 18446744073709550915LLU; | |
15690 | 15579 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
15691 | 15580 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
15692 | 15581 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -15695,12 +15584,12 @@ | ||
15695 | 15584 | state.addr = 587881359725709919LLU; // emitrefind |
15696 | 15585 | break; |
15697 | 15586 | } |
15698 | - case 18446744073709550912LLU: // 99999999z_''''''''''''''' | |
15587 | + case 18446744073709550915LLU: // 99999999zC''''''''''''''' | |
15699 | 15588 | { |
15700 | - state.addr = 18446744073709550913LLU; // 99999999zA''''''''''''''' | |
15589 | + state.addr = 18446744073709550916LLU; // 99999999zD''''''''''''''' | |
15701 | 15590 | break; |
15702 | 15591 | } |
15703 | - case 18446744073709550914LLU: // 99999999zB''''''''''''''' | |
15592 | + case 18446744073709550917LLU: // 99999999zE''''''''''''''' | |
15704 | 15593 | { |
15705 | 15594 | // ACCUMULATE ARGUMENTS - BEGIN |
15706 | 15595 | { |
@@ -15720,7 +15609,7 @@ | ||
15720 | 15609 | LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
15721 | 15610 | } |
15722 | 15611 | // ACCUMULATE ARGUMENTS - END |
15723 | - uint64_t return_to = 18446744073709550911LLU; | |
15612 | + uint64_t return_to = 18446744073709550914LLU; | |
15724 | 15613 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
15725 | 15614 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
15726 | 15615 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -15729,12 +15618,12 @@ | ||
15729 | 15618 | state.addr = 587881363956714079LLU; // emitvarind |
15730 | 15619 | break; |
15731 | 15620 | } |
15732 | - case 18446744073709550911LLU: // 99999999y9''''''''''''''' | |
15621 | + case 18446744073709550914LLU: // 99999999zB''''''''''''''' | |
15733 | 15622 | { |
15734 | - state.addr = 18446744073709550913LLU; // 99999999zA''''''''''''''' | |
15623 | + state.addr = 18446744073709550916LLU; // 99999999zD''''''''''''''' | |
15735 | 15624 | break; |
15736 | 15625 | } |
15737 | - case 18446744073709550913LLU: // 99999999zA''''''''''''''' | |
15626 | + case 18446744073709550916LLU: // 99999999zD''''''''''''''' | |
15738 | 15627 | { |
15739 | 15628 | // parameter-reference u64 INDIRECT__ goes out of scope |
15740 | 15629 | (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference INDIRECT__ at 5 |
@@ -15761,11 +15650,11 @@ | ||
15761 | 15650 | LOCAL_PUSH_MOVE(&heap, 5, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
15762 | 15651 | } |
15763 | 15652 | *LOCAL_ACCESS(heap.data, 6LLU, 5LLU) = /*INDIRECT__*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 6LLU, 4LLU)); |
15764 | - state.addr = *LOCAL_ACCESS(heap.data, 6LLU, 5LLU) ? 18446744073709550910LLU : 18446744073709550909LLU; | |
15653 | + state.addr = *LOCAL_ACCESS(heap.data, 6LLU, 5LLU) ? 18446744073709550913LLU : 18446744073709550912LLU; | |
15765 | 15654 | (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 6 |
15766 | 15655 | break; |
15767 | 15656 | } |
15768 | - case 18446744073709550910LLU: // 99999999y8''''''''''''''' | |
15657 | + case 18446744073709550913LLU: // 99999999zA''''''''''''''' | |
15769 | 15658 | { |
15770 | 15659 | // ACCUMULATE ARGUMENTS - BEGIN |
15771 | 15660 | { |
@@ -15785,7 +15674,7 @@ | ||
15785 | 15674 | LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
15786 | 15675 | } |
15787 | 15676 | // ACCUMULATE ARGUMENTS - END |
15788 | - uint64_t return_to = 18446744073709550907LLU; | |
15677 | + uint64_t return_to = 18446744073709550910LLU; | |
15789 | 15678 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
15790 | 15679 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
15791 | 15680 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -15794,12 +15683,12 @@ | ||
15794 | 15683 | state.addr = 587881359725559808LLU; // emitref___ |
15795 | 15684 | break; |
15796 | 15685 | } |
15797 | - case 18446744073709550907LLU: // 99999999y5''''''''''''''' | |
15686 | + case 18446744073709550910LLU: // 99999999y8''''''''''''''' | |
15798 | 15687 | { |
15799 | - state.addr = 18446744073709550908LLU; // 99999999y6''''''''''''''' | |
15688 | + state.addr = 18446744073709550911LLU; // 99999999y9''''''''''''''' | |
15800 | 15689 | break; |
15801 | 15690 | } |
15802 | - case 18446744073709550909LLU: // 99999999y7''''''''''''''' | |
15691 | + case 18446744073709550912LLU: // 99999999z_''''''''''''''' | |
15803 | 15692 | { |
15804 | 15693 | // ACCUMULATE ARGUMENTS - BEGIN |
15805 | 15694 | { |
@@ -15819,7 +15708,7 @@ | ||
15819 | 15708 | LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
15820 | 15709 | } |
15821 | 15710 | // ACCUMULATE ARGUMENTS - END |
15822 | - uint64_t return_to = 18446744073709550906LLU; | |
15711 | + uint64_t return_to = 18446744073709550909LLU; | |
15823 | 15712 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
15824 | 15713 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
15825 | 15714 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -15828,12 +15717,12 @@ | ||
15828 | 15717 | state.addr = 587881363956563968LLU; // emitvar___ |
15829 | 15718 | break; |
15830 | 15719 | } |
15831 | - case 18446744073709550906LLU: // 99999999y4''''''''''''''' | |
15720 | + case 18446744073709550909LLU: // 99999999y7''''''''''''''' | |
15832 | 15721 | { |
15833 | - state.addr = 18446744073709550908LLU; // 99999999y6''''''''''''''' | |
15722 | + state.addr = 18446744073709550911LLU; // 99999999y9''''''''''''''' | |
15834 | 15723 | break; |
15835 | 15724 | } |
15836 | - case 18446744073709550908LLU: // 99999999y6''''''''''''''' | |
15725 | + case 18446744073709550911LLU: // 99999999y9''''''''''''''' | |
15837 | 15726 | { |
15838 | 15727 | // parameter-reference u64 INDIRECT__ goes out of scope |
15839 | 15728 | (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference INDIRECT__ at 5 |
@@ -15861,22 +15750,22 @@ | ||
15861 | 15750 | LOCAL_PUSH_MOVE(&heap, 1, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
15862 | 15751 | } |
15863 | 15752 | *LOCAL_ACCESS(heap.data, 2LLU, 1LLU) = /*level_____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 0LLU)); |
15864 | - state.addr = 18446744073709550905LLU; // 99999999y3''''''''''''''' | |
15753 | + state.addr = 18446744073709550908LLU; // 99999999y6''''''''''''''' | |
15865 | 15754 | break; |
15866 | 15755 | } |
15867 | - case 18446744073709550905LLU: // 99999999y3''''''''''''''' | |
15756 | + case 18446744073709550908LLU: // 99999999y6''''''''''''''' | |
15868 | 15757 | { |
15869 | 15758 | if(!*LOCAL_ACCESS(heap.data, 2LLU, 1LLU)) |
15870 | 15759 | { |
15871 | - state.addr = 18446744073709550904LLU; // 99999999y2''''''''''''''' | |
15760 | + state.addr = 18446744073709550907LLU; // 99999999y5''''''''''''''' | |
15872 | 15761 | break; |
15873 | 15762 | } |
15874 | 15763 | --*LOCAL_ACCESS(heap.data, 2LLU, 1LLU); |
15875 | 15764 | fprintf(stdout, "%s", " "); |
15876 | - state.addr = 18446744073709550905LLU; // 99999999y3''''''''''''''' | |
15765 | + state.addr = 18446744073709550908LLU; // 99999999y6''''''''''''''' | |
15877 | 15766 | break; |
15878 | 15767 | } |
15879 | - case 18446744073709550904LLU: // 99999999y2''''''''''''''' | |
15768 | + case 18446744073709550907LLU: // 99999999y5''''''''''''''' | |
15880 | 15769 | { |
15881 | 15770 | // parameter u64 i_________ goes out of scope |
15882 | 15771 | // variable u64 i_________ goes out of scope |
@@ -15901,7 +15790,7 @@ | ||
15901 | 15790 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
15902 | 15791 | } |
15903 | 15792 | // ACCUMULATE ARGUMENTS - END |
15904 | - uint64_t return_to = 18446744073709550903LLU; | |
15793 | + uint64_t return_to = 18446744073709550906LLU; | |
15905 | 15794 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
15906 | 15795 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
15907 | 15796 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -15910,7 +15799,7 @@ | ||
15910 | 15799 | state.addr = 787446708198178816LLU; // printnr___ |
15911 | 15800 | break; |
15912 | 15801 | } |
15913 | - case 18446744073709550903LLU: // 99999999y1''''''''''''''' | |
15802 | + case 18446744073709550906LLU: // 99999999y4''''''''''''''' | |
15914 | 15803 | { |
15915 | 15804 | fprintf(stdout, "%s", ": // "); |
15916 | 15805 | printid(stdout, /*def_id____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 1LLU, 0LLU))); |
@@ -15933,7 +15822,7 @@ | ||
15933 | 15822 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
15934 | 15823 | } |
15935 | 15824 | // ACCUMULATE ARGUMENTS - END |
15936 | - uint64_t return_to = 18446744073709550902LLU; | |
15825 | + uint64_t return_to = 18446744073709550905LLU; | |
15937 | 15826 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
15938 | 15827 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
15939 | 15828 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -15942,7 +15831,7 @@ | ||
15942 | 15831 | state.addr = 660197403663532032LLU; // indent____ |
15943 | 15832 | break; |
15944 | 15833 | } |
15945 | - case 18446744073709550902LLU: // 99999999y0''''''''''''''' | |
15834 | + case 18446744073709550905LLU: // 99999999y3''''''''''''''' | |
15946 | 15835 | { |
15947 | 15836 | fprintf(stdout, "%s", " break;"); |
15948 | 15837 | // ACCUMULATE ARGUMENTS - BEGIN |
@@ -15951,7 +15840,7 @@ | ||
15951 | 15840 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
15952 | 15841 | } |
15953 | 15842 | // ACCUMULATE ARGUMENTS - END |
15954 | - uint64_t return_to = 18446744073709550901LLU; | |
15843 | + uint64_t return_to = 18446744073709550904LLU; | |
15955 | 15844 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
15956 | 15845 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
15957 | 15846 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -15960,7 +15849,7 @@ | ||
15960 | 15849 | state.addr = 660197403663532032LLU; // indent____ |
15961 | 15850 | break; |
15962 | 15851 | } |
15963 | - case 18446744073709550901LLU: // 99999999yz''''''''''''''' | |
15852 | + case 18446744073709550904LLU: // 99999999y2''''''''''''''' | |
15964 | 15853 | { |
15965 | 15854 | fprintf(stdout, "%s", "}"); |
15966 | 15855 | // parameter-reference u64 level_____ goes out of scope |
@@ -15981,7 +15870,7 @@ | ||
15981 | 15870 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
15982 | 15871 | } |
15983 | 15872 | // ACCUMULATE ARGUMENTS - END |
15984 | - uint64_t return_to = 18446744073709550900LLU; | |
15873 | + uint64_t return_to = 18446744073709550903LLU; | |
15985 | 15874 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
15986 | 15875 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
15987 | 15876 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -15990,7 +15879,7 @@ | ||
15990 | 15879 | state.addr = 660197403663532032LLU; // indent____ |
15991 | 15880 | break; |
15992 | 15881 | } |
15993 | - case 18446744073709550900LLU: // 99999999yy''''''''''''''' | |
15882 | + case 18446744073709550903LLU: // 99999999y1''''''''''''''' | |
15994 | 15883 | { |
15995 | 15884 | fprintf(stdout, "%s", " state.addr = "); |
15996 | 15885 | // ACCUMULATE ARGUMENTS - BEGIN |
@@ -15999,7 +15888,7 @@ | ||
15999 | 15888 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
16000 | 15889 | } |
16001 | 15890 | // ACCUMULATE ARGUMENTS - END |
16002 | - uint64_t return_to = 18446744073709550899LLU; | |
15891 | + uint64_t return_to = 18446744073709550902LLU; | |
16003 | 15892 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
16004 | 15893 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
16005 | 15894 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -16008,7 +15897,7 @@ | ||
16008 | 15897 | state.addr = 787446708198178816LLU; // printnr___ |
16009 | 15898 | break; |
16010 | 15899 | } |
16011 | - case 18446744073709550899LLU: // 99999999yx''''''''''''''' | |
15900 | + case 18446744073709550902LLU: // 99999999y0''''''''''''''' | |
16012 | 15901 | { |
16013 | 15902 | fprintf(stdout, "%s", "; // "); |
16014 | 15903 | printid(stdout, /*label_____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU))); |
@@ -16018,7 +15907,7 @@ | ||
16018 | 15907 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
16019 | 15908 | } |
16020 | 15909 | // ACCUMULATE ARGUMENTS - END |
16021 | - uint64_t return_to = 18446744073709550898LLU; | |
15910 | + uint64_t return_to = 18446744073709550901LLU; | |
16022 | 15911 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
16023 | 15912 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
16024 | 15913 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -16027,7 +15916,7 @@ | ||
16027 | 15916 | state.addr = 587881351406074923LLU; // emitjumpup |
16028 | 15917 | break; |
16029 | 15918 | } |
16030 | - case 18446744073709550898LLU: // 99999999yw''''''''''''''' | |
15919 | + case 18446744073709550901LLU: // 99999999yz''''''''''''''' | |
16031 | 15920 | { |
16032 | 15921 | // parameter-reference u64 label_____ goes out of scope |
16033 | 15922 | (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference label_____ at 2 |
@@ -16049,7 +15938,7 @@ | ||
16049 | 15938 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
16050 | 15939 | } |
16051 | 15940 | // ACCUMULATE ARGUMENTS - END |
16052 | - uint64_t return_to = 18446744073709550897LLU; | |
15941 | + uint64_t return_to = 18446744073709550900LLU; | |
16053 | 15942 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
16054 | 15943 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
16055 | 15944 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -16058,7 +15947,7 @@ | ||
16058 | 15947 | state.addr = 660197403663532032LLU; // indent____ |
16059 | 15948 | break; |
16060 | 15949 | } |
16061 | - case 18446744073709550897LLU: // 99999999yv''''''''''''''' | |
15950 | + case 18446744073709550900LLU: // 99999999yy''''''''''''''' | |
16062 | 15951 | { |
16063 | 15952 | fprintf(stdout, "%s", "{"); |
16064 | 15953 | // ACCUMULATE ARGUMENTS - BEGIN |
@@ -16071,7 +15960,7 @@ | ||
16071 | 15960 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
16072 | 15961 | } |
16073 | 15962 | // ACCUMULATE ARGUMENTS - END |
16074 | - uint64_t return_to = 18446744073709550896LLU; | |
15963 | + uint64_t return_to = 18446744073709550899LLU; | |
16075 | 15964 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
16076 | 15965 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
16077 | 15966 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -16080,7 +15969,7 @@ | ||
16080 | 15969 | state.addr = 587881351406071808LLU; // emitjump__ |
16081 | 15970 | break; |
16082 | 15971 | } |
16083 | - case 18446744073709550896LLU: // 99999999yu''''''''''''''' | |
15972 | + case 18446744073709550899LLU: // 99999999yx''''''''''''''' | |
16084 | 15973 | { |
16085 | 15974 | // parameter-reference u64 label_____ goes out of scope |
16086 | 15975 | (void)LOCAL_POP_MOVE(&heap, 2LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference label_____ at 2 |
@@ -16134,7 +16023,7 @@ | ||
16134 | 16023 | LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
16135 | 16024 | } |
16136 | 16025 | // ACCUMULATE ARGUMENTS - END |
16137 | - uint64_t return_to = 18446744073709550895LLU; | |
16026 | + uint64_t return_to = 18446744073709550898LLU; | |
16138 | 16027 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
16139 | 16028 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
16140 | 16029 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -16143,7 +16032,7 @@ | ||
16143 | 16032 | state.addr = 62098104378497011LLU; // CalcVarIdx |
16144 | 16033 | break; |
16145 | 16034 | } |
16146 | - case 18446744073709550895LLU: // 99999999yt''''''''''''''' | |
16035 | + case 18446744073709550898LLU: // 99999999yw''''''''''''''' | |
16147 | 16036 | { |
16148 | 16037 | { |
16149 | 16038 | uint64_t arg = 0; |
@@ -16167,7 +16056,7 @@ | ||
16167 | 16056 | LOCAL_PUSH_MOVE(&heap, 3LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
16168 | 16057 | } |
16169 | 16058 | // ACCUMULATE ARGUMENTS - END |
16170 | - uint64_t return_to = 18446744073709550892LLU; | |
16059 | + uint64_t return_to = 18446744073709550895LLU; | |
16171 | 16060 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)); |
16172 | 16061 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
16173 | 16062 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 4LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -16176,13 +16065,13 @@ | ||
16176 | 16065 | state.addr = 62098104378497011LLU; // CalcVarIdx |
16177 | 16066 | break; |
16178 | 16067 | } |
16179 | - case 18446744073709550892LLU: // 99999999yq''''''''''''''' | |
16068 | + case 18446744073709550895LLU: // 99999999yt''''''''''''''' | |
16180 | 16069 | { |
16181 | - state.addr = *LOCAL_ACCESS(heap.data, 5LLU, 4LLU) ? 18446744073709550894LLU : 18446744073709550893LLU; | |
16070 | + state.addr = *LOCAL_ACCESS(heap.data, 5LLU, 4LLU) ? 18446744073709550897LLU : 18446744073709550896LLU; | |
16182 | 16071 | (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 5 |
16183 | 16072 | break; |
16184 | 16073 | } |
16185 | - case 18446744073709550894LLU: // 99999999ys''''''''''''''' | |
16074 | + case 18446744073709550897LLU: // 99999999yv''''''''''''''' | |
16186 | 16075 | { |
16187 | 16076 | fprintf(stderr, "%s", "INTERNAL COMPILER ERROR in emitleave: not all arguments released (remainsize "); |
16188 | 16077 | // ACCUMULATE ARGUMENTS - BEGIN |
@@ -16191,7 +16080,7 @@ | ||
16191 | 16080 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
16192 | 16081 | } |
16193 | 16082 | // ACCUMULATE ARGUMENTS - END |
16194 | - uint64_t return_to = 18446744073709550891LLU; | |
16083 | + uint64_t return_to = 18446744073709550894LLU; | |
16195 | 16084 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
16196 | 16085 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
16197 | 16086 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -16200,7 +16089,7 @@ | ||
16200 | 16089 | state.addr = 819847183517274112LLU; // reportnr__ |
16201 | 16090 | break; |
16202 | 16091 | } |
16203 | - case 18446744073709550891LLU: // 99999999yp''''''''''''''' | |
16092 | + case 18446744073709550894LLU: // 99999999ys''''''''''''''' | |
16204 | 16093 | { |
16205 | 16094 | fprintf(stderr, "%s", ")"); |
16206 | 16095 | { |
@@ -16207,10 +16096,10 @@ | ||
16207 | 16096 | fprintf(stderr, "%s\n", ""); |
16208 | 16097 | exit(-1); |
16209 | 16098 | } |
16210 | - state.addr = 18446744073709550893LLU; // 99999999yr''''''''''''''' | |
16099 | + state.addr = 18446744073709550896LLU; // 99999999yu''''''''''''''' | |
16211 | 16100 | break; |
16212 | 16101 | } |
16213 | - case 18446744073709550893LLU: // 99999999yr''''''''''''''' | |
16102 | + case 18446744073709550896LLU: // 99999999yu''''''''''''''' | |
16214 | 16103 | { |
16215 | 16104 | // variable u64 varidx____ goes out of scope |
16216 | 16105 | // emitted destructur for type u64 |
@@ -16217,7 +16106,7 @@ | ||
16217 | 16106 | (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference varidx____ at 4 |
16218 | 16107 | // ACCUMULATE ARGUMENTS - BEGIN |
16219 | 16108 | // ACCUMULATE ARGUMENTS - END |
16220 | - uint64_t return_to = 18446744073709550890LLU; | |
16109 | + uint64_t return_to = 18446744073709550893LLU; | |
16221 | 16110 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 0LLU, 0/*address of closure-in-construction*/, 0)); |
16222 | 16111 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
16223 | 16112 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 0LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -16226,7 +16115,7 @@ | ||
16226 | 16115 | state.addr = 587881359729429353LLU; // emitreturn |
16227 | 16116 | break; |
16228 | 16117 | } |
16229 | - case 18446744073709550890LLU: // 99999999yo''''''''''''''' | |
16118 | + case 18446744073709550893LLU: // 99999999yr''''''''''''''' | |
16230 | 16119 | { |
16231 | 16120 | { |
16232 | 16121 | uint64_t arg = 0; |
@@ -16239,7 +16128,7 @@ | ||
16239 | 16128 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
16240 | 16129 | } |
16241 | 16130 | // ACCUMULATE ARGUMENTS - END |
16242 | - uint64_t return_to = 18446744073709550889LLU; | |
16131 | + uint64_t return_to = 18446744073709550892LLU; | |
16243 | 16132 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
16244 | 16133 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
16245 | 16134 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -16248,7 +16137,7 @@ | ||
16248 | 16137 | state.addr = 587881351406074923LLU; // emitjumpup |
16249 | 16138 | break; |
16250 | 16139 | } |
16251 | - case 18446744073709550889LLU: // 99999999yn''''''''''''''' | |
16140 | + case 18446744073709550892LLU: // 99999999yq''''''''''''''' | |
16252 | 16141 | { |
16253 | 16142 | // variable u64 level_____ goes out of scope |
16254 | 16143 | // emitted destructur for type u64 |
@@ -16279,7 +16168,7 @@ | ||
16279 | 16168 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
16280 | 16169 | } |
16281 | 16170 | // ACCUMULATE ARGUMENTS - END |
16282 | - uint64_t return_to = 18446744073709550888LLU; | |
16171 | + uint64_t return_to = 18446744073709550891LLU; | |
16283 | 16172 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
16284 | 16173 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
16285 | 16174 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -16288,7 +16177,7 @@ | ||
16288 | 16177 | state.addr = 587881351406071808LLU; // emitjump__ |
16289 | 16178 | break; |
16290 | 16179 | } |
16291 | - case 18446744073709550888LLU: // 99999999ym''''''''''''''' | |
16180 | + case 18446744073709550891LLU: // 99999999yp''''''''''''''' | |
16292 | 16181 | { |
16293 | 16182 | // ACCUMULATE ARGUMENTS - BEGIN |
16294 | 16183 | { |
@@ -16296,7 +16185,7 @@ | ||
16296 | 16185 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
16297 | 16186 | } |
16298 | 16187 | // ACCUMULATE ARGUMENTS - END |
16299 | - uint64_t return_to = 18446744073709550887LLU; | |
16188 | + uint64_t return_to = 18446744073709550890LLU; | |
16300 | 16189 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
16301 | 16190 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
16302 | 16191 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -16305,7 +16194,7 @@ | ||
16305 | 16194 | state.addr = 587881345921715008LLU; // emitenter_ |
16306 | 16195 | break; |
16307 | 16196 | } |
16308 | - case 18446744073709550887LLU: // 99999999yl''''''''''''''' | |
16197 | + case 18446744073709550890LLU: // 99999999yo''''''''''''''' | |
16309 | 16198 | { |
16310 | 16199 | // parameter-reference u64 label1____ goes out of scope |
16311 | 16200 | (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference label1____ at 3 |
@@ -16347,7 +16236,7 @@ | ||
16347 | 16236 | LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
16348 | 16237 | } |
16349 | 16238 | // ACCUMULATE ARGUMENTS - END |
16350 | - uint64_t return_to = 18446744073709550886LLU; | |
16239 | + uint64_t return_to = 18446744073709550889LLU; | |
16351 | 16240 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)); |
16352 | 16241 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
16353 | 16242 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -16356,7 +16245,7 @@ | ||
16356 | 16245 | state.addr = 587881353215085048LLU; // emitlabel2 |
16357 | 16246 | break; |
16358 | 16247 | } |
16359 | - case 18446744073709550886LLU: // 99999999yk''''''''''''''' | |
16248 | + case 18446744073709550889LLU: // 99999999yn''''''''''''''' | |
16360 | 16249 | { |
16361 | 16250 | // variable u64 label1____ goes out of scope |
16362 | 16251 | // emitted destructur for type u64 |
@@ -16380,7 +16269,7 @@ | ||
16380 | 16269 | { |
16381 | 16270 | if(*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU)) < 1) |
16382 | 16271 | { |
16383 | - state.addr = 18446744073709550885LLU; // 99999999yj''''''''''''''' | |
16272 | + state.addr = 18446744073709550888LLU; // 99999999ym''''''''''''''' | |
16384 | 16273 | break; |
16385 | 16274 | } |
16386 | 16275 | *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU)) -= 1; |
@@ -16396,7 +16285,7 @@ | ||
16396 | 16285 | } |
16397 | 16286 | break; |
16398 | 16287 | } |
16399 | - case 18446744073709550885LLU: // 99999999yj''''''''''''''' | |
16288 | + case 18446744073709550888LLU: // 99999999ym''''''''''''''' | |
16400 | 16289 | { |
16401 | 16290 | // ACCUMULATE ARGUMENTS - BEGIN |
16402 | 16291 | { |
@@ -16404,7 +16293,7 @@ | ||
16404 | 16293 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
16405 | 16294 | } |
16406 | 16295 | // ACCUMULATE ARGUMENTS - END |
16407 | - uint64_t return_to = 18446744073709550883LLU; | |
16296 | + uint64_t return_to = 18446744073709550886LLU; | |
16408 | 16297 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
16409 | 16298 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
16410 | 16299 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -16413,7 +16302,7 @@ | ||
16413 | 16302 | state.addr = 819847183515949359LLU; // reportinit |
16414 | 16303 | break; |
16415 | 16304 | } |
16416 | - case 18446744073709550883LLU: // 99999999yh''''''''''''''' | |
16305 | + case 18446744073709550886LLU: // 99999999yk''''''''''''''' | |
16417 | 16306 | { |
16418 | 16307 | fprintf(stderr, "%s", "out of memory"); |
16419 | 16308 | { |
@@ -16436,7 +16325,7 @@ | ||
16436 | 16325 | { |
16437 | 16326 | if(*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU)) < 1) |
16438 | 16327 | { |
16439 | - state.addr = 18446744073709550882LLU; // 99999999yg''''''''''''''' | |
16328 | + state.addr = 18446744073709550885LLU; // 99999999yj''''''''''''''' | |
16440 | 16329 | break; |
16441 | 16330 | } |
16442 | 16331 | *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 1LLU)) -= 1; |
@@ -16454,7 +16343,7 @@ | ||
16454 | 16343 | } |
16455 | 16344 | break; |
16456 | 16345 | } |
16457 | - case 18446744073709550882LLU: // 99999999yg''''''''''''''' | |
16346 | + case 18446744073709550885LLU: // 99999999yj''''''''''''''' | |
16458 | 16347 | { |
16459 | 16348 | // ACCUMULATE ARGUMENTS - BEGIN |
16460 | 16349 | { |
@@ -16462,7 +16351,7 @@ | ||
16462 | 16351 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
16463 | 16352 | } |
16464 | 16353 | // ACCUMULATE ARGUMENTS - END |
16465 | - uint64_t return_to = 18446744073709550880LLU; | |
16354 | + uint64_t return_to = 18446744073709550883LLU; | |
16466 | 16355 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
16467 | 16356 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
16468 | 16357 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -16471,7 +16360,7 @@ | ||
16471 | 16360 | state.addr = 819847183515949359LLU; // reportinit |
16472 | 16361 | break; |
16473 | 16362 | } |
16474 | - case 18446744073709550880LLU: // 99999999ye''''''''''''''' | |
16363 | + case 18446744073709550883LLU: // 99999999yh''''''''''''''' | |
16475 | 16364 | { |
16476 | 16365 | fprintf(stderr, "%s", "out of memory calling "); |
16477 | 16366 | printid(stderr, /*target____*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 3LLU, 2LLU))); |
@@ -16523,7 +16412,7 @@ | ||
16523 | 16412 | LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
16524 | 16413 | } |
16525 | 16414 | // ACCUMULATE ARGUMENTS - END |
16526 | - uint64_t return_to = 18446744073709550879LLU; | |
16415 | + uint64_t return_to = 18446744073709550882LLU; | |
16527 | 16416 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)); |
16528 | 16417 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
16529 | 16418 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -16532,7 +16421,7 @@ | ||
16532 | 16421 | state.addr = 838702162643404787LLU; // showvaridx |
16533 | 16422 | break; |
16534 | 16423 | } |
16535 | - case 18446744073709550879LLU: // 99999999yd''''''''''''''' | |
16424 | + case 18446744073709550882LLU: // 99999999yg''''''''''''''' | |
16536 | 16425 | { |
16537 | 16426 | fprintf(stdout, "%s", ", &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg);"); |
16538 | 16427 | fprintf(stdout, "%s", "\n }"); |
@@ -16550,7 +16439,7 @@ | ||
16550 | 16439 | LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
16551 | 16440 | } |
16552 | 16441 | // ACCUMULATE ARGUMENTS - END |
16553 | - uint64_t return_to = 18446744073709550878LLU; | |
16442 | + uint64_t return_to = 18446744073709550881LLU; | |
16554 | 16443 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)); |
16555 | 16444 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
16556 | 16445 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -16559,7 +16448,7 @@ | ||
16559 | 16448 | state.addr = 550426420023822623LLU; // checkmemid |
16560 | 16449 | break; |
16561 | 16450 | } |
16562 | - case 18446744073709550878LLU: // 99999999yc''''''''''''''' | |
16451 | + case 18446744073709550881LLU: // 99999999yf''''''''''''''' | |
16563 | 16452 | { |
16564 | 16453 | // parameter-reference u64 remainsize goes out of scope |
16565 | 16454 | (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference remainsize at 5 |
@@ -16583,7 +16472,7 @@ | ||
16583 | 16472 | { |
16584 | 16473 | // ACCUMULATE ARGUMENTS - BEGIN |
16585 | 16474 | // ACCUMULATE ARGUMENTS - END |
16586 | - uint64_t return_to = 18446744073709550877LLU; | |
16475 | + uint64_t return_to = 18446744073709550880LLU; | |
16587 | 16476 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 0LLU, 0/*address of closure-in-construction*/, 0)); |
16588 | 16477 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
16589 | 16478 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 0LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -16592,7 +16481,7 @@ | ||
16592 | 16481 | state.addr = 517221998735392768LLU; // argopen___ |
16593 | 16482 | break; |
16594 | 16483 | } |
16595 | - case 18446744073709550877LLU: // 99999999yb''''''''''''''' | |
16484 | + case 18446744073709550880LLU: // 99999999ye''''''''''''''' | |
16596 | 16485 | { |
16597 | 16486 | // ACCUMULATE ARGUMENTS - BEGIN |
16598 | 16487 | { |
@@ -16600,7 +16489,7 @@ | ||
16600 | 16489 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
16601 | 16490 | } |
16602 | 16491 | // ACCUMULATE ARGUMENTS - END |
16603 | - uint64_t return_to = 18446744073709550876LLU; | |
16492 | + uint64_t return_to = 18446744073709550879LLU; | |
16604 | 16493 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
16605 | 16494 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
16606 | 16495 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -16609,7 +16498,7 @@ | ||
16609 | 16498 | state.addr = 787446708198178816LLU; // printnr___ |
16610 | 16499 | break; |
16611 | 16500 | } |
16612 | - case 18446744073709550876LLU: // 99999999ya''''''''''''''' | |
16501 | + case 18446744073709550879LLU: // 99999999yd''''''''''''''' | |
16613 | 16502 | { |
16614 | 16503 | // ACCUMULATE ARGUMENTS - BEGIN |
16615 | 16504 | { |
@@ -16633,7 +16522,7 @@ | ||
16633 | 16522 | LOCAL_PUSH_MOVE(&heap, 4LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
16634 | 16523 | } |
16635 | 16524 | // ACCUMULATE ARGUMENTS - END |
16636 | - uint64_t return_to = 18446744073709550875LLU; | |
16525 | + uint64_t return_to = 18446744073709550878LLU; | |
16637 | 16526 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)); |
16638 | 16527 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
16639 | 16528 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 5LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -16642,7 +16531,7 @@ | ||
16642 | 16531 | state.addr = 517221169975918592LLU; // argclose__ |
16643 | 16532 | break; |
16644 | 16533 | } |
16645 | - case 18446744073709550875LLU: // 99999999y$''''''''''''''' | |
16534 | + case 18446744073709550878LLU: // 99999999yc''''''''''''''' | |
16646 | 16535 | { |
16647 | 16536 | // parameter-reference u64 value_____ goes out of scope |
16648 | 16537 | (void)LOCAL_POP_MOVE(&heap, 6LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference value_____ at 6 |
@@ -16693,7 +16582,7 @@ | ||
16693 | 16582 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
16694 | 16583 | } |
16695 | 16584 | // ACCUMULATE ARGUMENTS - END |
16696 | - uint64_t return_to = 18446744073709550874LLU; | |
16585 | + uint64_t return_to = 18446744073709550877LLU; | |
16697 | 16586 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
16698 | 16587 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
16699 | 16588 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -16702,7 +16591,7 @@ | ||
16702 | 16591 | state.addr = 787446708198178816LLU; // printnr___ |
16703 | 16592 | break; |
16704 | 16593 | } |
16705 | - case 18446744073709550874LLU: // 99999999yZ''''''''''''''' | |
16594 | + case 18446744073709550877LLU: // 99999999yb''''''''''''''' | |
16706 | 16595 | { |
16707 | 16596 | fprintf(stdout, "%s", ";"); |
16708 | 16597 | fprintf(stdout, "%s", "\n const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + "); |
@@ -16720,7 +16609,7 @@ | ||
16720 | 16609 | LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
16721 | 16610 | } |
16722 | 16611 | // ACCUMULATE ARGUMENTS - END |
16723 | - uint64_t return_to = 18446744073709550873LLU; | |
16612 | + uint64_t return_to = 18446744073709550876LLU; | |
16724 | 16613 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)); |
16725 | 16614 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
16726 | 16615 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -16729,7 +16618,7 @@ | ||
16729 | 16618 | state.addr = 838702162643404787LLU; // showvaridx |
16730 | 16619 | break; |
16731 | 16620 | } |
16732 | - case 18446744073709550873LLU: // 99999999yY''''''''''''''' | |
16621 | + case 18446744073709550876LLU: // 99999999ya''''''''''''''' | |
16733 | 16622 | { |
16734 | 16623 | fprintf(stdout, "%s", ", 0/*address of closure-in-construction*/, 0));"); |
16735 | 16624 | fprintf(stdout, "%s", "\n uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to);"); |
@@ -16748,7 +16637,7 @@ | ||
16748 | 16637 | LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
16749 | 16638 | } |
16750 | 16639 | // ACCUMULATE ARGUMENTS - END |
16751 | - uint64_t return_to = 18446744073709550872LLU; | |
16640 | + uint64_t return_to = 18446744073709550875LLU; | |
16752 | 16641 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)); |
16753 | 16642 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
16754 | 16643 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -16757,7 +16646,7 @@ | ||
16757 | 16646 | state.addr = 838702162643404787LLU; // showvaridx |
16758 | 16647 | break; |
16759 | 16648 | } |
16760 | - case 18446744073709550872LLU: // 99999999yX''''''''''''''' | |
16649 | + case 18446744073709550875LLU: // 99999999y$''''''''''''''' | |
16761 | 16650 | { |
16762 | 16651 | fprintf(stdout, "%s", ", 0/*address of closure-in-construction*/, 0)) = baseinfo;"); |
16763 | 16652 | fprintf(stdout, "%s", "\n heap.data[0].elem1 = heap.data[0].elem0;"); |
@@ -16781,7 +16670,7 @@ | ||
16781 | 16670 | LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
16782 | 16671 | } |
16783 | 16672 | // ACCUMULATE ARGUMENTS - END |
16784 | - uint64_t return_to = 18446744073709550871LLU; | |
16673 | + uint64_t return_to = 18446744073709550874LLU; | |
16785 | 16674 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)); |
16786 | 16675 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
16787 | 16676 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -16790,7 +16679,7 @@ | ||
16790 | 16679 | state.addr = 587881353215085048LLU; // emitlabel2 |
16791 | 16680 | break; |
16792 | 16681 | } |
16793 | - case 18446744073709550871LLU: // 99999999yW''''''''''''''' | |
16682 | + case 18446744073709550874LLU: // 99999999yZ''''''''''''''' | |
16794 | 16683 | { |
16795 | 16684 | // variable u64 level_____ goes out of scope |
16796 | 16685 | // emitted destructur for type u64 |
@@ -16817,7 +16706,7 @@ | ||
16817 | 16706 | { |
16818 | 16707 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 != 0/*typeu64___*/) |
16819 | 16708 | { |
16820 | - state.addr = 18446744073709550870LLU; // 99999999yV''''''''''''''' | |
16709 | + state.addr = 18446744073709550873LLU; // 99999999yY''''''''''''''' | |
16821 | 16710 | break; |
16822 | 16711 | } |
16823 | 16712 | { |
@@ -16838,7 +16727,7 @@ | ||
16838 | 16727 | } |
16839 | 16728 | break; |
16840 | 16729 | } |
16841 | - case 18446744073709550870LLU: // 99999999yV''''''''''''''' | |
16730 | + case 18446744073709550873LLU: // 99999999yY''''''''''''''' | |
16842 | 16731 | { |
16843 | 16732 | *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 0LLU)) = 0LLU; |
16844 | 16733 | // parameter-reference type______ __________ goes out of scope |
@@ -16852,7 +16741,7 @@ | ||
16852 | 16741 | } |
16853 | 16742 | break; |
16854 | 16743 | } |
16855 | - case 18446744073709550869LLU: // 99999999yU''''''''''''''' | |
16744 | + case 18446744073709550872LLU: // 99999999yX''''''''''''''' | |
16856 | 16745 | { |
16857 | 16746 | fprintf(stderr, "INTERNAL COMPILER ERROR: missing pattern-match-case in definition of isu64_____\n"); |
16858 | 16747 | exit(-1); |
@@ -16862,7 +16751,7 @@ | ||
16862 | 16751 | { |
16863 | 16752 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 != 0/*typeu64___*/) |
16864 | 16753 | { |
16865 | - state.addr = 18446744073709550868LLU; // 99999999yT''''''''''''''' | |
16754 | + state.addr = 18446744073709550871LLU; // 99999999yW''''''''''''''' | |
16866 | 16755 | break; |
16867 | 16756 | } |
16868 | 16757 | { |
@@ -16883,11 +16772,11 @@ | ||
16883 | 16772 | } |
16884 | 16773 | break; |
16885 | 16774 | } |
16886 | - case 18446744073709550868LLU: // 99999999yT''''''''''''''' | |
16775 | + case 18446744073709550871LLU: // 99999999yW''''''''''''''' | |
16887 | 16776 | { |
16888 | 16777 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 != 1/*typename__*/) |
16889 | 16778 | { |
16890 | - state.addr = 18446744073709550867LLU; // 99999999yS''''''''''''''' | |
16779 | + state.addr = 18446744073709550870LLU; // 99999999yV''''''''''''''' | |
16891 | 16780 | break; |
16892 | 16781 | } |
16893 | 16782 | { |
@@ -16908,11 +16797,11 @@ | ||
16908 | 16797 | } |
16909 | 16798 | break; |
16910 | 16799 | } |
16911 | - case 18446744073709550867LLU: // 99999999yS''''''''''''''' | |
16800 | + case 18446744073709550870LLU: // 99999999yV''''''''''''''' | |
16912 | 16801 | { |
16913 | 16802 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 != 2/*typelist__*/) |
16914 | 16803 | { |
16915 | - state.addr = 18446744073709550866LLU; // 99999999yR''''''''''''''' | |
16804 | + state.addr = 18446744073709550869LLU; // 99999999yU''''''''''''''' | |
16916 | 16805 | break; |
16917 | 16806 | } |
16918 | 16807 | { |
@@ -16933,7 +16822,7 @@ | ||
16933 | 16822 | } |
16934 | 16823 | break; |
16935 | 16824 | } |
16936 | - case 18446744073709550866LLU: // 99999999yR''''''''''''''' | |
16825 | + case 18446744073709550869LLU: // 99999999yU''''''''''''''' | |
16937 | 16826 | { |
16938 | 16827 | fprintf(stderr, "INTERNAL COMPILER ERROR: missing pattern-match-case in definition of islist____\n"); |
16939 | 16828 | exit(-1); |
@@ -16943,7 +16832,7 @@ | ||
16943 | 16832 | { |
16944 | 16833 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 != 0/*typeu64___*/) |
16945 | 16834 | { |
16946 | - state.addr = 18446744073709550865LLU; // 99999999yQ''''''''''''''' | |
16835 | + state.addr = 18446744073709550868LLU; // 99999999yT''''''''''''''' | |
16947 | 16836 | break; |
16948 | 16837 | } |
16949 | 16838 | { |
@@ -16964,7 +16853,7 @@ | ||
16964 | 16853 | } |
16965 | 16854 | break; |
16966 | 16855 | } |
16967 | - case 18446744073709550865LLU: // 99999999yQ''''''''''''''' | |
16856 | + case 18446744073709550868LLU: // 99999999yT''''''''''''''' | |
16968 | 16857 | { |
16969 | 16858 | *access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 0LLU)) = 0LLU; |
16970 | 16859 | // parameter-reference type______ __________ goes out of scope |
@@ -16978,7 +16867,7 @@ | ||
16978 | 16867 | } |
16979 | 16868 | break; |
16980 | 16869 | } |
16981 | - case 18446744073709550864LLU: // 99999999yP''''''''''''''' | |
16870 | + case 18446744073709550867LLU: // 99999999yS''''''''''''''' | |
16982 | 16871 | { |
16983 | 16872 | fprintf(stderr, "INTERNAL COMPILER ERROR: missing pattern-match-case in definition of isatom____\n"); |
16984 | 16873 | exit(-1); |
@@ -16988,7 +16877,7 @@ | ||
16988 | 16877 | { |
16989 | 16878 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 != 0/*typeu64___*/) |
16990 | 16879 | { |
16991 | - state.addr = 18446744073709550863LLU; // 99999999yO''''''''''''''' | |
16880 | + state.addr = 18446744073709550866LLU; // 99999999yR''''''''''''''' | |
16992 | 16881 | break; |
16993 | 16882 | } |
16994 | 16883 | { |
@@ -17009,11 +16898,11 @@ | ||
17009 | 16898 | } |
17010 | 16899 | break; |
17011 | 16900 | } |
17012 | - case 18446744073709550863LLU: // 99999999yO''''''''''''''' | |
16901 | + case 18446744073709550866LLU: // 99999999yR''''''''''''''' | |
17013 | 16902 | { |
17014 | 16903 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 != 1/*typename__*/) |
17015 | 16904 | { |
17016 | - state.addr = 18446744073709550862LLU; // 99999999yN''''''''''''''' | |
16905 | + state.addr = 18446744073709550865LLU; // 99999999yQ''''''''''''''' | |
17017 | 16906 | break; |
17018 | 16907 | } |
17019 | 16908 | { |
@@ -17034,11 +16923,11 @@ | ||
17034 | 16923 | } |
17035 | 16924 | break; |
17036 | 16925 | } |
17037 | - case 18446744073709550862LLU: // 99999999yN''''''''''''''' | |
16926 | + case 18446744073709550865LLU: // 99999999yQ''''''''''''''' | |
17038 | 16927 | { |
17039 | 16928 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 != 2/*typelist__*/) |
17040 | 16929 | { |
17041 | - state.addr = 18446744073709550861LLU; // 99999999yM''''''''''''''' | |
16930 | + state.addr = 18446744073709550864LLU; // 99999999yP''''''''''''''' | |
17042 | 16931 | break; |
17043 | 16932 | } |
17044 | 16933 | { |
@@ -17059,7 +16948,7 @@ | ||
17059 | 16948 | } |
17060 | 16949 | break; |
17061 | 16950 | } |
17062 | - case 18446744073709550861LLU: // 99999999yM''''''''''''''' | |
16951 | + case 18446744073709550864LLU: // 99999999yP''''''''''''''' | |
17063 | 16952 | { |
17064 | 16953 | fprintf(stderr, "INTERNAL COMPILER ERROR: missing pattern-match-case in definition of isprim____\n"); |
17065 | 16954 | exit(-1); |
@@ -17069,7 +16958,7 @@ | ||
17069 | 16958 | { |
17070 | 16959 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 != 0/*typeu64___*/) |
17071 | 16960 | { |
17072 | - state.addr = 18446744073709550860LLU; // 99999999yL''''''''''''''' | |
16961 | + state.addr = 18446744073709550863LLU; // 99999999yO''''''''''''''' | |
17073 | 16962 | break; |
17074 | 16963 | } |
17075 | 16964 | { |
@@ -17090,7 +16979,7 @@ | ||
17090 | 16979 | } |
17091 | 16980 | break; |
17092 | 16981 | } |
17093 | - case 18446744073709550860LLU: // 99999999yL''''''''''''''' | |
16982 | + case 18446744073709550863LLU: // 99999999yO''''''''''''''' | |
17094 | 16983 | { |
17095 | 16984 | printid(stderr, /*info______*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 0LLU))); |
17096 | 16985 | fprintf(stderr, "%s", ": need u64 but found "); |
@@ -17100,7 +16989,7 @@ | ||
17100 | 16989 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
17101 | 16990 | } |
17102 | 16991 | // ACCUMULATE ARGUMENTS - END |
17103 | - uint64_t return_to = 18446744073709550858LLU; | |
16992 | + uint64_t return_to = 18446744073709550861LLU; | |
17104 | 16993 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
17105 | 16994 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
17106 | 16995 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -17109,7 +16998,7 @@ | ||
17109 | 16998 | state.addr = 819847183518878432LLU; // reporttype |
17110 | 16999 | break; |
17111 | 17000 | } |
17112 | - case 18446744073709550858LLU: // 99999999yJ''''''''''''''' | |
17001 | + case 18446744073709550861LLU: // 99999999yM''''''''''''''' | |
17113 | 17002 | { |
17114 | 17003 | { |
17115 | 17004 | fprintf(stderr, "%s\n", ""); |
@@ -17127,7 +17016,7 @@ | ||
17127 | 17016 | } |
17128 | 17017 | break; |
17129 | 17018 | } |
17130 | - case 18446744073709550859LLU: // 99999999yK''''''''''''''' | |
17019 | + case 18446744073709550862LLU: // 99999999yN''''''''''''''' | |
17131 | 17020 | { |
17132 | 17021 | fprintf(stderr, "INTERNAL COMPILER ERROR: missing pattern-match-case in definition of assertu64_\n"); |
17133 | 17022 | exit(-1); |
@@ -17137,7 +17026,7 @@ | ||
17137 | 17026 | { |
17138 | 17027 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 != 0/*typeu64___*/) |
17139 | 17028 | { |
17140 | - state.addr = 18446744073709550857LLU; // 99999999yI''''''''''''''' | |
17029 | + state.addr = 18446744073709550860LLU; // 99999999yL''''''''''''''' | |
17141 | 17030 | break; |
17142 | 17031 | } |
17143 | 17032 | { |
@@ -17164,11 +17053,11 @@ | ||
17164 | 17053 | } |
17165 | 17054 | break; |
17166 | 17055 | } |
17167 | - case 18446744073709550857LLU: // 99999999yI''''''''''''''' | |
17056 | + case 18446744073709550860LLU: // 99999999yL''''''''''''''' | |
17168 | 17057 | { |
17169 | 17058 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 != 1/*typename__*/) |
17170 | 17059 | { |
17171 | - state.addr = 18446744073709550856LLU; // 99999999yH''''''''''''''' | |
17060 | + state.addr = 18446744073709550859LLU; // 99999999yK''''''''''''''' | |
17172 | 17061 | break; |
17173 | 17062 | } |
17174 | 17063 | { |
@@ -17202,11 +17091,11 @@ | ||
17202 | 17091 | } |
17203 | 17092 | break; |
17204 | 17093 | } |
17205 | - case 18446744073709550856LLU: // 99999999yH''''''''''''''' | |
17094 | + case 18446744073709550859LLU: // 99999999yK''''''''''''''' | |
17206 | 17095 | { |
17207 | 17096 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 != 2/*typelist__*/) |
17208 | 17097 | { |
17209 | - state.addr = 18446744073709550855LLU; // 99999999yG''''''''''''''' | |
17098 | + state.addr = 18446744073709550858LLU; // 99999999yJ''''''''''''''' | |
17210 | 17099 | break; |
17211 | 17100 | } |
17212 | 17101 | { |
@@ -17227,7 +17116,7 @@ | ||
17227 | 17116 | } |
17228 | 17117 | break; |
17229 | 17118 | } |
17230 | - case 18446744073709550855LLU: // 99999999yG''''''''''''''' | |
17119 | + case 18446744073709550858LLU: // 99999999yJ''''''''''''''' | |
17231 | 17120 | { |
17232 | 17121 | fprintf(stderr, "INTERNAL COMPILER ERROR: missing pattern-match-case in definition of assertlist\n"); |
17233 | 17122 | exit(-1); |
@@ -17237,7 +17126,7 @@ | ||
17237 | 17126 | { |
17238 | 17127 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 != 0/*typeu64___*/) |
17239 | 17128 | { |
17240 | - state.addr = 18446744073709550854LLU; // 99999999yF''''''''''''''' | |
17129 | + state.addr = 18446744073709550857LLU; // 99999999yI''''''''''''''' | |
17241 | 17130 | break; |
17242 | 17131 | } |
17243 | 17132 | { |
@@ -17258,11 +17147,11 @@ | ||
17258 | 17147 | } |
17259 | 17148 | break; |
17260 | 17149 | } |
17261 | - case 18446744073709550854LLU: // 99999999yF''''''''''''''' | |
17150 | + case 18446744073709550857LLU: // 99999999yI''''''''''''''' | |
17262 | 17151 | { |
17263 | 17152 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 != 1/*typename__*/) |
17264 | 17153 | { |
17265 | - state.addr = 18446744073709550853LLU; // 99999999yE''''''''''''''' | |
17154 | + state.addr = 18446744073709550856LLU; // 99999999yH''''''''''''''' | |
17266 | 17155 | break; |
17267 | 17156 | } |
17268 | 17157 | { |
@@ -17283,11 +17172,11 @@ | ||
17283 | 17172 | } |
17284 | 17173 | break; |
17285 | 17174 | } |
17286 | - case 18446744073709550853LLU: // 99999999yE''''''''''''''' | |
17175 | + case 18446744073709550856LLU: // 99999999yH''''''''''''''' | |
17287 | 17176 | { |
17288 | 17177 | if(heap.data[*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 2LLU, 1LLU))].elem0 != 2/*typelist__*/) |
17289 | 17178 | { |
17290 | - state.addr = 18446744073709550852LLU; // 99999999yD''''''''''''''' | |
17179 | + state.addr = 18446744073709550855LLU; // 99999999yG''''''''''''''' | |
17291 | 17180 | break; |
17292 | 17181 | } |
17293 | 17182 | { |
@@ -17322,7 +17211,7 @@ | ||
17322 | 17211 | } |
17323 | 17212 | break; |
17324 | 17213 | } |
17325 | - case 18446744073709550852LLU: // 99999999yD''''''''''''''' | |
17214 | + case 18446744073709550855LLU: // 99999999yG''''''''''''''' | |
17326 | 17215 | { |
17327 | 17216 | fprintf(stderr, "INTERNAL COMPILER ERROR: missing pattern-match-case in definition of assertstat\n"); |
17328 | 17217 | exit(-1); |
@@ -17348,7 +17237,7 @@ | ||
17348 | 17237 | LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
17349 | 17238 | } |
17350 | 17239 | // ACCUMULATE ARGUMENTS - END |
17351 | - uint64_t return_to = 18446744073709550848LLU; | |
17240 | + uint64_t return_to = 18446744073709550851LLU; | |
17352 | 17241 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)); |
17353 | 17242 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
17354 | 17243 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -17357,18 +17246,18 @@ | ||
17357 | 17246 | state.addr = 589060043891015680LLU; // equtype___ |
17358 | 17247 | break; |
17359 | 17248 | } |
17360 | - case 18446744073709550848LLU: // 99999999y_''''''''''''''' | |
17249 | + case 18446744073709550851LLU: // 99999999yC''''''''''''''' | |
17361 | 17250 | { |
17362 | - state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709550851LLU : 18446744073709550850LLU; | |
17251 | + state.addr = *LOCAL_ACCESS(heap.data, 4LLU, 3LLU) ? 18446744073709550854LLU : 18446744073709550853LLU; | |
17363 | 17252 | (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 4 |
17364 | 17253 | break; |
17365 | 17254 | } |
17366 | - case 18446744073709550851LLU: // 99999999yC''''''''''''''' | |
17255 | + case 18446744073709550854LLU: // 99999999yF''''''''''''''' | |
17367 | 17256 | { |
17368 | - state.addr = 18446744073709550849LLU; // 99999999yA''''''''''''''' | |
17257 | + state.addr = 18446744073709550852LLU; // 99999999yD''''''''''''''' | |
17369 | 17258 | break; |
17370 | 17259 | } |
17371 | - case 18446744073709550850LLU: // 99999999yB''''''''''''''' | |
17260 | + case 18446744073709550853LLU: // 99999999yE''''''''''''''' | |
17372 | 17261 | { |
17373 | 17262 | // ACCUMULATE ARGUMENTS - BEGIN |
17374 | 17263 | { |
@@ -17376,7 +17265,7 @@ | ||
17376 | 17265 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
17377 | 17266 | } |
17378 | 17267 | // ACCUMULATE ARGUMENTS - END |
17379 | - uint64_t return_to = 18446744073709550847LLU; | |
17268 | + uint64_t return_to = 18446744073709550850LLU; | |
17380 | 17269 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
17381 | 17270 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
17382 | 17271 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -17385,7 +17274,7 @@ | ||
17385 | 17274 | state.addr = 819847183515949359LLU; // reportinit |
17386 | 17275 | break; |
17387 | 17276 | } |
17388 | - case 18446744073709550847LLU: // 99999999x9''''''''''''''' | |
17277 | + case 18446744073709550850LLU: // 99999999yB''''''''''''''' | |
17389 | 17278 | { |
17390 | 17279 | // ACCUMULATE ARGUMENTS - BEGIN |
17391 | 17280 | { |
@@ -17393,7 +17282,7 @@ | ||
17393 | 17282 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
17394 | 17283 | } |
17395 | 17284 | // ACCUMULATE ARGUMENTS - END |
17396 | - uint64_t return_to = 18446744073709550846LLU; | |
17285 | + uint64_t return_to = 18446744073709550849LLU; | |
17397 | 17286 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
17398 | 17287 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
17399 | 17288 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -17402,7 +17291,7 @@ | ||
17402 | 17291 | state.addr = 819847183518878432LLU; // reporttype |
17403 | 17292 | break; |
17404 | 17293 | } |
17405 | - case 18446744073709550846LLU: // 99999999x8''''''''''''''' | |
17294 | + case 18446744073709550849LLU: // 99999999yA''''''''''''''' | |
17406 | 17295 | { |
17407 | 17296 | fprintf(stderr, "%s", " != "); |
17408 | 17297 | // ACCUMULATE ARGUMENTS - BEGIN |
@@ -17411,7 +17300,7 @@ | ||
17411 | 17300 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
17412 | 17301 | } |
17413 | 17302 | // ACCUMULATE ARGUMENTS - END |
17414 | - uint64_t return_to = 18446744073709550845LLU; | |
17303 | + uint64_t return_to = 18446744073709550848LLU; | |
17415 | 17304 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
17416 | 17305 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
17417 | 17306 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -17420,16 +17309,16 @@ | ||
17420 | 17309 | state.addr = 819847183518878432LLU; // reporttype |
17421 | 17310 | break; |
17422 | 17311 | } |
17423 | - case 18446744073709550845LLU: // 99999999x7''''''''''''''' | |
17312 | + case 18446744073709550848LLU: // 99999999y_''''''''''''''' | |
17424 | 17313 | { |
17425 | 17314 | { |
17426 | 17315 | fprintf(stderr, "%s\n", ""); |
17427 | 17316 | exit(-1); |
17428 | 17317 | } |
17429 | - state.addr = 18446744073709550849LLU; // 99999999yA''''''''''''''' | |
17318 | + state.addr = 18446744073709550852LLU; // 99999999yD''''''''''''''' | |
17430 | 17319 | break; |
17431 | 17320 | } |
17432 | - case 18446744073709550849LLU: // 99999999yA''''''''''''''' | |
17321 | + case 18446744073709550852LLU: // 99999999yD''''''''''''''' | |
17433 | 17322 | { |
17434 | 17323 | // parameter-reference type______ typesrc___ goes out of scope |
17435 | 17324 | (void)LOCAL_POP_MOVE(&heap, 3LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference typesrc___ at 3 |
@@ -17465,7 +17354,7 @@ | ||
17465 | 17354 | LOCAL_PUSH_MOVE(&heap, 2LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
17466 | 17355 | } |
17467 | 17356 | // ACCUMULATE ARGUMENTS - END |
17468 | - uint64_t return_to = 18446744073709550841LLU; | |
17357 | + uint64_t return_to = 18446744073709550844LLU; | |
17469 | 17358 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)); |
17470 | 17359 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
17471 | 17360 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 3LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -17474,18 +17363,18 @@ | ||
17474 | 17363 | state.addr = 589060043891015680LLU; // equtype___ |
17475 | 17364 | break; |
17476 | 17365 | } |
17477 | - case 18446744073709550841LLU: // 99999999x3''''''''''''''' | |
17366 | + case 18446744073709550844LLU: // 99999999x6''''''''''''''' | |
17478 | 17367 | { |
17479 | - state.addr = *LOCAL_ACCESS(heap.data, 5LLU, 4LLU) ? 18446744073709550844LLU : 18446744073709550843LLU; | |
17368 | + state.addr = *LOCAL_ACCESS(heap.data, 5LLU, 4LLU) ? 18446744073709550847LLU : 18446744073709550846LLU; | |
17480 | 17369 | (void)LOCAL_POP_MOVE(&heap, 5LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 5 |
17481 | 17370 | break; |
17482 | 17371 | } |
17483 | - case 18446744073709550844LLU: // 99999999x6''''''''''''''' | |
17372 | + case 18446744073709550847LLU: // 99999999x9''''''''''''''' | |
17484 | 17373 | { |
17485 | - state.addr = 18446744073709550842LLU; // 99999999x4''''''''''''''' | |
17374 | + state.addr = 18446744073709550845LLU; // 99999999x7''''''''''''''' | |
17486 | 17375 | break; |
17487 | 17376 | } |
17488 | - case 18446744073709550843LLU: // 99999999x5''''''''''''''' | |
17377 | + case 18446744073709550846LLU: // 99999999x8''''''''''''''' | |
17489 | 17378 | { |
17490 | 17379 | // ACCUMULATE ARGUMENTS - BEGIN |
17491 | 17380 | { |
@@ -17493,7 +17382,7 @@ | ||
17493 | 17382 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
17494 | 17383 | } |
17495 | 17384 | // ACCUMULATE ARGUMENTS - END |
17496 | - uint64_t return_to = 18446744073709550840LLU; | |
17385 | + uint64_t return_to = 18446744073709550843LLU; | |
17497 | 17386 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
17498 | 17387 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
17499 | 17388 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -17502,7 +17391,7 @@ | ||
17502 | 17391 | state.addr = 819847183515949359LLU; // reportinit |
17503 | 17392 | break; |
17504 | 17393 | } |
17505 | - case 18446744073709550840LLU: // 99999999x2''''''''''''''' | |
17394 | + case 18446744073709550843LLU: // 99999999x5''''''''''''''' | |
17506 | 17395 | { |
17507 | 17396 | printid(stderr, /*id________*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 4LLU, 1LLU))); |
17508 | 17397 | fprintf(stderr, "%s", " :: "); |
@@ -17512,7 +17401,7 @@ | ||
17512 | 17401 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
17513 | 17402 | } |
17514 | 17403 | // ACCUMULATE ARGUMENTS - END |
17515 | - uint64_t return_to = 18446744073709550839LLU; | |
17404 | + uint64_t return_to = 18446744073709550842LLU; | |
17516 | 17405 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
17517 | 17406 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
17518 | 17407 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -17521,7 +17410,7 @@ | ||
17521 | 17410 | state.addr = 819847183518878432LLU; // reporttype |
17522 | 17411 | break; |
17523 | 17412 | } |
17524 | - case 18446744073709550839LLU: // 99999999x1''''''''''''''' | |
17413 | + case 18446744073709550842LLU: // 99999999x4''''''''''''''' | |
17525 | 17414 | { |
17526 | 17415 | fprintf(stderr, "%s", " != "); |
17527 | 17416 | // ACCUMULATE ARGUMENTS - BEGIN |
@@ -17530,7 +17419,7 @@ | ||
17530 | 17419 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
17531 | 17420 | } |
17532 | 17421 | // ACCUMULATE ARGUMENTS - END |
17533 | - uint64_t return_to = 18446744073709550838LLU; | |
17422 | + uint64_t return_to = 18446744073709550841LLU; | |
17534 | 17423 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
17535 | 17424 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
17536 | 17425 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -17539,16 +17428,16 @@ | ||
17539 | 17428 | state.addr = 819847183518878432LLU; // reporttype |
17540 | 17429 | break; |
17541 | 17430 | } |
17542 | - case 18446744073709550838LLU: // 99999999x0''''''''''''''' | |
17431 | + case 18446744073709550841LLU: // 99999999x3''''''''''''''' | |
17543 | 17432 | { |
17544 | 17433 | { |
17545 | 17434 | fprintf(stderr, "%s\n", ""); |
17546 | 17435 | exit(-1); |
17547 | 17436 | } |
17548 | - state.addr = 18446744073709550842LLU; // 99999999x4''''''''''''''' | |
17437 | + state.addr = 18446744073709550845LLU; // 99999999x7''''''''''''''' | |
17549 | 17438 | break; |
17550 | 17439 | } |
17551 | - case 18446744073709550842LLU: // 99999999x4''''''''''''''' | |
17440 | + case 18446744073709550845LLU: // 99999999x7''''''''''''''' | |
17552 | 17441 | { |
17553 | 17442 | // parameter-reference type______ typesrc___ goes out of scope |
17554 | 17443 | (void)LOCAL_POP_MOVE(&heap, 4LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference typesrc___ at 4 |
@@ -17657,7 +17546,7 @@ | ||
17657 | 17546 | LOCAL_PUSH_MOVE(&heap, 9LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
17658 | 17547 | } |
17659 | 17548 | // ACCUMULATE ARGUMENTS - END |
17660 | - uint64_t return_to = 18446744073709550837LLU; | |
17549 | + uint64_t return_to = 18446744073709550840LLU; | |
17661 | 17550 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 10LLU, 0/*address of closure-in-construction*/, 0)); |
17662 | 17551 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
17663 | 17552 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 10LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -17666,16 +17555,16 @@ | ||
17666 | 17555 | state.addr = 621705621980315648LLU; // getdef____ |
17667 | 17556 | break; |
17668 | 17557 | } |
17669 | - case 18446744073709550837LLU: // 99999999xz''''''''''''''' | |
17558 | + case 18446744073709550840LLU: // 99999999x2''''''''''''''' | |
17670 | 17559 | { |
17671 | 17560 | |
17672 | 17561 | list_size(heap.data, &*LOCAL_ACCESS(heap.data, 14LLU, 6LLU), /*mainresult*/*LOCAL_ACCESS(heap.data, 14LLU, 9LLU)); |
17673 | 17562 | |
17674 | 17563 | list_size(heap.data, &*LOCAL_ACCESS(heap.data, 14LLU, 7LLU), /*mainargs__*/*LOCAL_ACCESS(heap.data, 14LLU, 10LLU)); |
17675 | - state.addr = /*mainresult*/*LOCAL_ACCESS(heap.data, 14LLU, 9LLU) ? 18446744073709550836LLU : 18446744073709550835LLU; | |
17564 | + state.addr = /*mainresult*/*LOCAL_ACCESS(heap.data, 14LLU, 9LLU) ? 18446744073709550839LLU : 18446744073709550838LLU; | |
17676 | 17565 | break; |
17677 | 17566 | } |
17678 | - case 18446744073709550836LLU: // 99999999xy''''''''''''''' | |
17567 | + case 18446744073709550839LLU: // 99999999x1''''''''''''''' | |
17679 | 17568 | { |
17680 | 17569 | { |
17681 | 17570 | uint64_t arg = list_pop_move(&heap, &*LOCAL_ACCESS(heap.data, 14LLU, 9LLU)/*list*/, 8); |
@@ -17707,7 +17596,7 @@ | ||
17707 | 17596 | LOCAL_PUSH_MOVE(&heap, 1LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
17708 | 17597 | } |
17709 | 17598 | // ACCUMULATE ARGUMENTS - END |
17710 | - uint64_t return_to = 18446744073709550830LLU; | |
17599 | + uint64_t return_to = 18446744073709550833LLU; | |
17711 | 17600 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)); |
17712 | 17601 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
17713 | 17602 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 2LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -17716,18 +17605,18 @@ | ||
17716 | 17605 | state.addr = 661681486948204544LLU; // isu64_____ |
17717 | 17606 | break; |
17718 | 17607 | } |
17719 | - case 18446744073709550830LLU: // 99999999xs''''''''''''''' | |
17608 | + case 18446744073709550833LLU: // 99999999xv''''''''''''''' | |
17720 | 17609 | { |
17721 | - state.addr = *LOCAL_ACCESS(heap.data, 19LLU, 18LLU) ? 18446744073709550833LLU : 18446744073709550832LLU; | |
17610 | + state.addr = *LOCAL_ACCESS(heap.data, 19LLU, 18LLU) ? 18446744073709550836LLU : 18446744073709550835LLU; | |
17722 | 17611 | (void)LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 19 |
17723 | 17612 | break; |
17724 | 17613 | } |
17725 | - case 18446744073709550833LLU: // 99999999xv''''''''''''''' | |
17614 | + case 18446744073709550836LLU: // 99999999xy''''''''''''''' | |
17726 | 17615 | { |
17727 | - state.addr = 18446744073709550831LLU; // 99999999xt''''''''''''''' | |
17616 | + state.addr = 18446744073709550834LLU; // 99999999xw''''''''''''''' | |
17728 | 17617 | break; |
17729 | 17618 | } |
17730 | - case 18446744073709550832LLU: // 99999999xu''''''''''''''' | |
17619 | + case 18446744073709550835LLU: // 99999999xx''''''''''''''' | |
17731 | 17620 | { |
17732 | 17621 | printid(stderr, /*mainid____*/*LOCAL_ACCESS(heap.data, 18LLU, 5LLU)); |
17733 | 17622 | fprintf(stderr, "%s", ": main-result must be of type u64 reference but found "); |
@@ -17737,7 +17626,7 @@ | ||
17737 | 17626 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
17738 | 17627 | } |
17739 | 17628 | // ACCUMULATE ARGUMENTS - END |
17740 | - uint64_t return_to = 18446744073709550829LLU; | |
17629 | + uint64_t return_to = 18446744073709550832LLU; | |
17741 | 17630 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
17742 | 17631 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
17743 | 17632 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -17746,16 +17635,16 @@ | ||
17746 | 17635 | state.addr = 819847183518878432LLU; // reporttype |
17747 | 17636 | break; |
17748 | 17637 | } |
17749 | - case 18446744073709550829LLU: // 99999999xr''''''''''''''' | |
17638 | + case 18446744073709550832LLU: // 99999999xu''''''''''''''' | |
17750 | 17639 | { |
17751 | 17640 | { |
17752 | 17641 | fprintf(stderr, "%s\n", ""); |
17753 | 17642 | exit(-1); |
17754 | 17643 | } |
17755 | - state.addr = 18446744073709550831LLU; // 99999999xt''''''''''''''' | |
17644 | + state.addr = 18446744073709550834LLU; // 99999999xw''''''''''''''' | |
17756 | 17645 | break; |
17757 | 17646 | } |
17758 | - case 18446744073709550831LLU: // 99999999xt''''''''''''''' | |
17647 | + case 18446744073709550834LLU: // 99999999xw''''''''''''''' | |
17759 | 17648 | { |
17760 | 17649 | { |
17761 | 17650 | uint64_t arg = 0; |
@@ -17762,16 +17651,16 @@ | ||
17762 | 17651 | LOCAL_PUSH_MOVE(&heap, 18, &(heap.data[0].elem1)/*address of current closure*/, &arg); |
17763 | 17652 | } |
17764 | 17653 | *LOCAL_ACCESS(heap.data, 19LLU, 18LLU) = /*reference_*/*access_heap(heap.data, *LOCAL_ACCESS(heap.data, 19LLU, 17LLU)); |
17765 | - state.addr = *LOCAL_ACCESS(heap.data, 19LLU, 18LLU) ? 18446744073709550828LLU : 18446744073709550827LLU; | |
17654 | + state.addr = *LOCAL_ACCESS(heap.data, 19LLU, 18LLU) ? 18446744073709550831LLU : 18446744073709550830LLU; | |
17766 | 17655 | (void)LOCAL_POP_MOVE(&heap, 19LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE temporary reference at 19 |
17767 | 17656 | break; |
17768 | 17657 | } |
17769 | - case 18446744073709550828LLU: // 99999999xq''''''''''''''' | |
17658 | + case 18446744073709550831LLU: // 99999999xt''''''''''''''' | |
17770 | 17659 | { |
17771 | - state.addr = 18446744073709550826LLU; // 99999999xo''''''''''''''' | |
17660 | + state.addr = 18446744073709550829LLU; // 99999999xr''''''''''''''' | |
17772 | 17661 | break; |
17773 | 17662 | } |
17774 | - case 18446744073709550827LLU: // 99999999xp''''''''''''''' | |
17663 | + case 18446744073709550830LLU: // 99999999xs''''''''''''''' | |
17775 | 17664 | { |
17776 | 17665 | printid(stderr, /*mainid____*/*LOCAL_ACCESS(heap.data, 18LLU, 5LLU)); |
17777 | 17666 | fprintf(stderr, "%s", ": main-result must be of type u64 reference but found "); |
@@ -17781,7 +17670,7 @@ | ||
17781 | 17670 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
17782 | 17671 | } |
17783 | 17672 | // ACCUMULATE ARGUMENTS - END |
17784 | - uint64_t return_to = 18446744073709550825LLU; | |
17673 | + uint64_t return_to = 18446744073709550828LLU; | |
17785 | 17674 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
17786 | 17675 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
17787 | 17676 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -17790,16 +17679,16 @@ | ||
17790 | 17679 | state.addr = 819847183518878432LLU; // reporttype |
17791 | 17680 | break; |
17792 | 17681 | } |
17793 | - case 18446744073709550825LLU: // 99999999xn''''''''''''''' | |
17682 | + case 18446744073709550828LLU: // 99999999xq''''''''''''''' | |
17794 | 17683 | { |
17795 | 17684 | { |
17796 | 17685 | fprintf(stderr, "%s\n", ""); |
17797 | 17686 | exit(-1); |
17798 | 17687 | } |
17799 | - state.addr = 18446744073709550826LLU; // 99999999xo''''''''''''''' | |
17688 | + state.addr = 18446744073709550829LLU; // 99999999xr''''''''''''''' | |
17800 | 17689 | break; |
17801 | 17690 | } |
17802 | - case 18446744073709550826LLU: // 99999999xo''''''''''''''' | |
17691 | + case 18446744073709550829LLU: // 99999999xr''''''''''''''' | |
17803 | 17692 | { |
17804 | 17693 | // parameter-reference u64 reference_ goes out of scope |
17805 | 17694 | (void)LOCAL_POP_MOVE(&heap, 18LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference reference_ at 18 |
@@ -17807,10 +17696,10 @@ | ||
17807 | 17696 | (void)LOCAL_POP_MOVE(&heap, 17LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference idx_______ at 17 |
17808 | 17697 | // parameter-reference type______ type______ goes out of scope |
17809 | 17698 | (void)LOCAL_POP_MOVE(&heap, 16LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference type______ at 16 |
17810 | - state.addr = /*mainresult*/*LOCAL_ACCESS(heap.data, 15LLU, 9LLU) ? 18446744073709550824LLU : 18446744073709550823LLU; | |
17699 | + state.addr = /*mainresult*/*LOCAL_ACCESS(heap.data, 15LLU, 9LLU) ? 18446744073709550827LLU : 18446744073709550826LLU; | |
17811 | 17700 | break; |
17812 | 17701 | } |
17813 | - case 18446744073709550824LLU: // 99999999xm''''''''''''''' | |
17702 | + case 18446744073709550827LLU: // 99999999xp''''''''''''''' | |
17814 | 17703 | { |
17815 | 17704 | { |
17816 | 17705 | uint64_t arg = list_pop_move(&heap, &*LOCAL_ACCESS(heap.data, 15LLU, 9LLU)/*list*/, 8); |
@@ -17822,7 +17711,7 @@ | ||
17822 | 17711 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
17823 | 17712 | } |
17824 | 17713 | // ACCUMULATE ARGUMENTS - END |
17825 | - uint64_t return_to = 18446744073709550821LLU; | |
17714 | + uint64_t return_to = 18446744073709550824LLU; | |
17826 | 17715 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
17827 | 17716 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
17828 | 17717 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -17831,7 +17720,7 @@ | ||
17831 | 17720 | state.addr = 819847183515949359LLU; // reportinit |
17832 | 17721 | break; |
17833 | 17722 | } |
17834 | - case 18446744073709550821LLU: // 99999999xj''''''''''''''' | |
17723 | + case 18446744073709550824LLU: // 99999999xm''''''''''''''' | |
17835 | 17724 | { |
17836 | 17725 | fprintf(stderr, "%s", "too many results, need exactly one"); |
17837 | 17726 | { |
@@ -17846,7 +17735,7 @@ | ||
17846 | 17735 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
17847 | 17736 | } |
17848 | 17737 | // ACCUMULATE ARGUMENTS - END |
17849 | - uint64_t return_to = 18446744073709550820LLU; | |
17738 | + uint64_t return_to = 18446744073709550823LLU; | |
17850 | 17739 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
17851 | 17740 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
17852 | 17741 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -17855,23 +17744,23 @@ | ||
17855 | 17744 | state.addr = 18446744073709551534LLU; // 999999998s''''''''''''''' |
17856 | 17745 | break; |
17857 | 17746 | } |
17858 | - case 18446744073709550820LLU: // 99999999xi''''''''''''''' | |
17747 | + case 18446744073709550823LLU: // 99999999xl''''''''''''''' | |
17859 | 17748 | { |
17860 | 17749 | (void)LOCAL_POP_MOVE(&heap, 16LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference mainres___ at 16 |
17861 | - state.addr = 18446744073709550822LLU; // 99999999xk''''''''''''''' | |
17750 | + state.addr = 18446744073709550825LLU; // 99999999xn''''''''''''''' | |
17862 | 17751 | break; |
17863 | 17752 | } |
17864 | - case 18446744073709550823LLU: // 99999999xl''''''''''''''' | |
17753 | + case 18446744073709550826LLU: // 99999999xo''''''''''''''' | |
17865 | 17754 | { |
17866 | - state.addr = 18446744073709550822LLU; // 99999999xk''''''''''''''' | |
17755 | + state.addr = 18446744073709550825LLU; // 99999999xn''''''''''''''' | |
17867 | 17756 | break; |
17868 | 17757 | } |
17869 | - case 18446744073709550822LLU: // 99999999xk''''''''''''''' | |
17758 | + case 18446744073709550825LLU: // 99999999xn''''''''''''''' | |
17870 | 17759 | { |
17871 | - state.addr = /*mainargs__*/*LOCAL_ACCESS(heap.data, 15LLU, 10LLU) ? 18446744073709550819LLU : 18446744073709550818LLU; | |
17760 | + state.addr = /*mainargs__*/*LOCAL_ACCESS(heap.data, 15LLU, 10LLU) ? 18446744073709550822LLU : 18446744073709550821LLU; | |
17872 | 17761 | break; |
17873 | 17762 | } |
17874 | - case 18446744073709550819LLU: // 99999999xh''''''''''''''' | |
17763 | + case 18446744073709550822LLU: // 99999999xk''''''''''''''' | |
17875 | 17764 | { |
17876 | 17765 | { |
17877 | 17766 | uint64_t arg = list_pop_move(&heap, &*LOCAL_ACCESS(heap.data, 15LLU, 10LLU)/*list*/, 11); |
@@ -17883,7 +17772,7 @@ | ||
17883 | 17772 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
17884 | 17773 | } |
17885 | 17774 | // ACCUMULATE ARGUMENTS - END |
17886 | - uint64_t return_to = 18446744073709550816LLU; | |
17775 | + uint64_t return_to = 18446744073709550819LLU; | |
17887 | 17776 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
17888 | 17777 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
17889 | 17778 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -17892,7 +17781,7 @@ | ||
17892 | 17781 | state.addr = 819847183515949359LLU; // reportinit |
17893 | 17782 | break; |
17894 | 17783 | } |
17895 | - case 18446744073709550816LLU: // 99999999xe''''''''''''''' | |
17784 | + case 18446744073709550819LLU: // 99999999xh''''''''''''''' | |
17896 | 17785 | { |
17897 | 17786 | fprintf(stderr, "%s", "too many arguments - expect none when result expected"); |
17898 | 17787 | { |
@@ -17907,7 +17796,7 @@ | ||
17907 | 17796 | LOCAL_PUSH_MOVE(&heap, 0LLU, &(heap.data[0].elem0)/*address of closure-in-construction*/, &arg); |
17908 | 17797 | } |
17909 | 17798 | // ACCUMULATE ARGUMENTS - END |
17910 | - uint64_t return_to = 18446744073709550815LLU; | |
17799 | + uint64_t return_to = 18446744073709550818LLU; | |
17911 | 17800 | const uint64_t restore = *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)); |
17912 | 17801 | uint64_t baseinfo = pair_move(&heap, &(heap.data[0].elem1)/*memory root*/, &return_to); |
17913 | 17802 | *access_heap(heap.data, tree_elem_addr_internal(heap.data, 1 + 1LLU, 0/*address of closure-in-construction*/, 0)) = baseinfo; |
@@ -17916,18 +17805,18 @@ | ||
17916 | 17805 | state.addr = 18446744073709551468LLU; // 999999997q''''''''''''''' |
17917 | 17806 | break; |
17918 | 17807 | } |
17919 | - case 18446744073709550815LLU: // 99999999xd''''''''''''''' | |
17808 | + case 18446744073709550818LLU: // 99999999xg''''''''''''''' | |
17920 | 17809 | { |
17921 | 17810 | (void)LOCAL_POP_MOVE(&heap, 16LLU, &(heap.data[0].elem1)/*address of current closure*/); // RELEASE reference mainarg___ at 16 |
17922 | - state.addr = 18446744073709550817LLU; // 99999999xf''''''''''''''' | |
17811 | + state.addr = 18446744073709550820LLU; // 99999999xi''''''''''''''' | |
17923 | 17812 | break; |
17924 | 17813 | } |
17925 | - case 18446744073709550818LLU: // 99999999xg''''''''''''''' | |
17814 | + case 18446744073709550821LLU: // 99999999xj''''''''''''''' | |
17926 | 17815 | { |
17927 | - state.addr = 18446744073709550817LLU; // 99999999xf''''''''''''''' | |
17816 | + state.addr = 18446744073709550820L |
Part of diff was cut off due to size limit. Use your local client to view the full diff.