@salang/sa 0.1.3 → 0.1.4

package/sa_std/binary_heap.sa

@@ -0,0 +1,3003 @@
+// Concrete u64 max-heap with grow-on-demand storage.
+@import "core/mem.sa"
+@import "core/slice.sal"
+@import "core/slice.sa"
+@import "core/iter.sa"
+@import "alloc/vec.sal"
+@import "vec.sa"
+@import "num.sa"
+@import "binary_heap.sal"
+
+@binary_heap_swap(&heap: ptr, lhs: u64, rhs: u64) -> void:
+L_ENTRY:
+    buf = take heap+BinaryHeap_buf
+    lhs_off = mul lhs, BinaryHeap_SLOT_SIZE
+    rhs_off = mul rhs, BinaryHeap_SLOT_SIZE
+    lhs_ptr = ptr_add buf, lhs_off
+    rhs_ptr = ptr_add buf, rhs_off
+    lhs_value = load lhs_ptr+0 as u64
+    rhs_value = load rhs_ptr+0 as u64
+    store lhs_ptr+0, rhs_value as u64
+    store rhs_ptr+0, lhs_value as u64
+    !lhs_value
+    !rhs_value
+    !lhs_ptr
+    !rhs_ptr
+    !lhs_off
+    !rhs_off
+    !buf
+    !rhs
+    !lhs
+    !heap
+    return
+
+@export sa_binary_heap_new() -> ^ptr:
+L_ENTRY:
+    heap = alloc BinaryHeap_SIZE
+    initial_bytes = mul BinaryHeap_INITIAL_CAP, BinaryHeap_SLOT_SIZE
+    buf = alloc initial_bytes
+    call @sa_mem_set(&buf, 0, initial_bytes)
+    store heap+BinaryHeap_buf, buf as ptr
+    store heap+BinaryHeap_cap, BinaryHeap_INITIAL_CAP as u64
+    store heap+BinaryHeap_len, 0 as u64
+    ^buf
+    !initial_bytes
+    return heap
+
+@binary_heap_next_capacity(requested: u64) -> u64:
+L_ENTRY:
+    cap = BinaryHeap_INITIAL_CAP
+    requested_is_zero = eq requested, 0
+    br requested_is_zero -> L_NEXT_CAP_ZERO, L_NEXT_CAP_LOOP
+
+L_NEXT_CAP_LOOP:
+    cap_ge_requested = uge cap, requested
+    br cap_ge_requested -> L_NEXT_CAP_DONE, L_NEXT_CAP_GROW
+
+L_NEXT_CAP_GROW:
+    EXPAND NUM_U64_CHECKED_ADD next_cap_ok, next_cap, cap, cap
+    br next_cap_ok -> L_NEXT_CAP_GROW_OK, L_NEXT_CAP_OVERFLOW
+
+L_NEXT_CAP_OVERFLOW:
+    panic(1801)
+
+L_NEXT_CAP_GROW_OK:
+    cap = next_cap
+    !next_cap_ok
+    !cap_ge_requested
+    jmp L_NEXT_CAP_LOOP
+
+L_NEXT_CAP_DONE:
+    !cap_ge_requested
+    !requested_is_zero
+    !requested
+    return cap
+
+L_NEXT_CAP_ZERO:
+    !requested_is_zero
+    !requested
+    return 0
+
+@export sa_binary_heap_with_capacity(cap: u64) -> ^ptr:
+L_ENTRY:
+    heap = alloc BinaryHeap_SIZE
+    target_cap = call @binary_heap_next_capacity(cap)
+    target_zero = eq target_cap, 0
+    br target_zero -> L_WITH_CAP_EMPTY, L_WITH_CAP_ALLOC
+
+L_WITH_CAP_ALLOC:
+    EXPAND NUM_U64_CHECKED_MUL bytes_ok, bytes, target_cap, BinaryHeap_SLOT_SIZE
+    br bytes_ok -> L_WITH_CAP_ALLOC_BYTES_OK, L_WITH_CAP_ALLOC_OVERFLOW
+
+L_WITH_CAP_ALLOC_OVERFLOW:
+    panic(1802)
+
+L_WITH_CAP_ALLOC_BYTES_OK:
+    buf = alloc bytes
+    call @sa_mem_set(&buf, 0, bytes)
+    store heap+BinaryHeap_buf, buf as ptr
+    store heap+BinaryHeap_cap, target_cap as u64
+    store heap+BinaryHeap_len, 0 as u64
+    ^buf
+    !bytes_ok
+    !bytes
+    !target_zero
+    !target_cap
+    !cap
+    return heap
+
+L_WITH_CAP_EMPTY:
+    store heap+BinaryHeap_buf, 0 as ptr
+    store heap+BinaryHeap_cap, 0 as u64
+    store heap+BinaryHeap_len, 0 as u64
+    !target_zero
+    !target_cap
+    !cap
+    return heap
+
+@export sa_binary_heap_try_with_capacity(cap: u64, &out_heap_slot: ptr) -> i32:
+L_ENTRY:
+    heap = call @sa_binary_heap_with_capacity(cap)
+    store out_heap_slot+0, heap as ptr
+    !heap
+    !out_heap_slot
+    !cap
+    return 1
+
+@export sa_binary_heap_free(^heap: ptr) -> void:
+L_ENTRY:
+    buf = take heap+BinaryHeap_buf
+    !buf
+    !heap
+    return
+
+@export sa_binary_heap_len(&heap: ptr) -> u64:
+L_ENTRY:
+    len = load heap+BinaryHeap_len as u64
+    !heap
+    return len
+
+@export sa_binary_heap_capacity(&heap: ptr) -> u64:
+L_ENTRY:
+    cap = load heap+BinaryHeap_cap as u64
+    !heap
+    return cap
+
+@export sa_binary_heap_is_empty(&heap: ptr) -> i32:
+L_ENTRY:
+    len = load heap+BinaryHeap_len as u64
+    empty = eq len, 0
+    result = empty as i32
+    !len
+    !heap
+    return result
+
+@export sa_binary_heap_peek(&heap: ptr) -> u64:
+L_ENTRY:
+    len = load heap+BinaryHeap_len as u64
+    empty = eq len, 0
+    br empty -> L_EMPTY, L_HIT
+
+L_HIT:
+    buf = take heap+BinaryHeap_buf
+    root = load buf+0 as u64
+    !buf
+    !empty
+    !len
+    !heap
+    return root
+
+L_EMPTY:
+    !empty
+    !len
+    !heap
+    return 0
+
+@export sa_binary_heap_try_peek_mut_ptr(&heap: ptr, &out_ptr_slot: ptr) -> i32:
+L_ENTRY:
+    len = load heap+BinaryHeap_len as u64
+    empty = eq len, 0
+    br empty -> L_PEEK_MUT_EMPTY, L_PEEK_MUT_READY
+
+L_PEEK_MUT_READY:
+    buf = load heap+BinaryHeap_buf as ptr
+    store out_ptr_slot+0, buf as ptr
+    !buf
+    !empty
+    !len
+    !heap
+    !out_ptr_slot
+    return 1
+
+L_PEEK_MUT_EMPTY:
+    store out_ptr_slot+0, 0 as ptr
+    !empty
+    !len
+    !heap
+    !out_ptr_slot
+    return 0
+
+@export sa_binary_heap_try_peek_mut_set_u64(&heap: ptr, value: u64, &out_old_slot: ptr) -> i32:
+L_ENTRY:
+    len = load heap+BinaryHeap_len as u64
+    empty = eq len, 0
+    br empty -> L_PEEK_SET_EMPTY, L_PEEK_SET_READY
+
+L_PEEK_SET_READY:
+    buf = take heap+BinaryHeap_buf
+    old_value = load buf+0 as u64
+    store out_old_slot+0, old_value as u64
+    store buf+0, value as u64
+    call @binary_heap_sift_down(&heap, 0)
+    !old_value
+    !buf
+    !empty
+    !len
+    !value
+    !heap
+    !out_old_slot
+    return 1
+
+L_PEEK_SET_EMPTY:
+    store out_old_slot+0, 0 as u64
+    !empty
+    !len
+    !value
+    !heap
+    !out_old_slot
+    return 0
+
+@binary_heap_sift_up(&heap: ptr, index: u64) -> void:
+L_ENTRY:
+    is_root = eq index, 0
+    br is_root -> L_DONE_ROOT, L_BODY
+
+L_BODY:
+    idx_minus_one = sub index, 1
+    parent = udiv idx_minus_one, 2
+    buf = take heap+BinaryHeap_buf
+    child_off = mul index, BinaryHeap_SLOT_SIZE
+    parent_off = mul parent, BinaryHeap_SLOT_SIZE
+    child_ptr = ptr_add buf, child_off
+    parent_ptr = ptr_add buf, parent_off
+    child_value = load child_ptr+0 as u64
+    parent_value = load parent_ptr+0 as u64
+    should_swap = ugt child_value, parent_value
+    br should_swap -> L_SWAP, L_DONE_BODY
+
+L_SWAP:
+    call @binary_heap_swap(&heap, parent, index)
+    call @binary_heap_sift_up(&heap, parent)
+    !should_swap
+    !child_value
+    !parent_value
+    !child_ptr
+    !parent_ptr
+    !child_off
+    !parent_off
+    !idx_minus_one
+    !buf
+    !parent
+    !index
+    !is_root
+    !heap
+    return
+
+L_DONE_BODY:
+    !should_swap
+    !child_value
+    !parent_value
+    !child_ptr
+    !parent_ptr
+    !child_off
+    !parent_off
+    !idx_minus_one
+    !buf
+    !parent
+    !index
+    !is_root
+    !heap
+    return
+
+L_DONE_ROOT:
+    !is_root
+    !index
+    !heap
+    return
+
+@binary_heap_sift_down(&heap: ptr, index: u64) -> void:
+L_ENTRY:
+    len = load heap+BinaryHeap_len as u64
+    left_base = mul index, 2
+    left = add left_base, 1
+    has_left = ult left, len
+    br has_left -> L_BODY, L_DONE_SHORT
+
+L_BODY:
+    buf = take heap+BinaryHeap_buf
+    parent_off = mul index, BinaryHeap_SLOT_SIZE
+    parent_ptr = ptr_add buf, parent_off
+    parent_value = load parent_ptr+0 as u64
+    left_off = mul left, BinaryHeap_SLOT_SIZE
+    left_ptr = ptr_add buf, left_off
+    left_value = load left_ptr+0 as u64
+    right = add left, 1
+    has_right = ult right, len
+    br has_right -> L_RIGHT_BRANCH, L_LEFT_ONLY
+
+L_LEFT_ONLY:
+    should_swap = ugt left_value, parent_value
+    br should_swap -> L_SWAP_LEFT_ONLY, L_DONE_LEFT_ONLY
+
+L_RIGHT_BRANCH:
+    right_off = mul right, BinaryHeap_SLOT_SIZE
+    right_ptr = ptr_add buf, right_off
+    right_value = load right_ptr+0 as u64
+    right_bigger = ugt right_value, left_value
+    br right_bigger -> L_RIGHT_BIGGER, L_LEFT_BIGGER
+
+L_RIGHT_BIGGER:
+    should_swap = ugt right_value, parent_value
+    br should_swap -> L_SWAP_RIGHT, L_DONE_RIGHT_BRANCH
+
+L_LEFT_BIGGER:
+    should_swap = ugt left_value, parent_value
+    br should_swap -> L_SWAP_LEFT_RIGHT, L_DONE_RIGHT_BRANCH
+
+L_SWAP_RIGHT:
+    call @binary_heap_swap(&heap, index, right)
+    call @binary_heap_sift_down(&heap, right)
+    !should_swap
+    !right_bigger
+    !right_value
+    !right_ptr
+    !right_off
+    !has_right
+    !right
+    !left_value
+    !left_ptr
+    !left_off
+    !parent_value
+    !parent_ptr
+    !parent_off
+    !buf
+    !len
+    !left_base
+    !left
+    !index
+    !heap
+    return
+
+L_SWAP_LEFT_RIGHT:
+    call @binary_heap_swap(&heap, index, left)
+    call @binary_heap_sift_down(&heap, left)
+    !should_swap
+    !right_bigger
+    !right_value
+    !right_ptr
+    !right_off
+    !has_right
+    !right
+    !left_value
+    !left_ptr
+    !left_off
+    !parent_value
+    !parent_ptr
+    !parent_off
+    !buf
+    !len
+    !left_base
+    !left
+    !index
+    !heap
+    return
+
+L_SWAP_LEFT_ONLY:
+    call @binary_heap_swap(&heap, index, left)
+    call @binary_heap_sift_down(&heap, left)
+    !should_swap
+    !left_value
+    !left_ptr
+    !left_off
+    !parent_value
+    !parent_ptr
+    !parent_off
+    !buf
+    !len
+    !left_base
+    !left
+    !has_left
+    !index
+    !heap
+    return
+
+L_DONE_RIGHT_BRANCH:
+    !should_swap
+    !right_bigger
+    !right_value
+    !right_ptr
+    !right_off
+    !has_right
+    !right
+    !left_value
+    !left_ptr
+    !left_off
+    !parent_value
+    !parent_ptr
+    !parent_off
+    !buf
+    !len
+    !left_base
+    !left
+    !index
+    !heap
+    return
+
+L_DONE_LEFT_ONLY:
+    !should_swap
+    !left_value
+    !left_ptr
+    !left_off
+    !parent_value
+    !parent_ptr
+    !parent_off
+    !buf
+    !len
+    !left_base
+    !left
+    !has_left
+    !index
+    !heap
+    return
+
+L_DONE_SHORT:
+    !has_left
+    !left_base
+    !left
+    !len
+    !index
+    !heap
+    return
+
+@binary_heap_grow(&heap: ptr) -> void:
+L_ENTRY:
+    old_buf = take heap+BinaryHeap_buf
+    old_cap = load heap+BinaryHeap_cap as u64
+    old_len = load heap+BinaryHeap_len as u64
+    cap_is_zero = eq old_cap, 0
+    br cap_is_zero -> L_GROW_INIT, L_GROW_DOUBLE
+
+L_GROW_INIT:
+    next_cap_raw = BinaryHeap_INITIAL_CAP
+    next_cap = next_cap_raw
+    next_cap_ok = add 0, 1
+    jmp L_GROW_ALLOC
+
+L_GROW_DOUBLE:
+    EXPAND NUM_U64_CHECKED_ADD next_cap_ok, next_cap_raw, old_cap, old_cap
+    br next_cap_ok -> L_GROW_DOUBLE_OK, L_GROW_CAP_OVERFLOW
+
+L_GROW_CAP_OVERFLOW:
+    panic(1803)
+
+L_GROW_DOUBLE_OK:
+    next_cap = next_cap_raw
+    jmp L_GROW_ALLOC
+
+L_GROW_ALLOC:
+    EXPAND NUM_U64_CHECKED_MUL copy_bytes_ok, copy_bytes, old_len, BinaryHeap_SLOT_SIZE
+    br copy_bytes_ok -> L_GROW_COPY_BYTES_OK, L_GROW_COPY_BYTES_OVERFLOW
+
+L_GROW_COPY_BYTES_OVERFLOW:
+    panic(1804)
+
+L_GROW_COPY_BYTES_OK:
+    EXPAND NUM_U64_CHECKED_MUL new_bytes_ok, new_bytes, next_cap, BinaryHeap_SLOT_SIZE
+    br new_bytes_ok -> L_GROW_ALLOC_BYTES_OK, L_GROW_ALLOC_BYTES_OVERFLOW
+
+L_GROW_ALLOC_BYTES_OVERFLOW:
+    panic(1805)
+
+L_GROW_ALLOC_BYTES_OK:
+    new_buf = alloc new_bytes
+    call @sa_mem_copy(&new_buf, &old_buf, copy_bytes)
+    !new_bytes_ok
+    !copy_bytes_ok
+    !copy_bytes
+    !new_bytes
+    !old_len
+    !old_cap
+    !cap_is_zero
+    !old_buf
+    store heap+BinaryHeap_buf, new_buf as ptr
+    store heap+BinaryHeap_cap, next_cap as u64
+    ^new_buf
+    !next_cap_ok
+    !next_cap
+    !heap
+    return
+
+@binary_heap_realloc(&heap: ptr, target_cap: u64) -> void:
+L_ENTRY:
+    old_buf = take heap+BinaryHeap_buf
+    len = load heap+BinaryHeap_len as u64
+    target_zero = eq target_cap, 0
+    br target_zero -> L_REALLOC_EMPTY, L_REALLOC_ALLOC
+
+L_REALLOC_ALLOC:
+    EXPAND NUM_U64_CHECKED_MUL realloc_new_bytes_ok, new_bytes, target_cap, BinaryHeap_SLOT_SIZE
+    br realloc_new_bytes_ok -> L_REALLOC_NEW_BYTES_OK, L_REALLOC_NEW_BYTES_OVERFLOW
+
+L_REALLOC_NEW_BYTES_OVERFLOW:
+    panic(1806)
+
+L_REALLOC_NEW_BYTES_OK:
+    EXPAND NUM_U64_CHECKED_MUL realloc_copy_bytes_ok, copy_bytes, len, BinaryHeap_SLOT_SIZE
+    br realloc_copy_bytes_ok -> L_REALLOC_COPY_BYTES_OK, L_REALLOC_COPY_BYTES_OVERFLOW
+
+L_REALLOC_COPY_BYTES_OVERFLOW:
+    panic(1807)
+
+L_REALLOC_COPY_BYTES_OK:
+    new_buf = alloc new_bytes
+    call @sa_mem_set(&new_buf, 0, new_bytes)
+    call @sa_mem_copy(&new_buf, &old_buf, copy_bytes)
+    !realloc_copy_bytes_ok
+    !realloc_new_bytes_ok
+    !copy_bytes
+    !new_bytes
+    !old_buf
+    store heap+BinaryHeap_buf, new_buf as ptr
+    store heap+BinaryHeap_cap, target_cap as u64
+    ^new_buf
+    !target_zero
+    !len
+    !target_cap
+    !heap
+    return
+
+L_REALLOC_EMPTY:
+    !old_buf
+    store heap+BinaryHeap_buf, 0 as ptr
+    store heap+BinaryHeap_cap, 0 as u64
+    store heap+BinaryHeap_len, 0 as u64
+    !target_zero
+    !len
+    !target_cap
+    !heap
+    return
+
+@export sa_binary_heap_reserve(&heap: ptr, additional: u64) -> void:
+L_ENTRY:
+    len = load heap+BinaryHeap_len as u64
+    cap = load heap+BinaryHeap_cap as u64
+    EXPAND NUM_U64_CHECKED_ADD reserve_needed_ok, needed, len, additional
+    br reserve_needed_ok -> L_RESERVE_NEEDED_OK, L_RESERVE_OVERFLOW
+
+L_RESERVE_OVERFLOW:
+    panic(1810)
+
+L_RESERVE_NEEDED_OK:
+    has_room = uge cap, needed
+    br has_room -> L_RESERVE_DONE, L_RESERVE_GROW
+
+L_RESERVE_GROW:
+    target_cap = call @binary_heap_next_capacity(needed)
+    call @binary_heap_realloc(&heap, target_cap)
+    !target_cap
+    !has_room
+    !needed
+    !reserve_needed_ok
+    !cap
+    !len
+    !additional
+    !heap
+    return
+
+L_RESERVE_DONE:
+    !has_room
+    !needed
+    !reserve_needed_ok
+    !cap
+    !len
+    !additional
+    !heap
+    return
+
+@export sa_binary_heap_reserve_exact(&heap: ptr, additional: u64) -> void:
+L_ENTRY:
+    len = load heap+BinaryHeap_len as u64
+    cap = load heap+BinaryHeap_cap as u64
+    EXPAND NUM_U64_CHECKED_ADD reserve_exact_needed_ok, needed, len, additional
+    br reserve_exact_needed_ok -> L_RESERVE_EXACT_NEEDED_OK, L_RESERVE_EXACT_OVERFLOW
+
+L_RESERVE_EXACT_OVERFLOW:
+    panic(1811)
+
+L_RESERVE_EXACT_NEEDED_OK:
+    has_room = uge cap, needed
+    br has_room -> L_RESERVE_EXACT_DONE, L_RESERVE_EXACT_GROW
+
+L_RESERVE_EXACT_GROW:
+    call @binary_heap_realloc(&heap, needed)
+    !has_room
+    !needed
+    !reserve_exact_needed_ok
+    !cap
+    !len
+    !additional
+    !heap
+    return
+
+L_RESERVE_EXACT_DONE:
+    !has_room
+    !needed
+    !reserve_exact_needed_ok
+    !cap
+    !len
+    !additional
+    !heap
+    return
+
+@export sa_binary_heap_try_reserve(&heap: ptr, additional: u64) -> i32:
+L_ENTRY:
+    call @sa_binary_heap_reserve(&heap, additional)
+    !additional
+    !heap
+    return 1
+
+@export sa_binary_heap_try_reserve_exact(&heap: ptr, additional: u64) -> i32:
+L_ENTRY:
+    call @sa_binary_heap_reserve_exact(&heap, additional)
+    !additional
+    !heap
+    return 1
+
+@export sa_binary_heap_shrink_to(&heap: ptr, min_capacity: u64) -> void:
+L_ENTRY:
+    len = load heap+BinaryHeap_len as u64
+    cap = load heap+BinaryHeap_cap as u64
+    keep_len = uge len, min_capacity
+    br keep_len -> L_SHRINK_TO_LEN, L_SHRINK_TO_MIN
+
+L_SHRINK_TO_LEN:
+    target_cap = add len, 0
+    jmp L_SHRINK_TO_CHECK
+
+L_SHRINK_TO_MIN:
+    target_cap = add min_capacity, 0
+
+L_SHRINK_TO_CHECK:
+    needs_shrink = ult target_cap, cap
+    br needs_shrink -> L_SHRINK_TO_APPLY, L_SHRINK_TO_DONE
+
+L_SHRINK_TO_APPLY:
+    call @binary_heap_realloc(&heap, target_cap)
+    !needs_shrink
+    !target_cap
+    !keep_len
+    !cap
+    !len
+    !min_capacity
+    !heap
+    return
+
+L_SHRINK_TO_DONE:
+    !needs_shrink
+    !target_cap
+    !keep_len
+    !cap
+    !len
+    !min_capacity
+    !heap
+    return
+
+@export sa_binary_heap_shrink_to_fit(&heap: ptr) -> void:
+L_ENTRY:
+    len = load heap+BinaryHeap_len as u64
+    cap = load heap+BinaryHeap_cap as u64
+    needs_shrink = ne cap, len
+    br needs_shrink -> L_SHRINK, L_SHRINK_DONE
+
+L_SHRINK:
+    call @binary_heap_realloc(&heap, len)
+    !needs_shrink
+    !cap
+    !len
+    !heap
+    return
+
+L_SHRINK_DONE:
+    !needs_shrink
+    !cap
+    !len
+    !heap
+    return
+
+@export sa_binary_heap_as_slice(&heap: ptr, &out_slice: ptr) -> void:
+L_ENTRY:
+    buf = load heap+BinaryHeap_buf as ptr
+    len = load heap+BinaryHeap_len as u64
+    store out_slice+Slice_ptr, buf as ptr
+    store out_slice+Slice_len, len as u64
+    !len
+    !buf
+    !out_slice
+    !heap
+    return
+
+@export sa_binary_heap_as_mut_slice(&heap: ptr, &out_slice: ptr) -> void:
+L_ENTRY:
+    call @sa_binary_heap_as_slice(&heap, &out_slice)
+    !out_slice
+    !heap
+    return
+
+@export sa_binary_heap_into_vec(^heap: ptr) -> ^ptr:
+L_ENTRY:
+    return heap
+
+@export sa_binary_heap_into_sorted_vec(^heap: ptr) -> ^ptr:
+L_ENTRY:
+    len = load heap+BinaryHeap_len as u64
+    out_vec = alloc Vec_SIZE
+    EXPAND NUM_U64_CHECKED_MUL sort_bytes_ok, bytes, len, BinaryHeap_SLOT_SIZE
+    br sort_bytes_ok -> L_SORT_BYTES_OK, L_SORT_BYTES_OVERFLOW
+
+L_SORT_BYTES_OVERFLOW:
+    panic(1808)
+
+L_SORT_BYTES_OK:
+    has_bytes = ne bytes, 0
+    br has_bytes -> L_SORT_ALLOC, L_SORT_EMPTY
+
+L_SORT_ALLOC:
+    out_buf = alloc bytes
+    call @sa_mem_set(&out_buf, 0, bytes)
+    store out_vec+Vec_ptr, out_buf as ptr
+    ^out_buf
+    jmp L_SORT_INIT
+
+L_SORT_EMPTY:
+    store out_vec+Vec_ptr, 0 as ptr
+    jmp L_SORT_INIT
+
+L_SORT_INIT:
+    store out_vec+Vec_cap, len as u64
+    store out_vec+Vec_len, len as u64
+    idx_slot = stack_alloc 8
+    value_slot = stack_alloc 8
+    store idx_slot+0, len as u64
+    jmp L_SORT_HEAD
+
+L_SORT_HEAD:
+    idx = load idx_slot+0 as u64
+    done = eq idx, 0
+    br done -> L_SORT_DONE, L_SORT_BODY
+
+L_SORT_BODY:
+    next_idx = sub idx, 1
+    ok = call @sa_binary_heap_try_pop(&heap, &value_slot)
+    value = load value_slot+0 as u64
+    out_buf2 = load out_vec+Vec_ptr as ptr
+    off = mul next_idx, BinaryHeap_SLOT_SIZE
+    slot = ptr_add out_buf2, off
+    store slot+0, value as u64
+    store idx_slot+0, next_idx as u64
+    !slot
+    !off
+    !out_buf2
+    !value
+    !ok
+    !next_idx
+    !done
+    !idx
+    jmp L_SORT_HEAD
+
+L_SORT_DONE:
+    call @sa_binary_heap_free(^heap)
+    !done
+    !idx
+    !has_bytes
+    !sort_bytes_ok
+    !bytes
+    !len
+    return out_vec
+
+@export sa_binary_heap_push(&heap: ptr, value: u64) -> void:
+L_ENTRY:
+    len = load heap+BinaryHeap_len as u64
+    cap = load heap+BinaryHeap_cap as u64
+    room = ult len, cap
+    br room -> L_INSERT_RELEASE, L_GROW
+
+L_GROW:
+    call @binary_heap_grow(&heap)
+    !room
+    !cap
+    !len
+    jmp L_INSERT_WRITE
+
+L_INSERT_RELEASE:
+    !room
+    !cap
+    !len
+    jmp L_INSERT_WRITE
+
+L_INSERT_WRITE:
+    len2 = load heap+BinaryHeap_len as u64
+    buf = take heap+BinaryHeap_buf
+    slot_off = mul len2, BinaryHeap_SLOT_SIZE
+    slot = ptr_add buf, slot_off
+    store slot+0, value as u64
+    next_len = add len2, 1
+    store heap+BinaryHeap_len, next_len as u64
+    call @binary_heap_sift_up(&heap, len2)
+    !slot
+    !slot_off
+    !next_len
+    !buf
+    !len2
+    !value
+    !heap
+    return
+
+@export sa_binary_heap_try_pop(&heap: ptr, &out_value_slot: ptr) -> i32:
+L_ENTRY:
+    len = load heap+BinaryHeap_len as u64
+    empty = eq len, 0
+    br empty -> L_EMPTY, L_READY
+
+L_READY:
+    buf = take heap+BinaryHeap_buf
+    root_ptr = take heap+BinaryHeap_buf
+    value = load root_ptr+0 as u64
+    last_index = sub len, 1
+    last_off = mul last_index, BinaryHeap_SLOT_SIZE
+    last_ptr = ptr_add buf, last_off
+    last_value = load last_ptr+0 as u64
+    next_len = sub len, 1
+    store out_value_slot+0, value as u64
+    store heap+BinaryHeap_len, next_len as u64
+    store root_ptr+0, last_value as u64
+    call @binary_heap_sift_down(&heap, 0)
+    !last_value
+    !last_ptr
+    !last_off
+    !last_index
+    !value
+    !root_ptr
+    !next_len
+    !buf
+    !len
+    !empty
+    !out_value_slot
+    !heap
+    return 1
+
+L_EMPTY:
+    store out_value_slot+0, 0 as u64
+    !empty
+    !len
+    !out_value_slot
+    !heap
+    return 0
+
+@export sa_binary_heap_clear(&heap: ptr) -> void:
+L_ENTRY:
+    buf = take heap+BinaryHeap_buf
+    cap = load heap+BinaryHeap_cap as u64
+    EXPAND NUM_U64_CHECKED_MUL clear_bytes_ok, bytes, cap, BinaryHeap_SLOT_SIZE
+    br clear_bytes_ok -> L_CLEAR_BYTES_OK, L_CLEAR_BYTES_OVERFLOW
+
+L_CLEAR_BYTES_OVERFLOW:
+    panic(1809)
+
+L_CLEAR_BYTES_OK:
+    has_buf = ne buf, 0
+    br has_buf -> L_CLEAR_BUF, L_CLEAR_SKIP
+L_CLEAR_BUF:
+    call @sa_mem_set(&buf, 0, bytes)
+    !bytes
+    store heap+BinaryHeap_len, 0 as u64
+    !has_buf
+    !clear_bytes_ok
+    !buf
+    !cap
+    !heap
+    return
+L_CLEAR_SKIP:
+    !bytes
+    store heap+BinaryHeap_len, 0 as u64
+    !has_buf
+    !clear_bytes_ok
+    !buf
+    !cap
+    !heap
+    return
+
+@export sa_binary_heap_append(&heap: ptr, &other: ptr) -> void:
+L_ENTRY:
+    value_slot = stack_alloc 8
+    jmp L_APPEND_LOOP
+
+L_APPEND_LOOP:
+    ok = call @sa_binary_heap_try_pop(&other, &value_slot)
+    br ok -> L_APPEND_PUSH, L_APPEND_DONE
+
+L_APPEND_PUSH:
+    value = load value_slot+0 as u64
+    call @sa_binary_heap_push(&heap, value)
+    !value
+    !ok
+    jmp L_APPEND_LOOP
+
+L_APPEND_DONE:
+    !ok
+    !other
+    !heap
+    return
+
+[MACRO] BINARY_HEAP_NEW %out_heap
+    %out_heap = call @sa_binary_heap_new()
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_WITH_CAPACITY %out_heap, %cap
+    %out_heap = call @sa_binary_heap_with_capacity(%cap)
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_TRY_WITH_CAPACITY %out_ok, %out_heap, %cap
+    __binary_heap_try_new_slot_%out_ok = stack_alloc 8
+    %out_ok = call @sa_binary_heap_try_with_capacity(%cap, &__binary_heap_try_new_slot_%out_ok)
+    %out_heap = load __binary_heap_try_new_slot_%out_ok+0 as ptr
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_FREE %heap_reg
+    call @sa_binary_heap_free(^%heap_reg)
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_LEN %out_len, %heap_reg
+    %out_len = call @sa_binary_heap_len(&%heap_reg)
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_CAPACITY %out_cap, %heap_reg
+    %out_cap = call @sa_binary_heap_capacity(&%heap_reg)
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_RESERVE %heap_reg, %additional
+    call @sa_binary_heap_reserve(&%heap_reg, %additional)
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_RESERVE_EXACT %heap_reg, %additional
+    call @sa_binary_heap_reserve_exact(&%heap_reg, %additional)
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_TRY_RESERVE %out_ok, %heap_reg, %additional
+    %out_ok = call @sa_binary_heap_try_reserve(&%heap_reg, %additional)
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_TRY_RESERVE_EXACT %out_ok, %heap_reg, %additional
+    %out_ok = call @sa_binary_heap_try_reserve_exact(&%heap_reg, %additional)
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_SHRINK_TO %heap_reg, %min_capacity
+    call @sa_binary_heap_shrink_to(&%heap_reg, %min_capacity)
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_SHRINK_TO_FIT %heap_reg
+    call @sa_binary_heap_shrink_to_fit(&%heap_reg)
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_AS_SLICE %out_slice, %heap_reg
+    %out_slice = alloc Slice_SIZE
+    call @sa_binary_heap_as_slice(&%heap_reg, &%out_slice)
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_AS_MUT_SLICE %out_slice, %heap_reg
+    %out_slice = alloc Slice_SIZE
+    call @sa_binary_heap_as_mut_slice(&%heap_reg, &%out_slice)
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_ITER_U64 %out_iter, %heap_reg
+    __binary_heap_iter_slice_%out_iter = stack_alloc Slice_SIZE
+    call @sa_binary_heap_as_slice(&%heap_reg, &__binary_heap_iter_slice_%out_iter)
+    EXPAND ITER_FROM_SLICE %out_iter, __binary_heap_iter_slice_%out_iter
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_ITER_U64.
+[MACRO] BINARY_HEAP_ITER %out_iter, %heap_reg
+    EXPAND BINARY_HEAP_ITER_U64 %out_iter, %heap_reg
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_REF_INTO_ITER_U64 %out_iter, %heap_reg
+    EXPAND BINARY_HEAP_ITER_U64 %out_iter, %heap_reg
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_REF_INTO_ITER_U64.
+[MACRO] BINARY_HEAP_REF_INTO_ITER %out_iter, %heap_reg
+    EXPAND BINARY_HEAP_REF_INTO_ITER_U64 %out_iter, %heap_reg
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_ITER_DEFAULT_U64 %out_iter
+    __binary_heap_iter_default_slice_%out_iter = stack_alloc Slice_SIZE
+    EXPAND SLICE_NEW __binary_heap_iter_default_slice_%out_iter, 0, 0
+    EXPAND ITER_FROM_SLICE %out_iter, __binary_heap_iter_default_slice_%out_iter
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_ITER_DEFAULT_U64.
+[MACRO] BINARY_HEAP_ITER_DEFAULT %out_iter
+    EXPAND BINARY_HEAP_ITER_DEFAULT_U64 %out_iter
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_ITER_CLONE_U64 %out_iter, %iter_reg
+    EXPAND ITER_CLONE %out_iter, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_ITER_CLONE_U64.
+[MACRO] BINARY_HEAP_ITER_CLONE %out_iter, %iter_reg
+    EXPAND BINARY_HEAP_ITER_CLONE_U64 %out_iter, %iter_reg
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_ITER_NEXT_U64 %out_has, %out_value, %iter_reg
+    EXPAND ITER_NEXT_U64 %out_has, %out_value, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_ITER_NEXT_U64.
+[MACRO] BINARY_HEAP_ITER_NEXT %out_has, %out_value, %iter_reg
+    EXPAND BINARY_HEAP_ITER_NEXT_U64 %out_has, %out_value, %iter_reg
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_ITER_NEXT_BACK_U64 %out_has, %out_value, %iter_reg
+    EXPAND ITER_NEXT_BACK_U64 %out_has, %out_value, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_ITER_NEXT_BACK_U64.
+[MACRO] BINARY_HEAP_ITER_NEXT_BACK %out_has, %out_value, %iter_reg
+    EXPAND BINARY_HEAP_ITER_NEXT_BACK_U64 %out_has, %out_value, %iter_reg
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_ITER_NTH_U64 %out_has, %out_value, %iter_reg, %nth
+    EXPAND ITER_NTH_U64 %out_has, %out_value, %iter_reg, %nth
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_ITER_NTH_U64.
+[MACRO] BINARY_HEAP_ITER_NTH %out_has, %out_value, %iter_reg, %nth
+    EXPAND BINARY_HEAP_ITER_NTH_U64 %out_has, %out_value, %iter_reg, %nth
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_ITER_NTH_BACK_U64 %out_has, %out_value, %iter_reg, %nth
+    EXPAND ITER_NTH_BACK_U64 %out_has, %out_value, %iter_reg, %nth
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_ITER_NTH_BACK_U64.
+[MACRO] BINARY_HEAP_ITER_NTH_BACK %out_has, %out_value, %iter_reg, %nth
+    EXPAND BINARY_HEAP_ITER_NTH_BACK_U64 %out_has, %out_value, %iter_reg, %nth
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_ITER_TRY_NEXT_CHUNK_U64 %out_ok, %out_filled, %iter_reg, %dst_ptr, %count
+    EXPAND ITER_TRY_NEXT_CHUNK_U64 %out_ok, %out_filled, %iter_reg, %dst_ptr, %count
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_ITER_TRY_NEXT_CHUNK_U64.
+[MACRO] BINARY_HEAP_ITER_TRY_NEXT_CHUNK %out_ok, %out_filled, %iter_reg, %dst_ptr, %count
+    EXPAND BINARY_HEAP_ITER_TRY_NEXT_CHUNK_U64 %out_ok, %out_filled, %iter_reg, %dst_ptr, %count
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_ITER_ADVANCE_BY %out_ok, %out_remaining, %iter_reg, %count
+    EXPAND ITER_ADVANCE_BY %out_ok, %out_remaining, %iter_reg, %count
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_ITER_ADVANCE_BACK_BY %out_ok, %out_remaining, %iter_reg, %count
+    EXPAND ITER_ADVANCE_BACK_BY %out_ok, %out_remaining, %iter_reg, %count
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_ITER_COUNT_U64 %out_count, %iter_reg
+    EXPAND ITER_COUNT %out_count, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_ITER_COUNT_U64.
+[MACRO] BINARY_HEAP_ITER_COUNT %out_count, %iter_reg
+    EXPAND BINARY_HEAP_ITER_COUNT_U64 %out_count, %iter_reg
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_ITER_LAST_U64 %out_has, %out_value, %iter_reg
+    EXPAND ITER_LAST_U64 %out_has, %out_value, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_ITER_LAST_U64.
+[MACRO] BINARY_HEAP_ITER_LAST %out_has, %out_value, %iter_reg
+    EXPAND BINARY_HEAP_ITER_LAST_U64 %out_has, %out_value, %iter_reg
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_ITER_FIND_U64 %out_has, %out_value, %iter_reg, %pred_fn
+    EXPAND ITER_FIND_U64 %out_has, %out_value, %iter_reg, %pred_fn
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_ITER_FIND_U64.
+[MACRO] BINARY_HEAP_ITER_FIND %out_has, %out_value, %iter_reg, %pred_fn
+    EXPAND BINARY_HEAP_ITER_FIND_U64 %out_has, %out_value, %iter_reg, %pred_fn
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_ITER_TRY_FIND_U64 %out_ok, %out_has, %out_value, %iter_reg, %pred_fn
+    EXPAND ITER_TRY_FIND_U64 %out_ok, %out_has, %out_value, %iter_reg, %pred_fn
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_ITER_TRY_FIND_U64.
+[MACRO] BINARY_HEAP_ITER_TRY_FIND %out_ok, %out_has, %out_value, %iter_reg, %pred_fn
+    EXPAND BINARY_HEAP_ITER_TRY_FIND_U64 %out_ok, %out_has, %out_value, %iter_reg, %pred_fn
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_ITER_FIND_MAP_U64 %out_has, %out_value, %iter_reg, %map_fn
+    EXPAND ITER_FIND_MAP_U64 %out_has, %out_value, %iter_reg, %map_fn
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_ITER_FIND_MAP_U64.
+[MACRO] BINARY_HEAP_ITER_FIND_MAP %out_has, %out_value, %iter_reg, %map_fn
+    EXPAND BINARY_HEAP_ITER_FIND_MAP_U64 %out_has, %out_value, %iter_reg, %map_fn
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_ITER_POSITION_U64 %out_has, %out_index, %iter_reg, %pred_fn
+    EXPAND ITER_POSITION_U64 %out_has, %out_index, %iter_reg, %pred_fn
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_ITER_POSITION_U64.
+[MACRO] BINARY_HEAP_ITER_POSITION %out_has, %out_index, %iter_reg, %pred_fn
+    EXPAND BINARY_HEAP_ITER_POSITION_U64 %out_has, %out_index, %iter_reg, %pred_fn
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_ITER_RPOSITION_U64 %out_has, %out_index, %iter_reg, %pred_fn
+    EXPAND ITER_RPOSITION_U64 %out_has, %out_index, %iter_reg, %pred_fn
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_ITER_RPOSITION_U64.
+[MACRO] BINARY_HEAP_ITER_RPOSITION %out_has, %out_index, %iter_reg, %pred_fn
+    EXPAND BINARY_HEAP_ITER_RPOSITION_U64 %out_has, %out_index, %iter_reg, %pred_fn
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_ITER_RFIND_U64 %out_has, %out_value, %iter_reg, %pred_fn
+    EXPAND ITER_RFIND_U64 %out_has, %out_value, %iter_reg, %pred_fn
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_ITER_RFIND_U64.
+[MACRO] BINARY_HEAP_ITER_RFIND %out_has, %out_value, %iter_reg, %pred_fn
+    EXPAND BINARY_HEAP_ITER_RFIND_U64 %out_has, %out_value, %iter_reg, %pred_fn
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_ITER_ANY_U64 %out_bool, %iter_reg, %pred_fn
+    EXPAND ITER_ANY_U64 %out_bool, %iter_reg, %pred_fn
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_ITER_ANY_U64.
+[MACRO] BINARY_HEAP_ITER_ANY %out_bool, %iter_reg, %pred_fn
+    EXPAND BINARY_HEAP_ITER_ANY_U64 %out_bool, %iter_reg, %pred_fn
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_ITER_ALL_U64 %out_bool, %iter_reg, %pred_fn
+    EXPAND ITER_ALL_U64 %out_bool, %iter_reg, %pred_fn
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_ITER_ALL_U64.
+[MACRO] BINARY_HEAP_ITER_ALL %out_bool, %iter_reg, %pred_fn
+    EXPAND BINARY_HEAP_ITER_ALL_U64 %out_bool, %iter_reg, %pred_fn
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_ITER_FOR_EACH_U64 %iter_reg, %each_fn
+    EXPAND ITER_FOR_EACH_U64 %iter_reg, %each_fn
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_ITER_FOR_EACH_U64.
+[MACRO] BINARY_HEAP_ITER_FOR_EACH %iter_reg, %each_fn
+    EXPAND BINARY_HEAP_ITER_FOR_EACH_U64 %iter_reg, %each_fn
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_ITER_TRY_FOR_EACH_U64 %out_ok, %iter_reg, %each_fn
+    EXPAND ITER_TRY_FOR_EACH_U64 %out_ok, %iter_reg, %each_fn
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_ITER_TRY_FOR_EACH_U64.
+[MACRO] BINARY_HEAP_ITER_TRY_FOR_EACH %out_ok, %iter_reg, %each_fn
+    EXPAND BINARY_HEAP_ITER_TRY_FOR_EACH_U64 %out_ok, %iter_reg, %each_fn
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_ITER_FOLD_U64 %out_value, %iter_reg, %init_value, %fold_fn
+    EXPAND ITER_FOLD_U64 %out_value, %iter_reg, %init_value, %fold_fn
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_ITER_FOLD_U64.
+[MACRO] BINARY_HEAP_ITER_FOLD %out_value, %iter_reg, %init_value, %fold_fn
+    EXPAND BINARY_HEAP_ITER_FOLD_U64 %out_value, %iter_reg, %init_value, %fold_fn
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_ITER_TRY_FOLD_U64 %out_ok, %out_value, %iter_reg, %init_value, %fold_fn
+    EXPAND ITER_TRY_FOLD_U64 %out_ok, %out_value, %iter_reg, %init_value, %fold_fn
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_ITER_TRY_FOLD_U64.
+[MACRO] BINARY_HEAP_ITER_TRY_FOLD %out_ok, %out_value, %iter_reg, %init_value, %fold_fn
+    EXPAND BINARY_HEAP_ITER_TRY_FOLD_U64 %out_ok, %out_value, %iter_reg, %init_value, %fold_fn
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_ITER_RFOLD_U64 %out_value, %iter_reg, %init_value, %fold_fn
+    EXPAND ITER_RFOLD_U64 %out_value, %iter_reg, %init_value, %fold_fn
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_ITER_RFOLD_U64.
+[MACRO] BINARY_HEAP_ITER_RFOLD %out_value, %iter_reg, %init_value, %fold_fn
+    EXPAND BINARY_HEAP_ITER_RFOLD_U64 %out_value, %iter_reg, %init_value, %fold_fn
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_ITER_TRY_RFOLD_U64 %out_ok, %out_value, %iter_reg, %init_value, %fold_fn
+    EXPAND ITER_TRY_RFOLD_U64 %out_ok, %out_value, %iter_reg, %init_value, %fold_fn
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_ITER_TRY_RFOLD_U64.
+[MACRO] BINARY_HEAP_ITER_TRY_RFOLD %out_ok, %out_value, %iter_reg, %init_value, %fold_fn
+    EXPAND BINARY_HEAP_ITER_TRY_RFOLD_U64 %out_ok, %out_value, %iter_reg, %init_value, %fold_fn
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_ITER_SUM_U64 %out_value, %iter_reg
+    EXPAND ITER_SUM_U64 %out_value, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_ITER_SUM_U64.
+[MACRO] BINARY_HEAP_ITER_SUM %out_value, %iter_reg
+    EXPAND BINARY_HEAP_ITER_SUM_U64 %out_value, %iter_reg
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_ITER_PRODUCT_U64 %out_value, %iter_reg
+    EXPAND ITER_PRODUCT_U64 %out_value, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_ITER_PRODUCT_U64.
+[MACRO] BINARY_HEAP_ITER_PRODUCT %out_value, %iter_reg
+    EXPAND BINARY_HEAP_ITER_PRODUCT_U64 %out_value, %iter_reg
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_ITER_MIN_U64 %out_has, %out_value, %iter_reg
+    EXPAND ITER_MIN_U64 %out_has, %out_value, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_ITER_MIN_U64.
+[MACRO] BINARY_HEAP_ITER_MIN %out_has, %out_value, %iter_reg
+    EXPAND BINARY_HEAP_ITER_MIN_U64 %out_has, %out_value, %iter_reg
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_ITER_MAX_U64 %out_has, %out_value, %iter_reg
+    EXPAND ITER_MAX_U64 %out_has, %out_value, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_ITER_MAX_U64.
+[MACRO] BINARY_HEAP_ITER_MAX %out_has, %out_value, %iter_reg
+    EXPAND BINARY_HEAP_ITER_MAX_U64 %out_has, %out_value, %iter_reg
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_ITER_REDUCE_U64 %out_has, %out_value, %iter_reg, %reduce_fn
+    EXPAND ITER_REDUCE_U64 %out_has, %out_value, %iter_reg, %reduce_fn
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_ITER_REDUCE_U64.
+[MACRO] BINARY_HEAP_ITER_REDUCE %out_has, %out_value, %iter_reg, %reduce_fn
+    EXPAND BINARY_HEAP_ITER_REDUCE_U64 %out_has, %out_value, %iter_reg, %reduce_fn
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_ITER_TRY_REDUCE_U64 %out_ok, %out_has, %out_value, %iter_reg, %reduce_fn
+    EXPAND ITER_TRY_REDUCE_U64 %out_ok, %out_has, %out_value, %iter_reg, %reduce_fn
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_ITER_TRY_REDUCE_U64.
+[MACRO] BINARY_HEAP_ITER_TRY_REDUCE %out_ok, %out_has, %out_value, %iter_reg, %reduce_fn
+    EXPAND BINARY_HEAP_ITER_TRY_REDUCE_U64 %out_ok, %out_has, %out_value, %iter_reg, %reduce_fn
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_ITER_SIZE_HINT_U64 %out_lower, %out_upper, %iter_reg
+    EXPAND ITER_SIZE_HINT %out_lower, %out_upper, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_ITER_SIZE_HINT_U64.
+[MACRO] BINARY_HEAP_ITER_SIZE_HINT %out_lower, %out_upper, %iter_reg
+    EXPAND BINARY_HEAP_ITER_SIZE_HINT_U64 %out_lower, %out_upper, %iter_reg
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_ITER_EXACT_SIZE_LEN_U64 %out_len, %iter_reg
+    EXPAND ITER_EXACT_SIZE_LEN %out_len, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_ITER_EXACT_SIZE_LEN_U64.
+[MACRO] BINARY_HEAP_ITER_EXACT_SIZE_LEN %out_len, %iter_reg
+    EXPAND BINARY_HEAP_ITER_EXACT_SIZE_LEN_U64 %out_len, %iter_reg
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_ITER_EXACT_SIZE_IS_EMPTY_U64 %out_bool, %iter_reg
+    EXPAND ITER_EXACT_SIZE_IS_EMPTY %out_bool, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_ITER_EXACT_SIZE_IS_EMPTY_U64.
+[MACRO] BINARY_HEAP_ITER_EXACT_SIZE_IS_EMPTY %out_bool, %iter_reg
+    EXPAND BINARY_HEAP_ITER_EXACT_SIZE_IS_EMPTY_U64 %out_bool, %iter_reg
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_ITER_COLLECT_U64 %out_vec, %iter_reg
+    EXPAND ITER_COLLECT_U64 %out_vec, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_ITER_COLLECT_U64.
+[MACRO] BINARY_HEAP_ITER_COLLECT %out_vec, %iter_reg
+    EXPAND BINARY_HEAP_ITER_COLLECT_U64 %out_vec, %iter_reg
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_ITER_TRY_COLLECT_U64 %out_ok, %out_vec, %iter_reg, %try_fn
+    EXPAND ITER_TRY_COLLECT_U64 %out_ok, %out_vec, %iter_reg, %try_fn
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_ITER_TRY_COLLECT_U64.
+[MACRO] BINARY_HEAP_ITER_TRY_COLLECT %out_ok, %out_vec, %iter_reg, %try_fn
+    EXPAND BINARY_HEAP_ITER_TRY_COLLECT_U64 %out_ok, %out_vec, %iter_reg, %try_fn
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_ITER_COLLECT_INTO_U64 %vec_reg, %iter_reg
+    EXPAND ITER_COLLECT_INTO_U64 %vec_reg, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_ITER_COLLECT_INTO_U64.
+[MACRO] BINARY_HEAP_ITER_COLLECT_INTO %vec_reg, %iter_reg
+    EXPAND BINARY_HEAP_ITER_COLLECT_INTO_U64 %vec_reg, %iter_reg
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_VEC %out_vec, %heap_reg
+    %out_vec = call @sa_binary_heap_into_vec(^%heap_reg)
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_U64 %out_iter, %out_vec, %heap_reg
+    EXPAND BINARY_HEAP_INTO_VEC %out_vec, %heap_reg
+    EXPAND VEC_AS_SLICE __binary_heap_into_iter_slice_%out_iter, %out_vec
+    EXPAND ITER_FROM_SLICE %out_iter, __binary_heap_into_iter_slice_%out_iter
+    !__binary_heap_into_iter_slice_%out_iter
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_U64.
+[MACRO] BINARY_HEAP_INTO_ITER %out_iter, %out_vec, %heap_reg
+    EXPAND BINARY_HEAP_INTO_ITER_U64 %out_iter, %out_vec, %heap_reg
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_DEFAULT_U64 %out_iter, %out_vec
+    EXPAND VEC_INTO_ITER_DEFAULT_U64 %out_iter, %out_vec
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_DEFAULT_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_DEFAULT %out_iter, %out_vec
+    EXPAND BINARY_HEAP_INTO_ITER_DEFAULT_U64 %out_iter, %out_vec
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_NEXT_U64 %out_has, %out_value, %iter_reg
+    EXPAND ITER_NEXT_U64 %out_has, %out_value, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_NEXT_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_NEXT %out_has, %out_value, %iter_reg
+    EXPAND BINARY_HEAP_INTO_ITER_NEXT_U64 %out_has, %out_value, %iter_reg
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_NEXT_BACK_U64 %out_has, %out_value, %iter_reg
+    EXPAND ITER_NEXT_BACK_U64 %out_has, %out_value, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_NEXT_BACK_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_NEXT_BACK %out_has, %out_value, %iter_reg
+    EXPAND BINARY_HEAP_INTO_ITER_NEXT_BACK_U64 %out_has, %out_value, %iter_reg
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_NTH_U64 %out_has, %out_value, %iter_reg, %nth
+    EXPAND VEC_INTO_ITER_NTH_U64 %out_has, %out_value, %iter_reg, %nth
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_NTH_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_NTH %out_has, %out_value, %iter_reg, %nth
+    EXPAND BINARY_HEAP_INTO_ITER_NTH_U64 %out_has, %out_value, %iter_reg, %nth
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_NTH_BACK_U64 %out_has, %out_value, %iter_reg, %nth
+    EXPAND VEC_INTO_ITER_NTH_BACK_U64 %out_has, %out_value, %iter_reg, %nth
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_NTH_BACK_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_NTH_BACK %out_has, %out_value, %iter_reg, %nth
+    EXPAND BINARY_HEAP_INTO_ITER_NTH_BACK_U64 %out_has, %out_value, %iter_reg, %nth
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_TRY_NEXT_CHUNK_U64 %out_ok, %out_filled, %iter_reg, %dst_ptr, %count
+    EXPAND VEC_INTO_ITER_TRY_NEXT_CHUNK_U64 %out_ok, %out_filled, %iter_reg, %dst_ptr, %count
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_TRY_NEXT_CHUNK_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_TRY_NEXT_CHUNK %out_ok, %out_filled, %iter_reg, %dst_ptr, %count
+    EXPAND BINARY_HEAP_INTO_ITER_TRY_NEXT_CHUNK_U64 %out_ok, %out_filled, %iter_reg, %dst_ptr, %count
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_ADVANCE_BY %out_ok, %out_remaining, %iter_reg, %count
+    EXPAND VEC_INTO_ITER_ADVANCE_BY %out_ok, %out_remaining, %iter_reg, %count
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_ADVANCE_BACK_BY %out_ok, %out_remaining, %iter_reg, %count
+    EXPAND VEC_INTO_ITER_ADVANCE_BACK_BY %out_ok, %out_remaining, %iter_reg, %count
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_SIZE_HINT_U64 %out_lower, %out_upper, %iter_reg
+    EXPAND ITER_SIZE_HINT %out_lower, %out_upper, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_SIZE_HINT_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_SIZE_HINT %out_lower, %out_upper, %iter_reg
+    EXPAND BINARY_HEAP_INTO_ITER_SIZE_HINT_U64 %out_lower, %out_upper, %iter_reg
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_EXACT_SIZE_LEN_U64 %out_len, %iter_reg
+    EXPAND ITER_EXACT_SIZE_LEN %out_len, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_EXACT_SIZE_LEN_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_EXACT_SIZE_LEN %out_len, %iter_reg
+    EXPAND BINARY_HEAP_INTO_ITER_EXACT_SIZE_LEN_U64 %out_len, %iter_reg
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_EXACT_SIZE_IS_EMPTY_U64 %out_bool, %iter_reg
+    EXPAND ITER_EXACT_SIZE_IS_EMPTY %out_bool, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_EXACT_SIZE_IS_EMPTY_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_EXACT_SIZE_IS_EMPTY %out_bool, %iter_reg
+    EXPAND BINARY_HEAP_INTO_ITER_EXACT_SIZE_IS_EMPTY_U64 %out_bool, %iter_reg
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_COUNT_U64 %out_count, %iter_reg
+    EXPAND VEC_INTO_ITER_COUNT_U64 %out_count, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_COUNT_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_COUNT %out_count, %iter_reg
+    EXPAND BINARY_HEAP_INTO_ITER_COUNT_U64 %out_count, %iter_reg
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_LAST_U64 %out_has, %out_value, %iter_reg
+    EXPAND VEC_INTO_ITER_LAST_U64 %out_has, %out_value, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_LAST_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_LAST %out_has, %out_value, %iter_reg
+    EXPAND BINARY_HEAP_INTO_ITER_LAST_U64 %out_has, %out_value, %iter_reg
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_CLONE_U64 %out_iter, %out_vec, %iter_reg
+    EXPAND VEC_INTO_ITER_CLONE_U64 %out_iter, %out_vec, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_CLONE_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_CLONE %out_iter, %out_vec, %iter_reg
+    EXPAND BINARY_HEAP_INTO_ITER_CLONE_U64 %out_iter, %out_vec, %iter_reg
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_COLLECT_U64 %out_vec, %iter_reg
+    EXPAND ITER_COLLECT_U64 %out_vec, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_COLLECT_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_COLLECT %out_vec, %iter_reg
+    EXPAND BINARY_HEAP_INTO_ITER_COLLECT_U64 %out_vec, %iter_reg
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_TRY_COLLECT_U64 %out_ok, %out_vec, %iter_reg, %try_fn
+    EXPAND ITER_TRY_COLLECT_U64 %out_ok, %out_vec, %iter_reg, %try_fn
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_TRY_COLLECT_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_TRY_COLLECT %out_ok, %out_vec, %iter_reg, %try_fn
+    EXPAND BINARY_HEAP_INTO_ITER_TRY_COLLECT_U64 %out_ok, %out_vec, %iter_reg, %try_fn
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_COLLECT_INTO_U64 %vec_reg, %iter_reg
+    EXPAND ITER_COLLECT_INTO_U64 %vec_reg, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_COLLECT_INTO_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_COLLECT_INTO %vec_reg, %iter_reg
+    EXPAND BINARY_HEAP_INTO_ITER_COLLECT_INTO_U64 %vec_reg, %iter_reg
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_FIND_U64 %out_has, %out_value, %iter_reg, %pred_fn
+    EXPAND VEC_INTO_ITER_FIND_U64 %out_has, %out_value, %iter_reg, %pred_fn
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_FIND_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_FIND %out_has, %out_value, %iter_reg, %pred_fn
+    EXPAND BINARY_HEAP_INTO_ITER_FIND_U64 %out_has, %out_value, %iter_reg, %pred_fn
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_TRY_FIND_U64 %out_ok, %out_has, %out_value, %iter_reg, %pred_fn
+    EXPAND VEC_INTO_ITER_TRY_FIND_U64 %out_ok, %out_has, %out_value, %iter_reg, %pred_fn
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_TRY_FIND_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_TRY_FIND %out_ok, %out_has, %out_value, %iter_reg, %pred_fn
+    EXPAND BINARY_HEAP_INTO_ITER_TRY_FIND_U64 %out_ok, %out_has, %out_value, %iter_reg, %pred_fn
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_FIND_MAP_U64 %out_has, %out_value, %iter_reg, %map_fn
+    EXPAND VEC_INTO_ITER_FIND_MAP_U64 %out_has, %out_value, %iter_reg, %map_fn
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_FIND_MAP_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_FIND_MAP %out_has, %out_value, %iter_reg, %map_fn
+    EXPAND BINARY_HEAP_INTO_ITER_FIND_MAP_U64 %out_has, %out_value, %iter_reg, %map_fn
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_POSITION_U64 %out_has, %out_index, %iter_reg, %pred_fn
+    EXPAND VEC_INTO_ITER_POSITION_U64 %out_has, %out_index, %iter_reg, %pred_fn
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_POSITION_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_POSITION %out_has, %out_index, %iter_reg, %pred_fn
+    EXPAND BINARY_HEAP_INTO_ITER_POSITION_U64 %out_has, %out_index, %iter_reg, %pred_fn
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_RPOSITION_U64 %out_has, %out_index, %iter_reg, %pred_fn
+    EXPAND VEC_INTO_ITER_RPOSITION_U64 %out_has, %out_index, %iter_reg, %pred_fn
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_RPOSITION_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_RPOSITION %out_has, %out_index, %iter_reg, %pred_fn
+    EXPAND BINARY_HEAP_INTO_ITER_RPOSITION_U64 %out_has, %out_index, %iter_reg, %pred_fn
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_RFIND_U64 %out_has, %out_value, %iter_reg, %pred_fn
+    EXPAND VEC_INTO_ITER_RFIND_U64 %out_has, %out_value, %iter_reg, %pred_fn
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_RFIND_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_RFIND %out_has, %out_value, %iter_reg, %pred_fn
+    EXPAND BINARY_HEAP_INTO_ITER_RFIND_U64 %out_has, %out_value, %iter_reg, %pred_fn
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_ANY_U64 %out_bool, %iter_reg, %pred_fn
+    EXPAND VEC_INTO_ITER_ANY_U64 %out_bool, %iter_reg, %pred_fn
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_ANY_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_ANY %out_bool, %iter_reg, %pred_fn
+    EXPAND BINARY_HEAP_INTO_ITER_ANY_U64 %out_bool, %iter_reg, %pred_fn
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_ALL_U64 %out_bool, %iter_reg, %pred_fn
+    EXPAND VEC_INTO_ITER_ALL_U64 %out_bool, %iter_reg, %pred_fn
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_ALL_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_ALL %out_bool, %iter_reg, %pred_fn
+    EXPAND BINARY_HEAP_INTO_ITER_ALL_U64 %out_bool, %iter_reg, %pred_fn
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_FOR_EACH_U64 %iter_reg, %each_fn
+    EXPAND VEC_INTO_ITER_FOR_EACH_U64 %iter_reg, %each_fn
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_FOR_EACH_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_FOR_EACH %iter_reg, %each_fn
+    EXPAND BINARY_HEAP_INTO_ITER_FOR_EACH_U64 %iter_reg, %each_fn
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_TRY_FOR_EACH_U64 %out_ok, %iter_reg, %each_fn
+    EXPAND VEC_INTO_ITER_TRY_FOR_EACH_U64 %out_ok, %iter_reg, %each_fn
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_TRY_FOR_EACH_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_TRY_FOR_EACH %out_ok, %iter_reg, %each_fn
+    EXPAND BINARY_HEAP_INTO_ITER_TRY_FOR_EACH_U64 %out_ok, %iter_reg, %each_fn
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_FOLD_U64 %out_value, %iter_reg, %init_value, %fold_fn
+    EXPAND VEC_INTO_ITER_FOLD_U64 %out_value, %iter_reg, %init_value, %fold_fn
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_FOLD_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_FOLD %out_value, %iter_reg, %init_value, %fold_fn
+    EXPAND BINARY_HEAP_INTO_ITER_FOLD_U64 %out_value, %iter_reg, %init_value, %fold_fn
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_TRY_FOLD_U64 %out_ok, %out_value, %iter_reg, %init_value, %fold_fn
+    EXPAND VEC_INTO_ITER_TRY_FOLD_U64 %out_ok, %out_value, %iter_reg, %init_value, %fold_fn
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_TRY_FOLD_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_TRY_FOLD %out_ok, %out_value, %iter_reg, %init_value, %fold_fn
+    EXPAND BINARY_HEAP_INTO_ITER_TRY_FOLD_U64 %out_ok, %out_value, %iter_reg, %init_value, %fold_fn
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_RFOLD_U64 %out_value, %iter_reg, %init_value, %fold_fn
+    EXPAND VEC_INTO_ITER_RFOLD_U64 %out_value, %iter_reg, %init_value, %fold_fn
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_RFOLD_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_RFOLD %out_value, %iter_reg, %init_value, %fold_fn
+    EXPAND BINARY_HEAP_INTO_ITER_RFOLD_U64 %out_value, %iter_reg, %init_value, %fold_fn
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_TRY_RFOLD_U64 %out_ok, %out_value, %iter_reg, %init_value, %fold_fn
+    EXPAND VEC_INTO_ITER_TRY_RFOLD_U64 %out_ok, %out_value, %iter_reg, %init_value, %fold_fn
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_TRY_RFOLD_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_TRY_RFOLD %out_ok, %out_value, %iter_reg, %init_value, %fold_fn
+    EXPAND BINARY_HEAP_INTO_ITER_TRY_RFOLD_U64 %out_ok, %out_value, %iter_reg, %init_value, %fold_fn
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_SUM_U64 %out_value, %iter_reg
+    EXPAND VEC_INTO_ITER_SUM_U64 %out_value, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_SUM_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_SUM %out_value, %iter_reg
+    EXPAND BINARY_HEAP_INTO_ITER_SUM_U64 %out_value, %iter_reg
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_PRODUCT_U64 %out_value, %iter_reg
+    EXPAND VEC_INTO_ITER_PRODUCT_U64 %out_value, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_PRODUCT_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_PRODUCT %out_value, %iter_reg
+    EXPAND BINARY_HEAP_INTO_ITER_PRODUCT_U64 %out_value, %iter_reg
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_MIN_U64 %out_has, %out_value, %iter_reg
+    EXPAND VEC_INTO_ITER_MIN_U64 %out_has, %out_value, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_MIN_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_MIN %out_has, %out_value, %iter_reg
+    EXPAND BINARY_HEAP_INTO_ITER_MIN_U64 %out_has, %out_value, %iter_reg
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_MAX_U64 %out_has, %out_value, %iter_reg
+    EXPAND VEC_INTO_ITER_MAX_U64 %out_has, %out_value, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_MAX_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_MAX %out_has, %out_value, %iter_reg
+    EXPAND BINARY_HEAP_INTO_ITER_MAX_U64 %out_has, %out_value, %iter_reg
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_REDUCE_U64 %out_has, %out_value, %iter_reg, %reduce_fn
+    EXPAND VEC_INTO_ITER_REDUCE_U64 %out_has, %out_value, %iter_reg, %reduce_fn
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_REDUCE_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_REDUCE %out_has, %out_value, %iter_reg, %reduce_fn
+    EXPAND BINARY_HEAP_INTO_ITER_REDUCE_U64 %out_has, %out_value, %iter_reg, %reduce_fn
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_TRY_REDUCE_U64 %out_ok, %out_has, %out_value, %iter_reg, %reduce_fn
+    EXPAND VEC_INTO_ITER_TRY_REDUCE_U64 %out_ok, %out_has, %out_value, %iter_reg, %reduce_fn
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_TRY_REDUCE_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_TRY_REDUCE %out_ok, %out_has, %out_value, %iter_reg, %reduce_fn
+    EXPAND BINARY_HEAP_INTO_ITER_TRY_REDUCE_U64 %out_ok, %out_has, %out_value, %iter_reg, %reduce_fn
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_MIN_BY_U64 %out_has, %out_value, %iter_reg, %compare_fn
+    EXPAND VEC_INTO_ITER_MIN_BY_U64 %out_has, %out_value, %iter_reg, %compare_fn
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_MIN_BY_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_MIN_BY %out_has, %out_value, %iter_reg, %compare_fn
+    EXPAND BINARY_HEAP_INTO_ITER_MIN_BY_U64 %out_has, %out_value, %iter_reg, %compare_fn
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_MAX_BY_U64 %out_has, %out_value, %iter_reg, %compare_fn
+    EXPAND VEC_INTO_ITER_MAX_BY_U64 %out_has, %out_value, %iter_reg, %compare_fn
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_MAX_BY_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_MAX_BY %out_has, %out_value, %iter_reg, %compare_fn
+    EXPAND BINARY_HEAP_INTO_ITER_MAX_BY_U64 %out_has, %out_value, %iter_reg, %compare_fn
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_MIN_BY_KEY_U64 %out_has, %out_value, %iter_reg, %key_fn
+    EXPAND VEC_INTO_ITER_MIN_BY_KEY_U64 %out_has, %out_value, %iter_reg, %key_fn
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_MIN_BY_KEY_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_MIN_BY_KEY %out_has, %out_value, %iter_reg, %key_fn
+    EXPAND BINARY_HEAP_INTO_ITER_MIN_BY_KEY_U64 %out_has, %out_value, %iter_reg, %key_fn
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_MAX_BY_KEY_U64 %out_has, %out_value, %iter_reg, %key_fn
+    EXPAND VEC_INTO_ITER_MAX_BY_KEY_U64 %out_has, %out_value, %iter_reg, %key_fn
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_MAX_BY_KEY_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_MAX_BY_KEY %out_has, %out_value, %iter_reg, %key_fn
+    EXPAND BINARY_HEAP_INTO_ITER_MAX_BY_KEY_U64 %out_has, %out_value, %iter_reg, %key_fn
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_CMP_U64 %out_ordering, %left_iter, %right_iter
+    EXPAND VEC_INTO_ITER_CMP_U64 %out_ordering, %left_iter, %right_iter
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_CMP_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_CMP %out_ordering, %left_iter, %right_iter
+    EXPAND BINARY_HEAP_INTO_ITER_CMP_U64 %out_ordering, %left_iter, %right_iter
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_CMP_BY_U64 %out_ordering, %left_iter, %right_iter, %compare_fn
+    EXPAND VEC_INTO_ITER_CMP_BY_U64 %out_ordering, %left_iter, %right_iter, %compare_fn
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_CMP_BY_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_CMP_BY %out_ordering, %left_iter, %right_iter, %compare_fn
+    EXPAND BINARY_HEAP_INTO_ITER_CMP_BY_U64 %out_ordering, %left_iter, %right_iter, %compare_fn
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_PARTIAL_CMP_U64 %out_ordering, %left_iter, %right_iter
+    EXPAND VEC_INTO_ITER_PARTIAL_CMP_U64 %out_ordering, %left_iter, %right_iter
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_PARTIAL_CMP_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_PARTIAL_CMP %out_ordering, %left_iter, %right_iter
+    EXPAND BINARY_HEAP_INTO_ITER_PARTIAL_CMP_U64 %out_ordering, %left_iter, %right_iter
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_PARTIAL_CMP_BY_U64 %out_ok, %out_ordering, %left_iter, %right_iter, %compare_fn
+    EXPAND VEC_INTO_ITER_PARTIAL_CMP_BY_U64 %out_ok, %out_ordering, %left_iter, %right_iter, %compare_fn
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_PARTIAL_CMP_BY_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_PARTIAL_CMP_BY %out_ok, %out_ordering, %left_iter, %right_iter, %compare_fn
+    EXPAND BINARY_HEAP_INTO_ITER_PARTIAL_CMP_BY_U64 %out_ok, %out_ordering, %left_iter, %right_iter, %compare_fn
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_EQ_BY_U64 %out_bool, %left_iter, %right_iter, %eq_fn
+    EXPAND VEC_INTO_ITER_EQ_BY_U64 %out_bool, %left_iter, %right_iter, %eq_fn
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_EQ_BY_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_EQ_BY %out_bool, %left_iter, %right_iter, %eq_fn
+    EXPAND BINARY_HEAP_INTO_ITER_EQ_BY_U64 %out_bool, %left_iter, %right_iter, %eq_fn
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_EQ_U64 %out_bool, %left_iter, %right_iter
+    EXPAND VEC_INTO_ITER_EQ_U64 %out_bool, %left_iter, %right_iter
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_EQ_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_EQ %out_bool, %left_iter, %right_iter
+    EXPAND BINARY_HEAP_INTO_ITER_EQ_U64 %out_bool, %left_iter, %right_iter
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_PARTIAL_EQ_U64 %out_bool, %left_iter, %right_iter
+    EXPAND VEC_INTO_ITER_PARTIAL_EQ_U64 %out_bool, %left_iter, %right_iter
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_PARTIAL_EQ_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_PARTIAL_EQ %out_bool, %left_iter, %right_iter
+    EXPAND BINARY_HEAP_INTO_ITER_PARTIAL_EQ_U64 %out_bool, %left_iter, %right_iter
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_NE_U64 %out_bool, %left_iter, %right_iter
+    EXPAND VEC_INTO_ITER_NE_U64 %out_bool, %left_iter, %right_iter
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_NE_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_NE %out_bool, %left_iter, %right_iter
+    EXPAND BINARY_HEAP_INTO_ITER_NE_U64 %out_bool, %left_iter, %right_iter
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_LT_U64 %out_bool, %left_iter, %right_iter
+    EXPAND VEC_INTO_ITER_LT_U64 %out_bool, %left_iter, %right_iter
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_LT_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_LT %out_bool, %left_iter, %right_iter
+    EXPAND BINARY_HEAP_INTO_ITER_LT_U64 %out_bool, %left_iter, %right_iter
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_LE_U64 %out_bool, %left_iter, %right_iter
+    EXPAND VEC_INTO_ITER_LE_U64 %out_bool, %left_iter, %right_iter
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_LE_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_LE %out_bool, %left_iter, %right_iter
+    EXPAND BINARY_HEAP_INTO_ITER_LE_U64 %out_bool, %left_iter, %right_iter
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_GT_U64 %out_bool, %left_iter, %right_iter
+    EXPAND VEC_INTO_ITER_GT_U64 %out_bool, %left_iter, %right_iter
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_GT_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_GT %out_bool, %left_iter, %right_iter
+    EXPAND BINARY_HEAP_INTO_ITER_GT_U64 %out_bool, %left_iter, %right_iter
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_GE_U64 %out_bool, %left_iter, %right_iter
+    EXPAND VEC_INTO_ITER_GE_U64 %out_bool, %left_iter, %right_iter
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_GE_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_GE %out_bool, %left_iter, %right_iter
+    EXPAND BINARY_HEAP_INTO_ITER_GE_U64 %out_bool, %left_iter, %right_iter
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_SORTED_VEC %out_vec, %heap_reg
+    %out_vec = call @sa_binary_heap_into_sorted_vec(^%heap_reg)
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_U64 %out_iter, %out_vec, %heap_reg
+    EXPAND BINARY_HEAP_INTO_SORTED_VEC __binary_heap_sorted_vec_%out_iter, %heap_reg
+    EXPAND VEC_LEN __binary_heap_sorted_len_%out_iter, __binary_heap_sorted_vec_%out_iter
+    EXPAND VEC_WITH_CAPACITY_U64 %out_vec, __binary_heap_sorted_len_%out_iter
+    __binary_heap_sorted_idx_slot_%out_iter = stack_alloc 8
+    store __binary_heap_sorted_idx_slot_%out_iter+0, __binary_heap_sorted_len_%out_iter as u64
+    jmp L_BINARY_HEAP_INTO_ITER_SORTED_HEAD_%out_iter
+
+L_BINARY_HEAP_INTO_ITER_SORTED_HEAD_%out_iter:
+    __binary_heap_sorted_idx_%out_iter = load __binary_heap_sorted_idx_slot_%out_iter+0 as u64
+    __binary_heap_sorted_done_%out_iter = eq __binary_heap_sorted_idx_%out_iter, 0
+    br __binary_heap_sorted_done_%out_iter -> L_BINARY_HEAP_INTO_ITER_SORTED_BUILD_ITER_%out_iter, L_BINARY_HEAP_INTO_ITER_SORTED_BODY_%out_iter
+
+L_BINARY_HEAP_INTO_ITER_SORTED_BODY_%out_iter:
+    __binary_heap_sorted_prev_%out_iter = sub __binary_heap_sorted_idx_%out_iter, 1
+    EXPAND VEC_GET_U64 __binary_heap_sorted_value_%out_iter, __binary_heap_sorted_vec_%out_iter, __binary_heap_sorted_prev_%out_iter
+    EXPAND VEC_PUSH_U64 %out_vec, __binary_heap_sorted_value_%out_iter
+    store __binary_heap_sorted_idx_slot_%out_iter+0, __binary_heap_sorted_prev_%out_iter as u64
+    !__binary_heap_sorted_value_%out_iter
+    !__binary_heap_sorted_prev_%out_iter
+    !__binary_heap_sorted_done_%out_iter
+    !__binary_heap_sorted_idx_%out_iter
+    jmp L_BINARY_HEAP_INTO_ITER_SORTED_HEAD_%out_iter
+
+L_BINARY_HEAP_INTO_ITER_SORTED_BUILD_ITER_%out_iter:
+    EXPAND VEC_FREE __binary_heap_sorted_vec_%out_iter
+    EXPAND VEC_AS_SLICE __binary_heap_into_iter_sorted_slice_%out_iter, %out_vec
+    EXPAND ITER_FROM_SLICE %out_iter, __binary_heap_into_iter_sorted_slice_%out_iter
+    !__binary_heap_into_iter_sorted_slice_%out_iter
+    !__binary_heap_sorted_done_%out_iter
+    !__binary_heap_sorted_idx_%out_iter
+    !__binary_heap_sorted_len_%out_iter
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_SORTED_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED %out_iter, %out_vec, %heap_reg
+    EXPAND BINARY_HEAP_INTO_ITER_SORTED_U64 %out_iter, %out_vec, %heap_reg
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_NEXT_U64 %out_has, %out_value, %iter_reg
+    EXPAND ITER_NEXT_U64 %out_has, %out_value, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_SORTED_NEXT_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_NEXT %out_has, %out_value, %iter_reg
+    EXPAND BINARY_HEAP_INTO_ITER_SORTED_NEXT_U64 %out_has, %out_value, %iter_reg
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_NTH_U64 %out_has, %out_value, %iter_reg, %nth
+    EXPAND VEC_INTO_ITER_NTH_U64 %out_has, %out_value, %iter_reg, %nth
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_SORTED_NTH_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_NTH %out_has, %out_value, %iter_reg, %nth
+    EXPAND BINARY_HEAP_INTO_ITER_SORTED_NTH_U64 %out_has, %out_value, %iter_reg, %nth
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_TRY_NEXT_CHUNK_U64 %out_ok, %out_filled, %iter_reg, %dst_ptr, %count
+    EXPAND VEC_INTO_ITER_TRY_NEXT_CHUNK_U64 %out_ok, %out_filled, %iter_reg, %dst_ptr, %count
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_SORTED_TRY_NEXT_CHUNK_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_TRY_NEXT_CHUNK %out_ok, %out_filled, %iter_reg, %dst_ptr, %count
+    EXPAND BINARY_HEAP_INTO_ITER_SORTED_TRY_NEXT_CHUNK_U64 %out_ok, %out_filled, %iter_reg, %dst_ptr, %count
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_ADVANCE_BY %out_ok, %out_remaining, %iter_reg, %count
+    EXPAND VEC_INTO_ITER_ADVANCE_BY %out_ok, %out_remaining, %iter_reg, %count
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_SIZE_HINT_U64 %out_lower, %out_upper, %iter_reg
+    EXPAND ITER_SIZE_HINT %out_lower, %out_upper, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_SORTED_SIZE_HINT_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_SIZE_HINT %out_lower, %out_upper, %iter_reg
+    EXPAND BINARY_HEAP_INTO_ITER_SORTED_SIZE_HINT_U64 %out_lower, %out_upper, %iter_reg
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_EXACT_SIZE_LEN_U64 %out_len, %iter_reg
+    EXPAND ITER_EXACT_SIZE_LEN %out_len, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_SORTED_EXACT_SIZE_LEN_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_EXACT_SIZE_LEN %out_len, %iter_reg
+    EXPAND BINARY_HEAP_INTO_ITER_SORTED_EXACT_SIZE_LEN_U64 %out_len, %iter_reg
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_EXACT_SIZE_IS_EMPTY_U64 %out_bool, %iter_reg
+    EXPAND ITER_EXACT_SIZE_IS_EMPTY %out_bool, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_SORTED_EXACT_SIZE_IS_EMPTY_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_EXACT_SIZE_IS_EMPTY %out_bool, %iter_reg
+    EXPAND BINARY_HEAP_INTO_ITER_SORTED_EXACT_SIZE_IS_EMPTY_U64 %out_bool, %iter_reg
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_COUNT_U64 %out_count, %iter_reg
+    EXPAND VEC_INTO_ITER_COUNT_U64 %out_count, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_SORTED_COUNT_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_COUNT %out_count, %iter_reg
+    EXPAND BINARY_HEAP_INTO_ITER_SORTED_COUNT_U64 %out_count, %iter_reg
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_LAST_U64 %out_has, %out_value, %iter_reg
+    EXPAND VEC_INTO_ITER_LAST_U64 %out_has, %out_value, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_SORTED_LAST_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_LAST %out_has, %out_value, %iter_reg
+    EXPAND BINARY_HEAP_INTO_ITER_SORTED_LAST_U64 %out_has, %out_value, %iter_reg
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_FIND_U64 %out_has, %out_value, %iter_reg, %pred_fn
+    EXPAND VEC_INTO_ITER_FIND_U64 %out_has, %out_value, %iter_reg, %pred_fn
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_SORTED_FIND_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_FIND %out_has, %out_value, %iter_reg, %pred_fn
+    EXPAND BINARY_HEAP_INTO_ITER_SORTED_FIND_U64 %out_has, %out_value, %iter_reg, %pred_fn
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_TRY_FIND_U64 %out_ok, %out_has, %out_value, %iter_reg, %pred_fn
+    EXPAND VEC_INTO_ITER_TRY_FIND_U64 %out_ok, %out_has, %out_value, %iter_reg, %pred_fn
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_SORTED_TRY_FIND_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_TRY_FIND %out_ok, %out_has, %out_value, %iter_reg, %pred_fn
+    EXPAND BINARY_HEAP_INTO_ITER_SORTED_TRY_FIND_U64 %out_ok, %out_has, %out_value, %iter_reg, %pred_fn
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_FIND_MAP_U64 %out_has, %out_value, %iter_reg, %map_fn
+    EXPAND VEC_INTO_ITER_FIND_MAP_U64 %out_has, %out_value, %iter_reg, %map_fn
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_SORTED_FIND_MAP_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_FIND_MAP %out_has, %out_value, %iter_reg, %map_fn
+    EXPAND BINARY_HEAP_INTO_ITER_SORTED_FIND_MAP_U64 %out_has, %out_value, %iter_reg, %map_fn
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_POSITION_U64 %out_has, %out_index, %iter_reg, %pred_fn
+    EXPAND VEC_INTO_ITER_POSITION_U64 %out_has, %out_index, %iter_reg, %pred_fn
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_SORTED_POSITION_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_POSITION %out_has, %out_index, %iter_reg, %pred_fn
+    EXPAND BINARY_HEAP_INTO_ITER_SORTED_POSITION_U64 %out_has, %out_index, %iter_reg, %pred_fn
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_ANY_U64 %out_bool, %iter_reg, %pred_fn
+    EXPAND VEC_INTO_ITER_ANY_U64 %out_bool, %iter_reg, %pred_fn
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_SORTED_ANY_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_ANY %out_bool, %iter_reg, %pred_fn
+    EXPAND BINARY_HEAP_INTO_ITER_SORTED_ANY_U64 %out_bool, %iter_reg, %pred_fn
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_ALL_U64 %out_bool, %iter_reg, %pred_fn
+    EXPAND VEC_INTO_ITER_ALL_U64 %out_bool, %iter_reg, %pred_fn
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_SORTED_ALL_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_ALL %out_bool, %iter_reg, %pred_fn
+    EXPAND BINARY_HEAP_INTO_ITER_SORTED_ALL_U64 %out_bool, %iter_reg, %pred_fn
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_FOR_EACH_U64 %iter_reg, %each_fn
+    EXPAND VEC_INTO_ITER_FOR_EACH_U64 %iter_reg, %each_fn
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_SORTED_FOR_EACH_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_FOR_EACH %iter_reg, %each_fn
+    EXPAND BINARY_HEAP_INTO_ITER_SORTED_FOR_EACH_U64 %iter_reg, %each_fn
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_TRY_FOR_EACH_U64 %out_ok, %iter_reg, %each_fn
+    EXPAND VEC_INTO_ITER_TRY_FOR_EACH_U64 %out_ok, %iter_reg, %each_fn
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_SORTED_TRY_FOR_EACH_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_TRY_FOR_EACH %out_ok, %iter_reg, %each_fn
+    EXPAND BINARY_HEAP_INTO_ITER_SORTED_TRY_FOR_EACH_U64 %out_ok, %iter_reg, %each_fn
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_FOLD_U64 %out_value, %iter_reg, %init_value, %fold_fn
+    EXPAND VEC_INTO_ITER_FOLD_U64 %out_value, %iter_reg, %init_value, %fold_fn
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_SORTED_FOLD_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_FOLD %out_value, %iter_reg, %init_value, %fold_fn
+    EXPAND BINARY_HEAP_INTO_ITER_SORTED_FOLD_U64 %out_value, %iter_reg, %init_value, %fold_fn
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_TRY_FOLD_U64 %out_ok, %out_value, %iter_reg, %init_value, %fold_fn
+    EXPAND VEC_INTO_ITER_TRY_FOLD_U64 %out_ok, %out_value, %iter_reg, %init_value, %fold_fn
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_SORTED_TRY_FOLD_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_TRY_FOLD %out_ok, %out_value, %iter_reg, %init_value, %fold_fn
+    EXPAND BINARY_HEAP_INTO_ITER_SORTED_TRY_FOLD_U64 %out_ok, %out_value, %iter_reg, %init_value, %fold_fn
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_SUM_U64 %out_value, %iter_reg
+    EXPAND VEC_INTO_ITER_SUM_U64 %out_value, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_SORTED_SUM_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_SUM %out_value, %iter_reg
+    EXPAND BINARY_HEAP_INTO_ITER_SORTED_SUM_U64 %out_value, %iter_reg
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_PRODUCT_U64 %out_value, %iter_reg
+    EXPAND VEC_INTO_ITER_PRODUCT_U64 %out_value, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_SORTED_PRODUCT_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_PRODUCT %out_value, %iter_reg
+    EXPAND BINARY_HEAP_INTO_ITER_SORTED_PRODUCT_U64 %out_value, %iter_reg
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_MIN_U64 %out_has, %out_value, %iter_reg
+    EXPAND VEC_INTO_ITER_MIN_U64 %out_has, %out_value, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_SORTED_MIN_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_MIN %out_has, %out_value, %iter_reg
+    EXPAND BINARY_HEAP_INTO_ITER_SORTED_MIN_U64 %out_has, %out_value, %iter_reg
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_MAX_U64 %out_has, %out_value, %iter_reg
+    EXPAND VEC_INTO_ITER_MAX_U64 %out_has, %out_value, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_SORTED_MAX_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_MAX %out_has, %out_value, %iter_reg
+    EXPAND BINARY_HEAP_INTO_ITER_SORTED_MAX_U64 %out_has, %out_value, %iter_reg
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_REDUCE_U64 %out_has, %out_value, %iter_reg, %reduce_fn
+    EXPAND VEC_INTO_ITER_REDUCE_U64 %out_has, %out_value, %iter_reg, %reduce_fn
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_SORTED_REDUCE_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_REDUCE %out_has, %out_value, %iter_reg, %reduce_fn
+    EXPAND BINARY_HEAP_INTO_ITER_SORTED_REDUCE_U64 %out_has, %out_value, %iter_reg, %reduce_fn
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_TRY_REDUCE_U64 %out_ok, %out_has, %out_value, %iter_reg, %reduce_fn
+    EXPAND VEC_INTO_ITER_TRY_REDUCE_U64 %out_ok, %out_has, %out_value, %iter_reg, %reduce_fn
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_SORTED_TRY_REDUCE_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_TRY_REDUCE %out_ok, %out_has, %out_value, %iter_reg, %reduce_fn
+    EXPAND BINARY_HEAP_INTO_ITER_SORTED_TRY_REDUCE_U64 %out_ok, %out_has, %out_value, %iter_reg, %reduce_fn
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_MIN_BY_U64 %out_has, %out_value, %iter_reg, %compare_fn
+    EXPAND VEC_INTO_ITER_MIN_BY_U64 %out_has, %out_value, %iter_reg, %compare_fn
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_SORTED_MIN_BY_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_MIN_BY %out_has, %out_value, %iter_reg, %compare_fn
+    EXPAND BINARY_HEAP_INTO_ITER_SORTED_MIN_BY_U64 %out_has, %out_value, %iter_reg, %compare_fn
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_MAX_BY_U64 %out_has, %out_value, %iter_reg, %compare_fn
+    EXPAND VEC_INTO_ITER_MAX_BY_U64 %out_has, %out_value, %iter_reg, %compare_fn
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_SORTED_MAX_BY_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_MAX_BY %out_has, %out_value, %iter_reg, %compare_fn
+    EXPAND BINARY_HEAP_INTO_ITER_SORTED_MAX_BY_U64 %out_has, %out_value, %iter_reg, %compare_fn
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_MIN_BY_KEY_U64 %out_has, %out_value, %iter_reg, %key_fn
+    EXPAND VEC_INTO_ITER_MIN_BY_KEY_U64 %out_has, %out_value, %iter_reg, %key_fn
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_SORTED_MIN_BY_KEY_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_MIN_BY_KEY %out_has, %out_value, %iter_reg, %key_fn
+    EXPAND BINARY_HEAP_INTO_ITER_SORTED_MIN_BY_KEY_U64 %out_has, %out_value, %iter_reg, %key_fn
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_MAX_BY_KEY_U64 %out_has, %out_value, %iter_reg, %key_fn
+    EXPAND VEC_INTO_ITER_MAX_BY_KEY_U64 %out_has, %out_value, %iter_reg, %key_fn
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_SORTED_MAX_BY_KEY_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_MAX_BY_KEY %out_has, %out_value, %iter_reg, %key_fn
+    EXPAND BINARY_HEAP_INTO_ITER_SORTED_MAX_BY_KEY_U64 %out_has, %out_value, %iter_reg, %key_fn
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_IS_SORTED_U64 %out_bool, %iter_reg
+    EXPAND VEC_INTO_ITER_IS_SORTED_U64 %out_bool, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_SORTED_IS_SORTED_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_IS_SORTED %out_bool, %iter_reg
+    EXPAND BINARY_HEAP_INTO_ITER_SORTED_IS_SORTED_U64 %out_bool, %iter_reg
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_IS_SORTED_BY_U64 %out_bool, %iter_reg, %compare_fn
+    EXPAND VEC_INTO_ITER_IS_SORTED_BY_U64 %out_bool, %iter_reg, %compare_fn
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_SORTED_IS_SORTED_BY_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_IS_SORTED_BY %out_bool, %iter_reg, %compare_fn
+    EXPAND BINARY_HEAP_INTO_ITER_SORTED_IS_SORTED_BY_U64 %out_bool, %iter_reg, %compare_fn
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_IS_SORTED_BY_KEY_U64 %out_bool, %iter_reg, %key_fn
+    EXPAND VEC_INTO_ITER_IS_SORTED_BY_KEY_U64 %out_bool, %iter_reg, %key_fn
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_SORTED_IS_SORTED_BY_KEY_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_IS_SORTED_BY_KEY %out_bool, %iter_reg, %key_fn
+    EXPAND BINARY_HEAP_INTO_ITER_SORTED_IS_SORTED_BY_KEY_U64 %out_bool, %iter_reg, %key_fn
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_PARTITION_U64 %out_true_vec, %out_false_vec, %iter_reg, %pred_fn
+    EXPAND VEC_INTO_ITER_PARTITION_U64 %out_true_vec, %out_false_vec, %iter_reg, %pred_fn
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_SORTED_PARTITION_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_PARTITION %out_true_vec, %out_false_vec, %iter_reg, %pred_fn
+    EXPAND BINARY_HEAP_INTO_ITER_SORTED_PARTITION_U64 %out_true_vec, %out_false_vec, %iter_reg, %pred_fn
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_IS_PARTITIONED_U64 %out_bool, %iter_reg, %pred_fn
+    EXPAND VEC_INTO_ITER_IS_PARTITIONED_U64 %out_bool, %iter_reg, %pred_fn
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_SORTED_IS_PARTITIONED_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_IS_PARTITIONED %out_bool, %iter_reg, %pred_fn
+    EXPAND BINARY_HEAP_INTO_ITER_SORTED_IS_PARTITIONED_U64 %out_bool, %iter_reg, %pred_fn
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_CMP_U64 %out_ordering, %left_iter, %right_iter
+    EXPAND VEC_INTO_ITER_CMP_U64 %out_ordering, %left_iter, %right_iter
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_SORTED_CMP_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_CMP %out_ordering, %left_iter, %right_iter
+    EXPAND BINARY_HEAP_INTO_ITER_SORTED_CMP_U64 %out_ordering, %left_iter, %right_iter
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_CMP_BY_U64 %out_ordering, %left_iter, %right_iter, %compare_fn
+    EXPAND VEC_INTO_ITER_CMP_BY_U64 %out_ordering, %left_iter, %right_iter, %compare_fn
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_SORTED_CMP_BY_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_CMP_BY %out_ordering, %left_iter, %right_iter, %compare_fn
+    EXPAND BINARY_HEAP_INTO_ITER_SORTED_CMP_BY_U64 %out_ordering, %left_iter, %right_iter, %compare_fn
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_PARTIAL_CMP_U64 %out_ordering, %left_iter, %right_iter
+    EXPAND VEC_INTO_ITER_PARTIAL_CMP_U64 %out_ordering, %left_iter, %right_iter
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_SORTED_PARTIAL_CMP_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_PARTIAL_CMP %out_ordering, %left_iter, %right_iter
+    EXPAND BINARY_HEAP_INTO_ITER_SORTED_PARTIAL_CMP_U64 %out_ordering, %left_iter, %right_iter
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_PARTIAL_CMP_BY_U64 %out_ok, %out_ordering, %left_iter, %right_iter, %compare_fn
+    EXPAND VEC_INTO_ITER_PARTIAL_CMP_BY_U64 %out_ok, %out_ordering, %left_iter, %right_iter, %compare_fn
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_SORTED_PARTIAL_CMP_BY_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_PARTIAL_CMP_BY %out_ok, %out_ordering, %left_iter, %right_iter, %compare_fn
+    EXPAND BINARY_HEAP_INTO_ITER_SORTED_PARTIAL_CMP_BY_U64 %out_ok, %out_ordering, %left_iter, %right_iter, %compare_fn
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_EQ_BY_U64 %out_bool, %left_iter, %right_iter, %eq_fn
+    EXPAND VEC_INTO_ITER_EQ_BY_U64 %out_bool, %left_iter, %right_iter, %eq_fn
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_SORTED_EQ_BY_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_EQ_BY %out_bool, %left_iter, %right_iter, %eq_fn
+    EXPAND BINARY_HEAP_INTO_ITER_SORTED_EQ_BY_U64 %out_bool, %left_iter, %right_iter, %eq_fn
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_EQ_U64 %out_bool, %left_iter, %right_iter
+    EXPAND VEC_INTO_ITER_EQ_U64 %out_bool, %left_iter, %right_iter
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_SORTED_EQ_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_EQ %out_bool, %left_iter, %right_iter
+    EXPAND BINARY_HEAP_INTO_ITER_SORTED_EQ_U64 %out_bool, %left_iter, %right_iter
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_PARTIAL_EQ_U64 %out_bool, %left_iter, %right_iter
+    EXPAND VEC_INTO_ITER_PARTIAL_EQ_U64 %out_bool, %left_iter, %right_iter
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_SORTED_PARTIAL_EQ_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_PARTIAL_EQ %out_bool, %left_iter, %right_iter
+    EXPAND BINARY_HEAP_INTO_ITER_SORTED_PARTIAL_EQ_U64 %out_bool, %left_iter, %right_iter
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_NE_U64 %out_bool, %left_iter, %right_iter
+    EXPAND VEC_INTO_ITER_NE_U64 %out_bool, %left_iter, %right_iter
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_SORTED_NE_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_NE %out_bool, %left_iter, %right_iter
+    EXPAND BINARY_HEAP_INTO_ITER_SORTED_NE_U64 %out_bool, %left_iter, %right_iter
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_LT_U64 %out_bool, %left_iter, %right_iter
+    EXPAND VEC_INTO_ITER_LT_U64 %out_bool, %left_iter, %right_iter
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_SORTED_LT_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_LT %out_bool, %left_iter, %right_iter
+    EXPAND BINARY_HEAP_INTO_ITER_SORTED_LT_U64 %out_bool, %left_iter, %right_iter
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_LE_U64 %out_bool, %left_iter, %right_iter
+    EXPAND VEC_INTO_ITER_LE_U64 %out_bool, %left_iter, %right_iter
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_SORTED_LE_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_LE %out_bool, %left_iter, %right_iter
+    EXPAND BINARY_HEAP_INTO_ITER_SORTED_LE_U64 %out_bool, %left_iter, %right_iter
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_GT_U64 %out_bool, %left_iter, %right_iter
+    EXPAND VEC_INTO_ITER_GT_U64 %out_bool, %left_iter, %right_iter
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_SORTED_GT_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_GT %out_bool, %left_iter, %right_iter
+    EXPAND BINARY_HEAP_INTO_ITER_SORTED_GT_U64 %out_bool, %left_iter, %right_iter
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_GE_U64 %out_bool, %left_iter, %right_iter
+    EXPAND VEC_INTO_ITER_GE_U64 %out_bool, %left_iter, %right_iter
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_SORTED_GE_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_GE %out_bool, %left_iter, %right_iter
+    EXPAND BINARY_HEAP_INTO_ITER_SORTED_GE_U64 %out_bool, %left_iter, %right_iter
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_CLONE_U64 %out_iter, %out_vec, %iter_reg
+    EXPAND VEC_INTO_ITER_CLONE_U64 %out_iter, %out_vec, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_SORTED_CLONE_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_CLONE %out_iter, %out_vec, %iter_reg
+    EXPAND BINARY_HEAP_INTO_ITER_SORTED_CLONE_U64 %out_iter, %out_vec, %iter_reg
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_COLLECT_U64 %out_vec, %iter_reg
+    EXPAND ITER_COLLECT_U64 %out_vec, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_SORTED_COLLECT_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_COLLECT %out_vec, %iter_reg
+    EXPAND BINARY_HEAP_INTO_ITER_SORTED_COLLECT_U64 %out_vec, %iter_reg
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_TRY_COLLECT_U64 %out_ok, %out_vec, %iter_reg, %try_fn
+    EXPAND ITER_TRY_COLLECT_U64 %out_ok, %out_vec, %iter_reg, %try_fn
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_SORTED_TRY_COLLECT_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_TRY_COLLECT %out_ok, %out_vec, %iter_reg, %try_fn
+    EXPAND BINARY_HEAP_INTO_ITER_SORTED_TRY_COLLECT_U64 %out_ok, %out_vec, %iter_reg, %try_fn
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_COLLECT_INTO_U64 %vec_reg, %iter_reg
+    EXPAND ITER_COLLECT_INTO_U64 %vec_reg, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_SORTED_COLLECT_INTO_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_COLLECT_INTO %vec_reg, %iter_reg
+    EXPAND BINARY_HEAP_INTO_ITER_SORTED_COLLECT_INTO_U64 %vec_reg, %iter_reg
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_TAKE_COLLECT_U64 %out_vec, %iter_reg, %count
+    EXPAND VEC_INTO_ITER_TAKE_COLLECT_U64 %out_vec, %iter_reg, %count
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_SORTED_TAKE_COLLECT_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_TAKE_COLLECT %out_vec, %iter_reg, %count
+    EXPAND BINARY_HEAP_INTO_ITER_SORTED_TAKE_COLLECT_U64 %out_vec, %iter_reg, %count
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_SKIP_COLLECT_U64 %out_vec, %iter_reg, %count
+    EXPAND VEC_INTO_ITER_SKIP_COLLECT_U64 %out_vec, %iter_reg, %count
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_SORTED_SKIP_COLLECT_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_SKIP_COLLECT %out_vec, %iter_reg, %count
+    EXPAND BINARY_HEAP_INTO_ITER_SORTED_SKIP_COLLECT_U64 %out_vec, %iter_reg, %count
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_MAP_COLLECT_U64 %out_vec, %iter_reg, %map_fn
+    EXPAND VEC_INTO_ITER_MAP_COLLECT_U64 %out_vec, %iter_reg, %map_fn
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_SORTED_MAP_COLLECT_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_MAP_COLLECT %out_vec, %iter_reg, %map_fn
+    EXPAND BINARY_HEAP_INTO_ITER_SORTED_MAP_COLLECT_U64 %out_vec, %iter_reg, %map_fn
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_FILTER_COLLECT_U64 %out_vec, %iter_reg, %pred_fn
+    EXPAND VEC_INTO_ITER_FILTER_COLLECT_U64 %out_vec, %iter_reg, %pred_fn
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_SORTED_FILTER_COLLECT_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_FILTER_COLLECT %out_vec, %iter_reg, %pred_fn
+    EXPAND BINARY_HEAP_INTO_ITER_SORTED_FILTER_COLLECT_U64 %out_vec, %iter_reg, %pred_fn
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_FILTER_MAP_COLLECT_U64 %out_vec, %iter_reg, %map_fn
+    EXPAND VEC_INTO_ITER_FILTER_MAP_COLLECT_U64 %out_vec, %iter_reg, %map_fn
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_SORTED_FILTER_MAP_COLLECT_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_FILTER_MAP_COLLECT %out_vec, %iter_reg, %map_fn
+    EXPAND BINARY_HEAP_INTO_ITER_SORTED_FILTER_MAP_COLLECT_U64 %out_vec, %iter_reg, %map_fn
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_MAP_WHILE_COLLECT_U64 %out_vec, %iter_reg, %map_fn
+    EXPAND VEC_INTO_ITER_MAP_WHILE_COLLECT_U64 %out_vec, %iter_reg, %map_fn
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_SORTED_MAP_WHILE_COLLECT_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_MAP_WHILE_COLLECT %out_vec, %iter_reg, %map_fn
+    EXPAND BINARY_HEAP_INTO_ITER_SORTED_MAP_WHILE_COLLECT_U64 %out_vec, %iter_reg, %map_fn
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_INSPECT_COLLECT_U64 %out_vec, %iter_reg, %inspect_fn
+    EXPAND VEC_INTO_ITER_INSPECT_COLLECT_U64 %out_vec, %iter_reg, %inspect_fn
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_SORTED_INSPECT_COLLECT_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_INSPECT_COLLECT %out_vec, %iter_reg, %inspect_fn
+    EXPAND BINARY_HEAP_INTO_ITER_SORTED_INSPECT_COLLECT_U64 %out_vec, %iter_reg, %inspect_fn
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_SCAN_COLLECT_U64 %out_vec, %iter_reg, %initial_state, %scan_fn
+    EXPAND VEC_INTO_ITER_SCAN_COLLECT_U64 %out_vec, %iter_reg, %initial_state, %scan_fn
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_SORTED_SCAN_COLLECT_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_SCAN_COLLECT %out_vec, %iter_reg, %initial_state, %scan_fn
+    EXPAND BINARY_HEAP_INTO_ITER_SORTED_SCAN_COLLECT_U64 %out_vec, %iter_reg, %initial_state, %scan_fn
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_TRY_STEP_BY_COLLECT_U64 %out_ok, %out_vec, %iter_reg, %step
+    EXPAND VEC_INTO_ITER_TRY_STEP_BY_COLLECT_U64 %out_ok, %out_vec, %iter_reg, %step
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_SORTED_TRY_STEP_BY_COLLECT_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_TRY_STEP_BY_COLLECT %out_ok, %out_vec, %iter_reg, %step
+    EXPAND BINARY_HEAP_INTO_ITER_SORTED_TRY_STEP_BY_COLLECT_U64 %out_ok, %out_vec, %iter_reg, %step
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_STEP_BY_COLLECT_U64 %out_vec, %iter_reg, %step
+    EXPAND VEC_INTO_ITER_STEP_BY_COLLECT_U64 %out_vec, %iter_reg, %step
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_SORTED_STEP_BY_COLLECT_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_STEP_BY_COLLECT %out_vec, %iter_reg, %step
+    EXPAND BINARY_HEAP_INTO_ITER_SORTED_STEP_BY_COLLECT_U64 %out_vec, %iter_reg, %step
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_ENUMERATE_COLLECT_U64 %out_vec, %iter_reg
+    EXPAND VEC_INTO_ITER_ENUMERATE_COLLECT_U64 %out_vec, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_SORTED_ENUMERATE_COLLECT_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_ENUMERATE_COLLECT %out_vec, %iter_reg
+    EXPAND BINARY_HEAP_INTO_ITER_SORTED_ENUMERATE_COLLECT_U64 %out_vec, %iter_reg
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_BY_REF_COLLECT_U64 %out_vec, %iter_reg
+    EXPAND VEC_INTO_ITER_BY_REF_COLLECT_U64 %out_vec, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_SORTED_BY_REF_COLLECT_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_BY_REF_COLLECT %out_vec, %iter_reg
+    EXPAND BINARY_HEAP_INTO_ITER_SORTED_BY_REF_COLLECT_U64 %out_vec, %iter_reg
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_FUSE_COLLECT_U64 %out_vec, %iter_reg
+    EXPAND VEC_INTO_ITER_FUSE_COLLECT_U64 %out_vec, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_SORTED_FUSE_COLLECT_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_FUSE_COLLECT %out_vec, %iter_reg
+    EXPAND BINARY_HEAP_INTO_ITER_SORTED_FUSE_COLLECT_U64 %out_vec, %iter_reg
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_PEEKABLE_COLLECT_U64 %out_vec, %iter_reg
+    EXPAND VEC_INTO_ITER_PEEKABLE_COLLECT_U64 %out_vec, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_SORTED_PEEKABLE_COLLECT_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_PEEKABLE_COLLECT %out_vec, %iter_reg
+    EXPAND BINARY_HEAP_INTO_ITER_SORTED_PEEKABLE_COLLECT_U64 %out_vec, %iter_reg
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_ARRAY_CHUNKS_COLLECT_U64 %out_ok, %out_vec, %iter_reg, %chunk_size
+    EXPAND VEC_INTO_ITER_ARRAY_CHUNKS_COLLECT_U64 %out_ok, %out_vec, %iter_reg, %chunk_size
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_SORTED_ARRAY_CHUNKS_COLLECT_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_ARRAY_CHUNKS_COLLECT %out_ok, %out_vec, %iter_reg, %chunk_size
+    EXPAND BINARY_HEAP_INTO_ITER_SORTED_ARRAY_CHUNKS_COLLECT_U64 %out_ok, %out_vec, %iter_reg, %chunk_size
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_MAP_WINDOWS_COLLECT_U64 %out_ok, %out_vec, %iter_reg, %window_size, %map_fn
+    EXPAND VEC_INTO_ITER_MAP_WINDOWS_COLLECT_U64 %out_ok, %out_vec, %iter_reg, %window_size, %map_fn
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_SORTED_MAP_WINDOWS_COLLECT_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_MAP_WINDOWS_COLLECT %out_ok, %out_vec, %iter_reg, %window_size, %map_fn
+    EXPAND BINARY_HEAP_INTO_ITER_SORTED_MAP_WINDOWS_COLLECT_U64 %out_ok, %out_vec, %iter_reg, %window_size, %map_fn
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_INTERSPERSE_COLLECT_U64 %out_vec, %iter_reg, %separator
+    EXPAND VEC_INTO_ITER_INTERSPERSE_COLLECT_U64 %out_vec, %iter_reg, %separator
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_SORTED_INTERSPERSE_COLLECT_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_INTERSPERSE_COLLECT %out_vec, %iter_reg, %separator
+    EXPAND BINARY_HEAP_INTO_ITER_SORTED_INTERSPERSE_COLLECT_U64 %out_vec, %iter_reg, %separator
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_INTERSPERSE_WITH_COLLECT_U64 %out_vec, %iter_reg, %sep_fn
+    EXPAND VEC_INTO_ITER_INTERSPERSE_WITH_COLLECT_U64 %out_vec, %iter_reg, %sep_fn
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_SORTED_INTERSPERSE_WITH_COLLECT_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_INTERSPERSE_WITH_COLLECT %out_vec, %iter_reg, %sep_fn
+    EXPAND BINARY_HEAP_INTO_ITER_SORTED_INTERSPERSE_WITH_COLLECT_U64 %out_vec, %iter_reg, %sep_fn
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_CYCLE_TAKE_COLLECT_U64 %out_vec, %iter_reg, %count
+    EXPAND VEC_INTO_ITER_CYCLE_TAKE_COLLECT_U64 %out_vec, %iter_reg, %count
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_SORTED_CYCLE_TAKE_COLLECT_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_CYCLE_TAKE_COLLECT %out_vec, %iter_reg, %count
+    EXPAND BINARY_HEAP_INTO_ITER_SORTED_CYCLE_TAKE_COLLECT_U64 %out_vec, %iter_reg, %count
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_TAKE_WHILE_COLLECT_U64 %out_vec, %iter_reg, %pred_fn
+    EXPAND VEC_INTO_ITER_TAKE_WHILE_COLLECT_U64 %out_vec, %iter_reg, %pred_fn
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_SORTED_TAKE_WHILE_COLLECT_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_TAKE_WHILE_COLLECT %out_vec, %iter_reg, %pred_fn
+    EXPAND BINARY_HEAP_INTO_ITER_SORTED_TAKE_WHILE_COLLECT_U64 %out_vec, %iter_reg, %pred_fn
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_SKIP_WHILE_COLLECT_U64 %out_vec, %iter_reg, %pred_fn
+    EXPAND VEC_INTO_ITER_SKIP_WHILE_COLLECT_U64 %out_vec, %iter_reg, %pred_fn
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_SORTED_SKIP_WHILE_COLLECT_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_SKIP_WHILE_COLLECT %out_vec, %iter_reg, %pred_fn
+    EXPAND BINARY_HEAP_INTO_ITER_SORTED_SKIP_WHILE_COLLECT_U64 %out_vec, %iter_reg, %pred_fn
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_ZIP_COLLECT_U64 %out_vec, %left_iter, %right_iter
+    EXPAND VEC_INTO_ITER_ZIP_COLLECT_U64 %out_vec, %left_iter, %right_iter
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_SORTED_ZIP_COLLECT_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_ZIP_COLLECT %out_vec, %left_iter, %right_iter
+    EXPAND BINARY_HEAP_INTO_ITER_SORTED_ZIP_COLLECT_U64 %out_vec, %left_iter, %right_iter
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_CHAIN_COLLECT_U64 %out_vec, %left_iter, %right_iter
+    EXPAND VEC_INTO_ITER_CHAIN_COLLECT_U64 %out_vec, %left_iter, %right_iter
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_INTO_ITER_SORTED_CHAIN_COLLECT_U64.
+[MACRO] BINARY_HEAP_INTO_ITER_SORTED_CHAIN_COLLECT %out_vec, %left_iter, %right_iter
+    EXPAND BINARY_HEAP_INTO_ITER_SORTED_CHAIN_COLLECT_U64 %out_vec, %left_iter, %right_iter
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_IS_EMPTY %out_flag, %heap_reg
+    %out_flag = call @sa_binary_heap_is_empty(&%heap_reg)
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_PEEK %out_value, %heap_reg
+    %out_value = call @sa_binary_heap_peek(&%heap_reg)
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_TRY_PEEK_MUT_PTR %out_ok, %out_ptr, %heap_reg
+    __binary_heap_peek_mut_slot_%out_ok = stack_alloc 8
+    __binary_heap_peek_mut_ok_%out_ok = call @sa_binary_heap_try_peek_mut_ptr(&%heap_reg, &__binary_heap_peek_mut_slot_%out_ok)
+    %out_ptr = load __binary_heap_peek_mut_slot_%out_ok+0 as ptr
+    %out_ok = __binary_heap_peek_mut_ok_%out_ok
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_PEEK_MUT_PTR %out_ptr, %heap_reg
+    EXPAND BINARY_HEAP_TRY_PEEK_MUT_PTR __binary_heap_peek_mut_ok_%out_ptr, %out_ptr, %heap_reg
+[END_MACRO]
+
+// Rust method-name alias over checked peek-mut raw slot pointer.
+[MACRO] BINARY_HEAP_PEEK_MUT %out_ok, %out_ptr, %heap_reg
+    EXPAND BINARY_HEAP_TRY_PEEK_MUT_PTR %out_ok, %out_ptr, %heap_reg
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_TRY_PEEK_MUT_SET_U64 %out_ok, %out_old_value, %heap_reg, %value
+    __binary_heap_peek_set_slot_%out_ok = stack_alloc 8
+    __binary_heap_peek_set_ok_%out_ok = call @sa_binary_heap_try_peek_mut_set_u64(&%heap_reg, %value, &__binary_heap_peek_set_slot_%out_ok)
+    %out_old_value = load __binary_heap_peek_set_slot_%out_ok+0 as u64
+    %out_ok = __binary_heap_peek_set_ok_%out_ok
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_TRY_PEEK_MUT_SET_U64.
+[MACRO] BINARY_HEAP_TRY_PEEK_MUT_SET %out_ok, %out_old_value, %heap_reg, %value
+    EXPAND BINARY_HEAP_TRY_PEEK_MUT_SET_U64 %out_ok, %out_old_value, %heap_reg, %value
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_PEEK_MUT_SET_U64 %out_old_value, %heap_reg, %value
+    EXPAND BINARY_HEAP_TRY_PEEK_MUT_SET_U64 __binary_heap_peek_set_ok_%out_old_value, %out_old_value, %heap_reg, %value
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_PEEK_MUT_SET_U64.
+[MACRO] BINARY_HEAP_PEEK_MUT_SET %out_old_value, %heap_reg, %value
+    EXPAND BINARY_HEAP_PEEK_MUT_SET_U64 %out_old_value, %heap_reg, %value
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_PUSH %heap_reg, %value
+    call @sa_binary_heap_push(&%heap_reg, %value)
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_TRY_POP %out_ok, %out_value, %heap_reg
+    __binary_heap_value_slot_%out_ok = stack_alloc 8
+    __binary_heap_ok_%out_ok = call @sa_binary_heap_try_pop(&%heap_reg, &__binary_heap_value_slot_%out_ok)
+    %out_value = load __binary_heap_value_slot_%out_ok+0 as u64
+    %out_ok = __binary_heap_ok_%out_ok
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_TRY_POP_IF_U64 %out_ok, %out_value, %heap_reg, %pred_fn
+    EXPAND BINARY_HEAP_TRY_PEEK __binary_heap_pop_if_has_%out_ok, __binary_heap_pop_if_value_%out_ok, %heap_reg
+    br __binary_heap_pop_if_has_%out_ok -> L_BINARY_HEAP_POP_IF_CHECK_%out_ok, L_BINARY_HEAP_POP_IF_EMPTY_%out_ok
+
+L_BINARY_HEAP_POP_IF_CHECK_%out_ok:
+    __binary_heap_pop_if_pred_%out_ok = call %pred_fn(__binary_heap_pop_if_value_%out_ok)
+    __binary_heap_pop_if_take_%out_ok = ne __binary_heap_pop_if_pred_%out_ok, 0
+    br __binary_heap_pop_if_take_%out_ok -> L_BINARY_HEAP_POP_IF_TAKE_%out_ok, L_BINARY_HEAP_POP_IF_KEEP_%out_ok
+
+L_BINARY_HEAP_POP_IF_TAKE_%out_ok:
+    EXPAND BINARY_HEAP_TRY_POP __binary_heap_pop_if_pop_ok_%out_ok, __binary_heap_pop_if_pop_value_%out_ok, %heap_reg
+    %out_ok = __binary_heap_pop_if_pop_ok_%out_ok
+    %out_value = __binary_heap_pop_if_pop_value_%out_ok
+    !__binary_heap_pop_if_take_%out_ok
+    !__binary_heap_pop_if_pred_%out_ok
+    !__binary_heap_pop_if_value_%out_ok
+    !__binary_heap_pop_if_has_%out_ok
+    jmp L_BINARY_HEAP_POP_IF_END_%out_ok
+
+L_BINARY_HEAP_POP_IF_KEEP_%out_ok:
+    %out_ok = add 0, 0
+    %out_value = add 0, 0
+    !__binary_heap_pop_if_take_%out_ok
+    !__binary_heap_pop_if_pred_%out_ok
+    !__binary_heap_pop_if_value_%out_ok
+    !__binary_heap_pop_if_has_%out_ok
+    jmp L_BINARY_HEAP_POP_IF_END_%out_ok
+
+L_BINARY_HEAP_POP_IF_EMPTY_%out_ok:
+    %out_ok = add 0, 0
+    %out_value = add 0, 0
+    !__binary_heap_pop_if_value_%out_ok
+    !__binary_heap_pop_if_has_%out_ok
+
+L_BINARY_HEAP_POP_IF_END_%out_ok:
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_TRY_POP_IF_U64.
+[MACRO] BINARY_HEAP_TRY_POP_IF %out_ok, %out_value, %heap_reg, %pred_fn
+    EXPAND BINARY_HEAP_TRY_POP_IF_U64 %out_ok, %out_value, %heap_reg, %pred_fn
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_POP_IF_U64 %out_ok, %out_value, %heap_reg, %pred_fn
+    EXPAND BINARY_HEAP_TRY_POP_IF_U64 %out_ok, %out_value, %heap_reg, %pred_fn
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_POP_IF_U64.
+[MACRO] BINARY_HEAP_POP_IF %out_ok, %out_value, %heap_reg, %pred_fn
+    EXPAND BINARY_HEAP_POP_IF_U64 %out_ok, %out_value, %heap_reg, %pred_fn
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_CLEAR %heap_reg
+    call @sa_binary_heap_clear(&%heap_reg)
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_DRAIN %out_vec, %heap_reg
+    __binary_heap_drain_buf_%out_vec = load %heap_reg+BinaryHeap_buf as ptr
+    __binary_heap_drain_len_%out_vec = load %heap_reg+BinaryHeap_len as u64
+    EXPAND VEC_WITH_CAPACITY_U64 %out_vec, __binary_heap_drain_len_%out_vec
+    __binary_heap_drain_idx_slot_%out_vec = stack_alloc 8
+    store __binary_heap_drain_idx_slot_%out_vec+0, 0 as u64
+    jmp L_BINARY_HEAP_DRAIN_HEAD_%out_vec
+
+L_BINARY_HEAP_DRAIN_HEAD_%out_vec:
+    __binary_heap_drain_idx_%out_vec = load __binary_heap_drain_idx_slot_%out_vec+0 as u64
+    __binary_heap_drain_done_%out_vec = eq __binary_heap_drain_idx_%out_vec, __binary_heap_drain_len_%out_vec
+    br __binary_heap_drain_done_%out_vec -> L_BINARY_HEAP_DRAIN_DONE_%out_vec, L_BINARY_HEAP_DRAIN_BODY_%out_vec
+
+L_BINARY_HEAP_DRAIN_BODY_%out_vec:
+    __binary_heap_drain_off_%out_vec = mul __binary_heap_drain_idx_%out_vec, BinaryHeap_SLOT_SIZE
+    __binary_heap_drain_ptr_%out_vec = ptr_add __binary_heap_drain_buf_%out_vec, __binary_heap_drain_off_%out_vec
+    __binary_heap_drain_value_%out_vec = load __binary_heap_drain_ptr_%out_vec+0 as u64
+    EXPAND VEC_PUSH_U64 %out_vec, __binary_heap_drain_value_%out_vec
+    __binary_heap_drain_next_%out_vec = add __binary_heap_drain_idx_%out_vec, 1
+    store __binary_heap_drain_idx_slot_%out_vec+0, __binary_heap_drain_next_%out_vec as u64
+    !__binary_heap_drain_next_%out_vec
+    !__binary_heap_drain_value_%out_vec
+    !__binary_heap_drain_ptr_%out_vec
+    !__binary_heap_drain_off_%out_vec
+    !__binary_heap_drain_done_%out_vec
+    !__binary_heap_drain_idx_%out_vec
+    jmp L_BINARY_HEAP_DRAIN_HEAD_%out_vec
+
+L_BINARY_HEAP_DRAIN_DONE_%out_vec:
+    call @sa_binary_heap_clear(&%heap_reg)
+    !__binary_heap_drain_done_%out_vec
+    !__binary_heap_drain_idx_%out_vec
+    !__binary_heap_drain_len_%out_vec
+    !__binary_heap_drain_buf_%out_vec
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_RETAIN_U64 %out_len, %heap_reg, %pred_fn
+    __binary_heap_retain_buf_%out_len = load %heap_reg+BinaryHeap_buf as ptr
+    __binary_heap_retain_len_%out_len = load %heap_reg+BinaryHeap_len as u64
+    __binary_heap_retain_read_slot_%out_len = stack_alloc 8
+    __binary_heap_retain_write_slot_%out_len = stack_alloc 8
+    store __binary_heap_retain_read_slot_%out_len+0, 0 as u64
+    store __binary_heap_retain_write_slot_%out_len+0, 0 as u64
+    jmp L_BINARY_HEAP_RETAIN_HEAD_%out_len
+
+L_BINARY_HEAP_RETAIN_HEAD_%out_len:
+    __binary_heap_retain_read_%out_len = load __binary_heap_retain_read_slot_%out_len+0 as u64
+    __binary_heap_retain_done_%out_len = eq __binary_heap_retain_read_%out_len, __binary_heap_retain_len_%out_len
+    br __binary_heap_retain_done_%out_len -> L_BINARY_HEAP_RETAIN_CLEAR_HEAD_%out_len, L_BINARY_HEAP_RETAIN_BODY_%out_len
+
+L_BINARY_HEAP_RETAIN_BODY_%out_len:
+    __binary_heap_retain_read_off_%out_len = mul __binary_heap_retain_read_%out_len, BinaryHeap_SLOT_SIZE
+    __binary_heap_retain_read_ptr_%out_len = ptr_add __binary_heap_retain_buf_%out_len, __binary_heap_retain_read_off_%out_len
+    __binary_heap_retain_value_%out_len = load __binary_heap_retain_read_ptr_%out_len+0 as u64
+    __binary_heap_retain_pred_%out_len = call %pred_fn(__binary_heap_retain_value_%out_len)
+    __binary_heap_retain_keep_%out_len = ne __binary_heap_retain_pred_%out_len, 0
+    br __binary_heap_retain_keep_%out_len -> L_BINARY_HEAP_RETAIN_KEEP_%out_len, L_BINARY_HEAP_RETAIN_SKIP_%out_len
+
+L_BINARY_HEAP_RETAIN_KEEP_%out_len:
+    __binary_heap_retain_write_%out_len = load __binary_heap_retain_write_slot_%out_len+0 as u64
+    __binary_heap_retain_same_slot_%out_len = eq __binary_heap_retain_write_%out_len, __binary_heap_retain_read_%out_len
+    br __binary_heap_retain_same_slot_%out_len -> L_BINARY_HEAP_RETAIN_KEEP_ADVANCE_%out_len, L_BINARY_HEAP_RETAIN_COPY_%out_len
+
+L_BINARY_HEAP_RETAIN_COPY_%out_len:
+    __binary_heap_retain_write_off_%out_len = mul __binary_heap_retain_write_%out_len, BinaryHeap_SLOT_SIZE
+    __binary_heap_retain_write_ptr_%out_len = ptr_add __binary_heap_retain_buf_%out_len, __binary_heap_retain_write_off_%out_len
+    store __binary_heap_retain_write_ptr_%out_len+0, __binary_heap_retain_value_%out_len as u64
+    !__binary_heap_retain_write_ptr_%out_len
+    !__binary_heap_retain_write_off_%out_len
+    jmp L_BINARY_HEAP_RETAIN_KEEP_ADVANCE_%out_len
+
+L_BINARY_HEAP_RETAIN_KEEP_ADVANCE_%out_len:
+    __binary_heap_retain_next_write_%out_len = add __binary_heap_retain_write_%out_len, 1
+    store __binary_heap_retain_write_slot_%out_len+0, __binary_heap_retain_next_write_%out_len as u64
+    !__binary_heap_retain_next_write_%out_len
+    !__binary_heap_retain_same_slot_%out_len
+    !__binary_heap_retain_write_%out_len
+    jmp L_BINARY_HEAP_RETAIN_NEXT_%out_len
+
+L_BINARY_HEAP_RETAIN_SKIP_%out_len:
+    jmp L_BINARY_HEAP_RETAIN_NEXT_%out_len
+
+L_BINARY_HEAP_RETAIN_NEXT_%out_len:
+    __binary_heap_retain_next_read_%out_len = add __binary_heap_retain_read_%out_len, 1
+    store __binary_heap_retain_read_slot_%out_len+0, __binary_heap_retain_next_read_%out_len as u64
+    !__binary_heap_retain_next_read_%out_len
+    !__binary_heap_retain_keep_%out_len
+    !__binary_heap_retain_pred_%out_len
+    !__binary_heap_retain_value_%out_len
+    !__binary_heap_retain_read_ptr_%out_len
+    !__binary_heap_retain_read_off_%out_len
+    !__binary_heap_retain_done_%out_len
+    !__binary_heap_retain_read_%out_len
+    jmp L_BINARY_HEAP_RETAIN_HEAD_%out_len
+
+L_BINARY_HEAP_RETAIN_CLEAR_HEAD_%out_len:
+    __binary_heap_retain_clear_slot_%out_len = stack_alloc 8
+    __binary_heap_retain_kept_len_%out_len = load __binary_heap_retain_write_slot_%out_len+0 as u64
+    store __binary_heap_retain_clear_slot_%out_len+0, __binary_heap_retain_kept_len_%out_len as u64
+    jmp L_BINARY_HEAP_RETAIN_CLEAR_LOOP_%out_len
+
+L_BINARY_HEAP_RETAIN_CLEAR_LOOP_%out_len:
+    __binary_heap_retain_clear_idx_%out_len = load __binary_heap_retain_clear_slot_%out_len+0 as u64
+    __binary_heap_retain_clear_done_%out_len = eq __binary_heap_retain_clear_idx_%out_len, __binary_heap_retain_len_%out_len
+    br __binary_heap_retain_clear_done_%out_len -> L_BINARY_HEAP_RETAIN_HEAPIFY_INIT_%out_len, L_BINARY_HEAP_RETAIN_CLEAR_BODY_%out_len
+
+L_BINARY_HEAP_RETAIN_CLEAR_BODY_%out_len:
+    __binary_heap_retain_clear_off_%out_len = mul __binary_heap_retain_clear_idx_%out_len, BinaryHeap_SLOT_SIZE
+    __binary_heap_retain_clear_ptr_%out_len = ptr_add __binary_heap_retain_buf_%out_len, __binary_heap_retain_clear_off_%out_len
+    store __binary_heap_retain_clear_ptr_%out_len+0, 0 as u64
+    __binary_heap_retain_next_clear_%out_len = add __binary_heap_retain_clear_idx_%out_len, 1
+    store __binary_heap_retain_clear_slot_%out_len+0, __binary_heap_retain_next_clear_%out_len as u64
+    !__binary_heap_retain_next_clear_%out_len
+    !__binary_heap_retain_clear_ptr_%out_len
+    !__binary_heap_retain_clear_off_%out_len
+    !__binary_heap_retain_clear_done_%out_len
+    !__binary_heap_retain_clear_idx_%out_len
+    jmp L_BINARY_HEAP_RETAIN_CLEAR_LOOP_%out_len
+
+L_BINARY_HEAP_RETAIN_HEAPIFY_INIT_%out_len:
+    store %heap_reg+BinaryHeap_len, __binary_heap_retain_kept_len_%out_len as u64
+    __binary_heap_retain_too_small_%out_len = ule __binary_heap_retain_kept_len_%out_len, 1
+    br __binary_heap_retain_too_small_%out_len -> L_BINARY_HEAP_RETAIN_DONE_%out_len, L_BINARY_HEAP_RETAIN_HEAPIFY_START_%out_len
+
+L_BINARY_HEAP_RETAIN_HEAPIFY_START_%out_len:
+    __binary_heap_retain_last_%out_len = sub __binary_heap_retain_kept_len_%out_len, 2
+    __binary_heap_retain_parent_%out_len = udiv __binary_heap_retain_last_%out_len, 2
+    __binary_heap_retain_heapify_slot_%out_len = stack_alloc 8
+    store __binary_heap_retain_heapify_slot_%out_len+0, __binary_heap_retain_parent_%out_len as u64
+    jmp L_BINARY_HEAP_RETAIN_HEAPIFY_LOOP_%out_len
+
+L_BINARY_HEAP_RETAIN_HEAPIFY_LOOP_%out_len:
+    __binary_heap_retain_heapify_idx_%out_len = load __binary_heap_retain_heapify_slot_%out_len+0 as u64
+    call @binary_heap_sift_down(&%heap_reg, __binary_heap_retain_heapify_idx_%out_len)
+    __binary_heap_retain_heapify_zero_%out_len = eq __binary_heap_retain_heapify_idx_%out_len, 0
+    br __binary_heap_retain_heapify_zero_%out_len -> L_BINARY_HEAP_RETAIN_DONE_FROM_HEAPIFY_%out_len, L_BINARY_HEAP_RETAIN_HEAPIFY_NEXT_%out_len
+
+L_BINARY_HEAP_RETAIN_HEAPIFY_NEXT_%out_len:
+    __binary_heap_retain_prev_heapify_%out_len = sub __binary_heap_retain_heapify_idx_%out_len, 1
+    store __binary_heap_retain_heapify_slot_%out_len+0, __binary_heap_retain_prev_heapify_%out_len as u64
+    !__binary_heap_retain_prev_heapify_%out_len
+    !__binary_heap_retain_heapify_zero_%out_len
+    !__binary_heap_retain_heapify_idx_%out_len
+    jmp L_BINARY_HEAP_RETAIN_HEAPIFY_LOOP_%out_len
+
+L_BINARY_HEAP_RETAIN_DONE_FROM_HEAPIFY_%out_len:
+    !__binary_heap_retain_heapify_zero_%out_len
+    !__binary_heap_retain_heapify_idx_%out_len
+    !__binary_heap_retain_parent_%out_len
+    !__binary_heap_retain_last_%out_len
+    jmp L_BINARY_HEAP_RETAIN_DONE_%out_len
+
+L_BINARY_HEAP_RETAIN_DONE_%out_len:
+    %out_len = load %heap_reg+BinaryHeap_len as u64
+    !__binary_heap_retain_too_small_%out_len
+    !__binary_heap_retain_clear_done_%out_len
+    !__binary_heap_retain_clear_idx_%out_len
+    !__binary_heap_retain_kept_len_%out_len
+    !__binary_heap_retain_done_%out_len
+    !__binary_heap_retain_read_%out_len
+    !__binary_heap_retain_len_%out_len
+    !__binary_heap_retain_buf_%out_len
+[END_MACRO]
+
+// Rust method-name alias: BinaryHeap::retain over concrete u64 predicate helper.
+[MACRO] BINARY_HEAP_RETAIN %out_len, %heap_reg, %pred_fn
+    EXPAND BINARY_HEAP_RETAIN_U64 %out_len, %heap_reg, %pred_fn
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_APPEND %heap_reg, %other_heap_reg
+    call @sa_binary_heap_append(&%heap_reg, &%other_heap_reg)
+[END_MACRO]
+
+// Concrete u64-named and try/non-try value-form aliases over the existing
+// BINARY_HEAP_PUSH / PEEK / TRY_POP / capacity+len primitives. These add no
+// new syscall/FFI surface; they only expose Rust-style naming parity and a
+// fallible value view (ok,value) for PEEK.
+
+[MACRO] BINARY_HEAP_PUSH_U64 %heap_reg, %value
+    EXPAND BINARY_HEAP_PUSH %heap_reg, %value
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_PEEK_U64 %out_value, %heap_reg
+    EXPAND BINARY_HEAP_PEEK %out_value, %heap_reg
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_TRY_PEEK %out_ok, %out_value, %heap_reg
+    __binary_heap_try_peek_empty_%out_ok = call @sa_binary_heap_is_empty(&%heap_reg)
+    __binary_heap_try_peek_is_empty_%out_ok = eq __binary_heap_try_peek_empty_%out_ok, 1
+    br __binary_heap_try_peek_is_empty_%out_ok -> L_BINARY_HEAP_TRY_PEEK_EMPTY_%out_ok, L_BINARY_HEAP_TRY_PEEK_NONEMPTY_%out_ok
+L_BINARY_HEAP_TRY_PEEK_EMPTY_%out_ok:
+    %out_ok = add 0, 0
+    %out_value = add 0, 0
+    !__binary_heap_try_peek_empty_%out_ok
+    !__binary_heap_try_peek_is_empty_%out_ok
+    jmp L_BINARY_HEAP_TRY_PEEK_END_%out_ok
+L_BINARY_HEAP_TRY_PEEK_NONEMPTY_%out_ok:
+    %out_value = call @sa_binary_heap_peek(&%heap_reg)
+    %out_ok = add 0, 1
+    !__binary_heap_try_peek_empty_%out_ok
+    !__binary_heap_try_peek_is_empty_%out_ok
+    jmp L_BINARY_HEAP_TRY_PEEK_END_%out_ok
+L_BINARY_HEAP_TRY_PEEK_END_%out_ok:
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_TRY_PEEK_U64 %out_ok, %out_value, %heap_reg
+    EXPAND BINARY_HEAP_TRY_PEEK %out_ok, %out_value, %heap_reg
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_POP %out_value, %heap_reg
+    __binary_heap_pop_slot_%out_value = stack_alloc 8
+    __binary_heap_pop_ok_%out_value = call @sa_binary_heap_try_pop(&%heap_reg, &__binary_heap_pop_slot_%out_value)
+    %out_value = load __binary_heap_pop_slot_%out_value+0 as u64
+    !__binary_heap_pop_ok_%out_value
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_POP_U64 %out_value, %heap_reg
+    EXPAND BINARY_HEAP_POP %out_value, %heap_reg
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_EXTRA_CAPACITY %out_extra, %heap_reg
+    __binary_heap_ec_cap_%out_extra = call @sa_binary_heap_capacity(&%heap_reg)
+    __binary_heap_ec_len_%out_extra = call @sa_binary_heap_len(&%heap_reg)
+    %out_extra = sub __binary_heap_ec_cap_%out_extra, __binary_heap_ec_len_%out_extra
+    !__binary_heap_ec_len_%out_extra
+    !__binary_heap_ec_cap_%out_extra
+[END_MACRO]
+
+// Fixed-arity / from-collection constructors over the concrete u64 max-heap.
+// FROM_* helpers push each source element through the existing heapify path.
+
+[MACRO] BINARY_HEAP_LIT1 %out_heap, %value1
+    EXPAND BINARY_HEAP_NEW %out_heap
+    EXPAND BINARY_HEAP_PUSH_U64 %out_heap, %value1
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_LIT2 %out_heap, %value1, %value2
+    EXPAND BINARY_HEAP_NEW %out_heap
+    EXPAND BINARY_HEAP_PUSH_U64 %out_heap, %value1
+    EXPAND BINARY_HEAP_PUSH_U64 %out_heap, %value2
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_LIT3 %out_heap, %value1, %value2, %value3
+    EXPAND BINARY_HEAP_NEW %out_heap
+    EXPAND BINARY_HEAP_PUSH_U64 %out_heap, %value1
+    EXPAND BINARY_HEAP_PUSH_U64 %out_heap, %value2
+    EXPAND BINARY_HEAP_PUSH_U64 %out_heap, %value3
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_EXTEND_FROM_SLICE_U64 %heap_reg, %slice_reg
+    __bh_ext_len_%heap_reg = load %slice_reg+Slice_len as u64
+    __bh_ext_idx_slot_%heap_reg = stack_alloc 8
+    store __bh_ext_idx_slot_%heap_reg+0, 0 as u64
+    jmp L_BINARY_HEAP_EXTEND_HEAD_%heap_reg
+L_BINARY_HEAP_EXTEND_HEAD_%heap_reg:
+    __bh_ext_idx_%heap_reg = load __bh_ext_idx_slot_%heap_reg+0 as u64
+    __bh_ext_done_%heap_reg = eq __bh_ext_idx_%heap_reg, __bh_ext_len_%heap_reg
+    br __bh_ext_done_%heap_reg -> L_BINARY_HEAP_EXTEND_DONE_%heap_reg, L_BINARY_HEAP_EXTEND_BODY_%heap_reg
+L_BINARY_HEAP_EXTEND_BODY_%heap_reg:
+    EXPAND SLICE_GET_U64 __bh_ext_val_%heap_reg, %slice_reg, __bh_ext_idx_%heap_reg
+    EXPAND BINARY_HEAP_PUSH_U64 %heap_reg, __bh_ext_val_%heap_reg
+    __bh_ext_next_%heap_reg = add __bh_ext_idx_%heap_reg, 1
+    store __bh_ext_idx_slot_%heap_reg+0, __bh_ext_next_%heap_reg as u64
+    !__bh_ext_next_%heap_reg
+    !__bh_ext_val_%heap_reg
+    !__bh_ext_done_%heap_reg
+    !__bh_ext_idx_%heap_reg
+    jmp L_BINARY_HEAP_EXTEND_HEAD_%heap_reg
+L_BINARY_HEAP_EXTEND_DONE_%heap_reg:
+    !__bh_ext_done_%heap_reg
+    !__bh_ext_idx_%heap_reg
+    !__bh_ext_len_%heap_reg
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_EXTEND_FROM_SLICE_U64.
+[MACRO] BINARY_HEAP_EXTEND_FROM_SLICE %heap_reg, %slice_reg
+    EXPAND BINARY_HEAP_EXTEND_FROM_SLICE_U64 %heap_reg, %slice_reg
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_FROM_SLICE_U64 %out_heap, %slice_reg
+    EXPAND BINARY_HEAP_NEW %out_heap
+    EXPAND BINARY_HEAP_EXTEND_FROM_SLICE_U64 %out_heap, %slice_reg
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_FROM_SLICE_U64.
+[MACRO] BINARY_HEAP_FROM_SLICE %out_heap, %slice_reg
+    EXPAND BINARY_HEAP_FROM_SLICE_U64 %out_heap, %slice_reg
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_FROM_VEC_U64 %out_heap, %vec_reg
+    EXPAND VEC_AS_SLICE __bh_from_vec_slice_%out_heap, %vec_reg
+    EXPAND BINARY_HEAP_FROM_SLICE_U64 %out_heap, __bh_from_vec_slice_%out_heap
+    !__bh_from_vec_slice_%out_heap
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_FROM_VEC_U64.
+[MACRO] BINARY_HEAP_FROM_VEC %out_heap, %vec_reg
+    EXPAND BINARY_HEAP_FROM_VEC_U64 %out_heap, %vec_reg
+[END_MACRO]
+
+[MACRO] BINARY_HEAP_EXTEND_FROM_VEC_U64 %heap_reg, %vec_reg
+    EXPAND VEC_AS_SLICE __bh_ext_vec_slice_%heap_reg, %vec_reg
+    EXPAND BINARY_HEAP_EXTEND_FROM_SLICE_U64 %heap_reg, __bh_ext_vec_slice_%heap_reg
+    !__bh_ext_vec_slice_%heap_reg
+[END_MACRO]
+
+// Rust method-name alias over BINARY_HEAP_EXTEND_FROM_VEC_U64.
+[MACRO] BINARY_HEAP_EXTEND_FROM_VEC %heap_reg, %vec_reg
+    EXPAND BINARY_HEAP_EXTEND_FROM_VEC_U64 %heap_reg, %vec_reg
+[END_MACRO]
+
+// Linear membership query over the heap backing slice.
+[MACRO] BINARY_HEAP_CONTAINS %out_bool, %heap_reg, %needle
+    EXPAND BINARY_HEAP_AS_SLICE __bh_contains_slice_%out_bool, %heap_reg
+    EXPAND SLICE_CONTAINS_U64 %out_bool, __bh_contains_slice_%out_bool, %needle
+    !__bh_contains_slice_%out_bool
+[END_MACRO]
+// Rust Default-style empty BinaryHeap constructor alias.
+
+[MACRO] BINARY_HEAP_DEFAULT %out_heap
+    EXPAND BINARY_HEAP_NEW %out_heap
+[END_MACRO]
+
+// Eager extract_if: materialize matching values into Vec, rebuild heap with non-matching.
+
+// Eager extract_if without consuming heap storage: snapshot via as_slice, then rebuild.
+[MACRO] BINARY_HEAP_EXTRACT_IF %out_len, %out_vec, %heap_reg, %pred_fn
+    EXPAND VEC_NEW %out_vec
+    EXPAND BINARY_HEAP_AS_SLICE __bh_ei_slice_%out_len, %heap_reg
+    EXPAND SLICE_GET_LEN __bh_ei_n_%out_len, __bh_ei_slice_%out_len
+    EXPAND VEC_NEW __bh_ei_keep_%out_len
+    __bh_ei_i_slot_%out_len = stack_alloc 8
+    store __bh_ei_i_slot_%out_len+0, 0 as u64
+    jmp L_BH_EI_HEAD_%out_len
+L_BH_EI_HEAD_%out_len:
+    __bh_ei_i_%out_len = load __bh_ei_i_slot_%out_len+0 as u64
+    __bh_ei_done_%out_len = eq __bh_ei_i_%out_len, __bh_ei_n_%out_len
+    br __bh_ei_done_%out_len -> L_BH_EI_REBUILD_%out_len, L_BH_EI_BODY_%out_len
+L_BH_EI_BODY_%out_len:
+    EXPAND SLICE_GET_U64 __bh_ei_val_%out_len, __bh_ei_slice_%out_len, __bh_ei_i_%out_len
+    __bh_ei_pred_%out_len = call %pred_fn(__bh_ei_val_%out_len)
+    __bh_ei_take_%out_len = ne __bh_ei_pred_%out_len, 0
+    br __bh_ei_take_%out_len -> L_BH_EI_TAKE_%out_len, L_BH_EI_KEEP_%out_len
+L_BH_EI_TAKE_%out_len:
+    EXPAND VEC_PUSH_U64 %out_vec, __bh_ei_val_%out_len
+    jmp L_BH_EI_NEXT_%out_len
+L_BH_EI_KEEP_%out_len:
+    EXPAND VEC_PUSH_U64 __bh_ei_keep_%out_len, __bh_ei_val_%out_len
+    jmp L_BH_EI_NEXT_%out_len
+L_BH_EI_NEXT_%out_len:
+    __bh_ei_ni_%out_len = add __bh_ei_i_%out_len, 1
+    store __bh_ei_i_slot_%out_len+0, __bh_ei_ni_%out_len as u64
+    !__bh_ei_ni_%out_len
+    !__bh_ei_take_%out_len
+    !__bh_ei_pred_%out_len
+    !__bh_ei_val_%out_len
+    !__bh_ei_done_%out_len
+    !__bh_ei_i_%out_len
+    jmp L_BH_EI_HEAD_%out_len
+L_BH_EI_REBUILD_%out_len:
+    EXPAND BINARY_HEAP_CLEAR %heap_reg
+    EXPAND VEC_LEN __bh_ei_kn_%out_len, __bh_ei_keep_%out_len
+    store __bh_ei_i_slot_%out_len+0, 0 as u64
+    jmp L_BH_EI_PUSH_HEAD_%out_len
+L_BH_EI_PUSH_HEAD_%out_len:
+    __bh_ei_pi_%out_len = load __bh_ei_i_slot_%out_len+0 as u64
+    __bh_ei_pdone_%out_len = eq __bh_ei_pi_%out_len, __bh_ei_kn_%out_len
+    br __bh_ei_pdone_%out_len -> L_BH_EI_DONE_%out_len, L_BH_EI_PUSH_BODY_%out_len
+L_BH_EI_PUSH_BODY_%out_len:
+    EXPAND VEC_GET_U64 __bh_ei_kv_%out_len, __bh_ei_keep_%out_len, __bh_ei_pi_%out_len
+    EXPAND BINARY_HEAP_PUSH %heap_reg, __bh_ei_kv_%out_len
+    __bh_ei_pni_%out_len = add __bh_ei_pi_%out_len, 1
+    store __bh_ei_i_slot_%out_len+0, __bh_ei_pni_%out_len as u64
+    !__bh_ei_pni_%out_len
+    !__bh_ei_kv_%out_len
+    !__bh_ei_pdone_%out_len
+    !__bh_ei_pi_%out_len
+    jmp L_BH_EI_PUSH_HEAD_%out_len
+L_BH_EI_DONE_%out_len:
+    EXPAND VEC_LEN %out_len, %out_vec
+    EXPAND VEC_FREE __bh_ei_keep_%out_len
+    !__bh_ei_pdone_%out_len
+    !__bh_ei_pi_%out_len
+    !__bh_ei_kn_%out_len
+    !__bh_ei_done_%out_len
+    !__bh_ei_i_%out_len
+    !__bh_ei_n_%out_len
+    !__bh_ei_slice_%out_len
+[END_MACRO]