@salang/sa 0.1.2 → 0.1.4

package/sa_std/vec_deque.sa

@@ -0,0 +1,4925 @@
+// Fixed-capacity VecDeque backed by a circular buffer of raw u64 values.
+// This keeps the implementation verifier-friendly and concrete.
+@import "core/mem.sa"
+@import "core/slice.sal"
+@import "core/slice.sa"
+@import "alloc/vec.sal"
+@import "vec.sa"
+@import "num.sa"
+@import "vec_deque.sal"
+@import "hash.sa"
+
+@export sa_vec_deque_new() -> ^ptr:
+L_ENTRY:
+    deque = alloc VecDeque_SIZE
+    initial_bytes = mul VecDeque_INITIAL_CAP, VecDeque_SLOT_SIZE
+    buf = alloc initial_bytes
+    call @sa_mem_set(&buf, 0, initial_bytes)
+    store deque+VecDeque_buf, buf as ptr
+    store deque+VecDeque_cap, VecDeque_INITIAL_CAP as u64
+    store deque+VecDeque_head, 0 as u64
+    store deque+VecDeque_len, 0 as u64
+    ^buf
+    !initial_bytes
+    return deque
+
+@export sa_vec_deque_with_capacity(capacity: u64) -> ^ptr:
+L_ENTRY:
+    deque = alloc VecDeque_SIZE
+    EXPAND NUM_U64_CHECKED_MUL with_cap_bytes_ok, bytes, capacity, VecDeque_SLOT_SIZE
+    br with_cap_bytes_ok -> L_WITH_CAP_BYTES_OK, L_WITH_CAP_OVERFLOW
+
+L_WITH_CAP_OVERFLOW:
+    panic(1901)
+
+L_WITH_CAP_BYTES_OK:
+    has_bytes = ne bytes, 0
+    br has_bytes -> L_WITH_CAP_ALLOC, L_WITH_CAP_EMPTY
+
+L_WITH_CAP_ALLOC:
+    buf = alloc bytes
+    call @sa_mem_set(&buf, 0, bytes)
+    store deque+VecDeque_buf, buf as ptr
+    store deque+VecDeque_cap, capacity as u64
+    store deque+VecDeque_head, 0 as u64
+    store deque+VecDeque_len, 0 as u64
+    ^buf
+    !with_cap_bytes_ok
+    !has_bytes
+    !bytes
+    !capacity
+    return deque
+
+L_WITH_CAP_EMPTY:
+    store deque+VecDeque_buf, 0 as ptr
+    store deque+VecDeque_cap, 0 as u64
+    store deque+VecDeque_head, 0 as u64
+    store deque+VecDeque_len, 0 as u64
+    !with_cap_bytes_ok
+    !has_bytes
+    !bytes
+    !capacity
+    return deque
+
+@export sa_vec_deque_free(^deque: ptr) -> void:
+L_ENTRY:
+    buf = load deque+VecDeque_buf as ptr
+    !buf
+    !deque
+    return
+
+@export sa_vec_deque_len(&deque: ptr) -> u64:
+L_ENTRY:
+    len = load deque+VecDeque_len as u64
+    !deque
+    return len
+
+@export sa_vec_deque_capacity(&deque: ptr) -> u64:
+L_ENTRY:
+    cap = load deque+VecDeque_cap as u64
+    !deque
+    return cap
+
+@export sa_vec_deque_is_empty(&deque: ptr) -> i32:
+L_ENTRY:
+    len = load deque+VecDeque_len as u64
+    empty = eq len, 0
+    result = empty as i32
+    !len
+    !deque
+    return result
+
+@vec_deque_next_capacity(needed: u64) -> u64:
+L_ENTRY:
+    cap_slot = stack_alloc 8
+    store cap_slot+0, VecDeque_INITIAL_CAP as u64
+    jmp L_NEXT_CAP_HEAD
+
+L_NEXT_CAP_HEAD:
+    cap = load cap_slot+0 as u64
+    enough = uge cap, needed
+    br enough -> 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(1902)
+
+L_NEXT_CAP_GROW_OK:
+    store cap_slot+0, next_cap as u64
+    !next_cap_ok
+    !next_cap
+    !enough
+    !cap
+    jmp L_NEXT_CAP_HEAD
+
+L_NEXT_CAP_DONE:
+    !enough
+    !needed
+    return cap
+
+@vec_deque_realloc(&deque: ptr, target_cap: u64) -> void:
+L_ENTRY:
+    len = load deque+VecDeque_len as u64
+    target_zero = eq target_cap, 0
+    br target_zero -> L_DEQUE_REALLOC_ZERO, L_DEQUE_REALLOC_ALLOC
+
+L_DEQUE_REALLOC_ZERO:
+    old_buf_zero = take deque+VecDeque_buf
+    !old_buf_zero
+    store deque+VecDeque_buf, 0 as ptr
+    store deque+VecDeque_cap, 0 as u64
+    store deque+VecDeque_head, 0 as u64
+    store deque+VecDeque_len, 0 as u64
+    !target_zero
+    !len
+    !target_cap
+    !deque
+    return
+
+L_DEQUE_REALLOC_ALLOC:
+    old_buf = take deque+VecDeque_buf
+    old_cap = load deque+VecDeque_cap as u64
+    head = load deque+VecDeque_head as u64
+    EXPAND NUM_U64_CHECKED_MUL realloc_bytes_ok, new_bytes, target_cap, VecDeque_SLOT_SIZE
+    br realloc_bytes_ok -> L_DEQUE_REALLOC_BYTES_OK, L_DEQUE_REALLOC_OVERFLOW
+
+L_DEQUE_REALLOC_OVERFLOW:
+    panic(1903)
+
+L_DEQUE_REALLOC_BYTES_OK:
+    new_buf = alloc new_bytes
+    call @sa_mem_set(&new_buf, 0, new_bytes)
+    idx_slot = stack_alloc 8
+    store idx_slot+0, 0 as u64
+    jmp L_DEQUE_REALLOC_COPY_HEAD
+
+L_DEQUE_REALLOC_COPY_HEAD:
+    idx = load idx_slot+0 as u64
+    done = eq idx, len
+    br done -> L_DEQUE_REALLOC_COPY_DONE, L_DEQUE_REALLOC_COPY_BODY
+
+L_DEQUE_REALLOC_COPY_BODY:
+    old_sum = add head, idx
+    old_phys = urem old_sum, old_cap
+    old_off = mul old_phys, VecDeque_SLOT_SIZE
+    old_ptr = ptr_add old_buf, old_off
+    new_off = mul idx, VecDeque_SLOT_SIZE
+    new_ptr = ptr_add new_buf, new_off
+    value = load old_ptr+0 as u64
+    store new_ptr+0, value as u64
+    next_idx = add idx, 1
+    store idx_slot+0, next_idx as u64
+    !next_idx
+    !value
+    !new_ptr
+    !new_off
+    !old_ptr
+    !old_off
+    !old_phys
+    !old_sum
+    !done
+    !idx
+    jmp L_DEQUE_REALLOC_COPY_HEAD
+
+L_DEQUE_REALLOC_COPY_DONE:
+    store deque+VecDeque_buf, new_buf as ptr
+    store deque+VecDeque_cap, target_cap as u64
+    store deque+VecDeque_head, 0 as u64
+    store deque+VecDeque_len, len as u64
+    !done
+    !idx
+    !realloc_bytes_ok
+    !new_bytes
+    !head
+    !old_cap
+    !old_buf
+    ^new_buf
+    !target_zero
+    !len
+    !target_cap
+    !deque
+    return
+
+@export sa_vec_deque_reserve(&deque: ptr, additional: u64) -> void:
+L_ENTRY:
+    len = load deque+VecDeque_len as u64
+    cap = load deque+VecDeque_cap as u64
+    EXPAND NUM_U64_CHECKED_ADD reserve_needed_ok, needed, len, additional
+    br reserve_needed_ok -> L_DEQUE_RESERVE_NEEDED_OK, L_DEQUE_RESERVE_OVERFLOW
+
+L_DEQUE_RESERVE_OVERFLOW:
+    panic(1904)
+
+L_DEQUE_RESERVE_NEEDED_OK:
+    has_room = uge cap, needed
+    br has_room -> L_DEQUE_RESERVE_DONE, L_DEQUE_RESERVE_GROW
+
+L_DEQUE_RESERVE_GROW:
+    target_cap = call @vec_deque_next_capacity(needed)
+    call @vec_deque_realloc(&deque, target_cap)
+    !target_cap
+    !has_room
+    !needed
+    !reserve_needed_ok
+    !cap
+    !len
+    !additional
+    !deque
+    return
+
+L_DEQUE_RESERVE_DONE:
+    !has_room
+    !needed
+    !reserve_needed_ok
+    !cap
+    !len
+    !additional
+    !deque
+    return
+
+@export sa_vec_deque_reserve_exact(&deque: ptr, additional: u64) -> void:
+L_ENTRY:
+    len = load deque+VecDeque_len as u64
+    cap = load deque+VecDeque_cap as u64
+    EXPAND NUM_U64_CHECKED_ADD reserve_exact_needed_ok, needed, len, additional
+    br reserve_exact_needed_ok -> L_DEQUE_RESERVE_EXACT_NEEDED_OK, L_DEQUE_RESERVE_EXACT_OVERFLOW
+
+L_DEQUE_RESERVE_EXACT_OVERFLOW:
+    panic(1905)
+
+L_DEQUE_RESERVE_EXACT_NEEDED_OK:
+    has_room = uge cap, needed
+    br has_room -> L_DEQUE_RESERVE_EXACT_DONE, L_DEQUE_RESERVE_EXACT_GROW
+
+L_DEQUE_RESERVE_EXACT_GROW:
+    call @vec_deque_realloc(&deque, needed)
+    !has_room
+    !needed
+    !reserve_exact_needed_ok
+    !cap
+    !len
+    !additional
+    !deque
+    return
+
+L_DEQUE_RESERVE_EXACT_DONE:
+    !has_room
+    !needed
+    !reserve_exact_needed_ok
+    !cap
+    !len
+    !additional
+    !deque
+    return
+
+@export sa_vec_deque_try_reserve(&deque: ptr, additional: u64) -> i32:
+L_ENTRY:
+    call @sa_vec_deque_reserve(&deque, additional)
+    !additional
+    !deque
+    return 1
+
+@export sa_vec_deque_try_reserve_exact(&deque: ptr, additional: u64) -> i32:
+L_ENTRY:
+    call @sa_vec_deque_reserve_exact(&deque, additional)
+    !additional
+    !deque
+    return 1
+
+@export sa_vec_deque_shrink_to(&deque: ptr, min_capacity: u64) -> void:
+L_ENTRY:
+    len = load deque+VecDeque_len as u64
+    cap = load deque+VecDeque_cap as u64
+    keep_len = uge len, min_capacity
+    br keep_len -> L_DEQUE_SHRINK_TARGET_LEN, L_DEQUE_SHRINK_TARGET_MIN
+
+L_DEQUE_SHRINK_TARGET_LEN:
+    target_cap = add len, 0
+    jmp L_DEQUE_SHRINK_CHECK
+
+L_DEQUE_SHRINK_TARGET_MIN:
+    target_cap = add min_capacity, 0
+    jmp L_DEQUE_SHRINK_CHECK
+
+L_DEQUE_SHRINK_CHECK:
+    needs_shrink = ult target_cap, cap
+    br needs_shrink -> L_DEQUE_SHRINK_RUN, L_DEQUE_SHRINK_DONE
+
+L_DEQUE_SHRINK_RUN:
+    call @vec_deque_realloc(&deque, target_cap)
+    !needs_shrink
+    !target_cap
+    !keep_len
+    !cap
+    !len
+    !min_capacity
+    !deque
+    return
+
+L_DEQUE_SHRINK_DONE:
+    !needs_shrink
+    !target_cap
+    !keep_len
+    !cap
+    !len
+    !min_capacity
+    !deque
+    return
+
+@export sa_vec_deque_shrink_to_fit(&deque: ptr) -> void:
+L_ENTRY:
+    len = load deque+VecDeque_len as u64
+    call @sa_vec_deque_shrink_to(&deque, len)
+    !len
+    !deque
+    return
+
+@export sa_vec_deque_try_shrink_to(&deque: ptr, min_capacity: u64) -> i32:
+L_ENTRY:
+    call @sa_vec_deque_shrink_to(&deque, min_capacity)
+    !min_capacity
+    !deque
+    return 1
+
+@export sa_vec_deque_try_shrink_to_fit(&deque: ptr) -> i32:
+L_ENTRY:
+    call @sa_vec_deque_shrink_to_fit(&deque)
+    !deque
+    return 1
+
+@vec_deque_force_contiguous(&deque: ptr) -> void:
+L_ENTRY:
+    head = load deque+VecDeque_head as u64
+    already_front = eq head, 0
+    br already_front -> L_FORCE_DONE, L_FORCE_RUN
+
+L_FORCE_RUN:
+    cap = load deque+VecDeque_cap as u64
+    call @vec_deque_realloc(&deque, cap)
+    !cap
+    !already_front
+    !head
+    !deque
+    return
+
+L_FORCE_DONE:
+    !already_front
+    !head
+    !deque
+    return
+
+@export sa_vec_deque_as_slices(&deque: ptr, &out_front_slice: ptr, &out_back_slice: ptr) -> void:
+L_ENTRY:
+    len = load deque+VecDeque_len as u64
+    empty = eq len, 0
+    br empty -> L_AS_SLICES_EMPTY, L_AS_SLICES_NONEMPTY
+
+L_AS_SLICES_EMPTY:
+    store out_front_slice+Slice_ptr, 0 as ptr
+    store out_front_slice+Slice_len, 0 as u64
+    store out_back_slice+Slice_ptr, 0 as ptr
+    store out_back_slice+Slice_len, 0 as u64
+    !empty
+    !len
+    !out_back_slice
+    !out_front_slice
+    !deque
+    return
+
+L_AS_SLICES_NONEMPTY:
+    buf = load deque+VecDeque_buf as ptr
+    head = load deque+VecDeque_head as u64
+    cap = load deque+VecDeque_cap as u64
+    head_off = mul head, VecDeque_SLOT_SIZE
+    front_ptr = ptr_add buf, head_off
+    front_room = sub cap, head
+    one_slice = ule len, front_room
+    br one_slice -> L_AS_SLICES_ONE, L_AS_SLICES_TWO
+
+L_AS_SLICES_ONE:
+    store out_front_slice+Slice_ptr, front_ptr as ptr
+    store out_front_slice+Slice_len, len as u64
+    store out_back_slice+Slice_ptr, 0 as ptr
+    store out_back_slice+Slice_len, 0 as u64
+    !one_slice
+    !front_room
+    !front_ptr
+    !head_off
+    !cap
+    !head
+    !buf
+    !empty
+    !len
+    !out_back_slice
+    !out_front_slice
+    !deque
+    return
+
+L_AS_SLICES_TWO:
+    back_len = sub len, front_room
+    store out_front_slice+Slice_ptr, front_ptr as ptr
+    store out_front_slice+Slice_len, front_room as u64
+    store out_back_slice+Slice_ptr, buf as ptr
+    store out_back_slice+Slice_len, back_len as u64
+    !back_len
+    !one_slice
+    !front_room
+    !front_ptr
+    !head_off
+    !cap
+    !head
+    !buf
+    !empty
+    !len
+    !out_back_slice
+    !out_front_slice
+    !deque
+    return
+
+@export sa_vec_deque_as_mut_slices(&deque: ptr, &out_front_slice: ptr, &out_back_slice: ptr) -> void:
+L_ENTRY:
+    call @sa_vec_deque_as_slices(&deque, &out_front_slice, &out_back_slice)
+    !out_back_slice
+    !out_front_slice
+    !deque
+    return
+
+@export sa_vec_deque_make_contiguous(&deque: ptr, &out_slice: ptr) -> void:
+L_ENTRY:
+    len = load deque+VecDeque_len as u64
+    empty = eq len, 0
+    br empty -> L_MAKE_CONTIG_EMPTY, L_MAKE_CONTIG_CHECK
+
+L_MAKE_CONTIG_EMPTY:
+    store out_slice+Slice_ptr, 0 as ptr
+    store out_slice+Slice_len, 0 as u64
+    !empty
+    !len
+    !out_slice
+    !deque
+    return
+
+L_MAKE_CONTIG_CHECK:
+    head = load deque+VecDeque_head as u64
+    cap = load deque+VecDeque_cap as u64
+    front_room = sub cap, head
+    wrapped = ugt len, front_room
+    br wrapped -> L_MAKE_CONTIG_REALLOC, L_MAKE_CONTIG_VIEW
+
+L_MAKE_CONTIG_REALLOC:
+    call @vec_deque_realloc(&deque, cap)
+    new_buf = load deque+VecDeque_buf as ptr
+    store out_slice+Slice_ptr, new_buf as ptr
+    store out_slice+Slice_len, len as u64
+    !new_buf
+    !wrapped
+    !front_room
+    !cap
+    !head
+    !empty
+    !len
+    !out_slice
+    !deque
+    return
+
+L_MAKE_CONTIG_VIEW:
+    buf = load deque+VecDeque_buf as ptr
+    head_off = mul head, VecDeque_SLOT_SIZE
+    data_ptr = ptr_add buf, head_off
+    store out_slice+Slice_ptr, data_ptr as ptr
+    store out_slice+Slice_len, len as u64
+    !data_ptr
+    !head_off
+    !buf
+    !wrapped
+    !front_room
+    !cap
+    !head
+    !empty
+    !len
+    !out_slice
+    !deque
+    return
+
+@export sa_vec_deque_get(&deque: ptr, index: u64) -> u64:
+L_ENTRY:
+    len = load deque+VecDeque_len as u64
+    in_range = ult index, len
+    br in_range -> L_GET_HIT, L_GET_MISS
+L_GET_HIT:
+    buf = load deque+VecDeque_buf as ptr
+    head = load deque+VecDeque_head as u64
+    cap = load deque+VecDeque_cap as u64
+    head_plus = add head, index
+    phys_index = urem head_plus, cap
+    off = mul phys_index, VecDeque_SLOT_SIZE
+    slot = ptr_add buf, off
+    value = load slot+0 as u64
+    !slot
+    !off
+    !head_plus
+    !phys_index
+    !buf
+    !head
+    !cap
+    !index
+    !len
+    !in_range
+    !deque
+    return value
+L_GET_MISS:
+    !index
+    !len
+    !in_range
+    !deque
+    return 0
+
+@export sa_vec_deque_try_get(&deque: ptr, index: u64, &out_value_slot: ptr) -> i32:
+L_ENTRY:
+    len = load deque+VecDeque_len as u64
+    in_range = ult index, len
+    br in_range -> L_TRY_GET_HIT, L_TRY_GET_MISS
+
+L_TRY_GET_HIT:
+    buf = load deque+VecDeque_buf as ptr
+    head = load deque+VecDeque_head as u64
+    cap = load deque+VecDeque_cap as u64
+    head_plus = add head, index
+    phys_index = urem head_plus, cap
+    off = mul phys_index, VecDeque_SLOT_SIZE
+    slot = ptr_add buf, off
+    value = load slot+0 as u64
+    store out_value_slot+0, value as u64
+    !value
+    !slot
+    !off
+    !phys_index
+    !head_plus
+    !cap
+    !head
+    !buf
+    !in_range
+    !len
+    !index
+    !out_value_slot
+    !deque
+    return 1
+
+L_TRY_GET_MISS:
+    store out_value_slot+0, 0 as u64
+    !in_range
+    !len
+    !index
+    !out_value_slot
+    !deque
+    return 0
+
+@export sa_vec_deque_try_get_mut_ptr(&deque: ptr, index: u64, &out_ptr_slot: ptr) -> i32:
+L_ENTRY:
+    len = load deque+VecDeque_len as u64
+    in_range = ult index, len
+    br in_range -> L_GET_MUT_HIT, L_GET_MUT_MISS
+
+L_GET_MUT_HIT:
+    buf = load deque+VecDeque_buf as ptr
+    head = load deque+VecDeque_head as u64
+    cap = load deque+VecDeque_cap as u64
+    head_plus = add head, index
+    phys_index = urem head_plus, cap
+    off = mul phys_index, VecDeque_SLOT_SIZE
+    slot = ptr_add buf, off
+    store out_ptr_slot+0, slot as ptr
+    !slot
+    !off
+    !phys_index
+    !head_plus
+    !cap
+    !head
+    !buf
+    !in_range
+    !len
+    !index
+    !out_ptr_slot
+    !deque
+    return 1
+
+L_GET_MUT_MISS:
+    store out_ptr_slot+0, 0 as ptr
+    !in_range
+    !len
+    !index
+    !out_ptr_slot
+    !deque
+    return 0
+
+@export sa_vec_deque_try_front_mut_ptr(&deque: ptr, &out_ptr_slot: ptr) -> i32:
+L_ENTRY:
+    ok = call @sa_vec_deque_try_get_mut_ptr(&deque, 0, &out_ptr_slot)
+    !out_ptr_slot
+    !deque
+    return ok
+
+@export sa_vec_deque_try_back_mut_ptr(&deque: ptr, &out_ptr_slot: ptr) -> i32:
+L_ENTRY:
+    len = load deque+VecDeque_len as u64
+    empty = eq len, 0
+    br empty -> L_BACK_MUT_EMPTY, L_BACK_MUT_READY
+
+L_BACK_MUT_READY:
+    last = sub len, 1
+    ok = call @sa_vec_deque_try_get_mut_ptr(&deque, last, &out_ptr_slot)
+    !last
+    !empty
+    !len
+    !out_ptr_slot
+    !deque
+    return ok
+
+L_BACK_MUT_EMPTY:
+    store out_ptr_slot+0, 0 as ptr
+    !empty
+    !len
+    !out_ptr_slot
+    !deque
+    return 0
+
+@export sa_vec_deque_set(&deque: ptr, index: u64, value: u64) -> i32:
+L_ENTRY:
+    len = load deque+VecDeque_len as u64
+    in_range = ult index, len
+    br in_range -> L_SET_HIT, L_SET_MISS
+
+L_SET_HIT:
+    buf = load deque+VecDeque_buf as ptr
+    head = load deque+VecDeque_head as u64
+    cap = load deque+VecDeque_cap as u64
+    head_plus = add head, index
+    phys_index = urem head_plus, cap
+    off = mul phys_index, VecDeque_SLOT_SIZE
+    slot = ptr_add buf, off
+    store slot+0, value as u64
+    !slot
+    !off
+    !phys_index
+    !head_plus
+    !cap
+    !head
+    !buf
+    !in_range
+    !len
+    !value
+    !index
+    !deque
+    return 1
+
+L_SET_MISS:
+    !in_range
+    !len
+    !value
+    !index
+    !deque
+    return 0
+
+@export sa_vec_deque_contains(&deque: ptr, needle: u64) -> i32:
+L_ENTRY:
+    len = load deque+VecDeque_len as u64
+    buf = load deque+VecDeque_buf as ptr
+    head = load deque+VecDeque_head as u64
+    cap = load deque+VecDeque_cap as u64
+    idx_slot = stack_alloc 8
+    store idx_slot+0, 0 as u64
+    jmp L_CONTAINS_HEAD
+
+L_CONTAINS_HEAD:
+    idx = load idx_slot+0 as u64
+    done = eq idx, len
+    br done -> L_CONTAINS_MISS, L_CONTAINS_BODY
+
+L_CONTAINS_BODY:
+    head_plus = add head, idx
+    phys_index = urem head_plus, cap
+    off = mul phys_index, VecDeque_SLOT_SIZE
+    slot = ptr_add buf, off
+    value = load slot+0 as u64
+    matched = eq value, needle
+    br matched -> L_CONTAINS_HIT, L_CONTAINS_NEXT
+
+L_CONTAINS_NEXT:
+    next_idx = add idx, 1
+    store idx_slot+0, next_idx as u64
+    !next_idx
+    !matched
+    !value
+    !slot
+    !off
+    !phys_index
+    !head_plus
+    !done
+    !idx
+    jmp L_CONTAINS_HEAD
+
+L_CONTAINS_HIT:
+    !matched
+    !value
+    !slot
+    !off
+    !phys_index
+    !head_plus
+    !done
+    !idx
+    !cap
+    !head
+    !buf
+    !len
+    !needle
+    !deque
+    return 1
+
+L_CONTAINS_MISS:
+    !done
+    !idx
+    !cap
+    !head
+    !buf
+    !len
+    !needle
+    !deque
+    return 0
+
+@export sa_vec_deque_swap(&deque: ptr, left: u64, right: u64) -> i32:
+L_ENTRY:
+    len = load deque+VecDeque_len as u64
+    left_ok = ult left, len
+    right_ok = ult right, len
+    both_ok = and left_ok, right_ok
+    br both_ok -> L_SWAP_READY, L_SWAP_MISS
+
+L_SWAP_READY:
+    buf = load deque+VecDeque_buf as ptr
+    head = load deque+VecDeque_head as u64
+    cap = load deque+VecDeque_cap as u64
+    left_sum = add head, left
+    left_phys = urem left_sum, cap
+    left_off = mul left_phys, VecDeque_SLOT_SIZE
+    left_ptr = ptr_add buf, left_off
+    right_sum = add head, right
+    right_phys = urem right_sum, cap
+    right_off = mul right_phys, VecDeque_SLOT_SIZE
+    right_ptr = ptr_add buf, right_off
+    left_value = load left_ptr+0 as u64
+    right_value = load right_ptr+0 as u64
+    store left_ptr+0, right_value as u64
+    store right_ptr+0, left_value as u64
+    !right_value
+    !left_value
+    !right_ptr
+    !right_off
+    !right_phys
+    !right_sum
+    !left_ptr
+    !left_off
+    !left_phys
+    !left_sum
+    !cap
+    !head
+    !buf
+    !both_ok
+    !right_ok
+    !left_ok
+    !len
+    !right
+    !left
+    !deque
+    return 1
+
+L_SWAP_MISS:
+    !both_ok
+    !right_ok
+    !left_ok
+    !len
+    !right
+    !left
+    !deque
+    return 0
+
+@export sa_vec_deque_try_insert(&deque: ptr, index: u64, value: u64) -> i32:
+L_ENTRY:
+    len = load deque+VecDeque_len as u64
+    in_bounds = ule index, len
+    br in_bounds -> L_INSERT_READY, L_INSERT_MISS
+
+L_INSERT_READY:
+    call @sa_vec_deque_reserve(&deque, 1)
+    call @vec_deque_force_contiguous(&deque)
+    buf = load deque+VecDeque_buf as ptr
+    idx_slot = stack_alloc 8
+    store idx_slot+0, len as u64
+    jmp L_INSERT_SHIFT_HEAD
+
+L_INSERT_SHIFT_HEAD:
+    idx = load idx_slot+0 as u64
+    done = ule idx, index
+    br done -> L_INSERT_STORE, L_INSERT_SHIFT_BODY
+
+L_INSERT_SHIFT_BODY:
+    src_idx = sub idx, 1
+    src_off = mul src_idx, VecDeque_SLOT_SIZE
+    src_ptr = ptr_add buf, src_off
+    dst_off = mul idx, VecDeque_SLOT_SIZE
+    dst_ptr = ptr_add buf, dst_off
+    shifted = load src_ptr+0 as u64
+    store dst_ptr+0, shifted as u64
+    store idx_slot+0, src_idx as u64
+    !shifted
+    !dst_ptr
+    !dst_off
+    !src_ptr
+    !src_off
+    !src_idx
+    !done
+    !idx
+    jmp L_INSERT_SHIFT_HEAD
+
+L_INSERT_STORE:
+    insert_off = mul index, VecDeque_SLOT_SIZE
+    insert_ptr = ptr_add buf, insert_off
+    store insert_ptr+0, value as u64
+    next_len = add len, 1
+    store deque+VecDeque_len, next_len as u64
+    store deque+VecDeque_head, 0 as u64
+    !next_len
+    !insert_ptr
+    !insert_off
+    !done
+    !idx
+    !buf
+    !in_bounds
+    !len
+    !value
+    !index
+    !deque
+    return 1
+
+L_INSERT_MISS:
+    !in_bounds
+    !len
+    !value
+    !index
+    !deque
+    return 0
+
+@export sa_vec_deque_try_remove(&deque: ptr, index: u64, &out_value_slot: ptr) -> i32:
+L_ENTRY:
+    len = load deque+VecDeque_len as u64
+    in_bounds = ult index, len
+    br in_bounds -> L_REMOVE_READY, L_REMOVE_MISS
+
+L_REMOVE_READY:
+    call @vec_deque_force_contiguous(&deque)
+    buf = load deque+VecDeque_buf as ptr
+    remove_off = mul index, VecDeque_SLOT_SIZE
+    remove_ptr = ptr_add buf, remove_off
+    removed = load remove_ptr+0 as u64
+    last_index = sub len, 1
+    idx_slot = stack_alloc 8
+    store idx_slot+0, index as u64
+    jmp L_REMOVE_SHIFT_HEAD
+
+L_REMOVE_SHIFT_HEAD:
+    idx = load idx_slot+0 as u64
+    done = uge idx, last_index
+    br done -> L_REMOVE_STORE, L_REMOVE_SHIFT_BODY
+
+L_REMOVE_SHIFT_BODY:
+    src_idx = add idx, 1
+    src_off = mul src_idx, VecDeque_SLOT_SIZE
+    src_ptr = ptr_add buf, src_off
+    dst_off = mul idx, VecDeque_SLOT_SIZE
+    dst_ptr = ptr_add buf, dst_off
+    shifted = load src_ptr+0 as u64
+    store dst_ptr+0, shifted as u64
+    store idx_slot+0, src_idx as u64
+    !shifted
+    !dst_ptr
+    !dst_off
+    !src_ptr
+    !src_off
+    !src_idx
+    !done
+    !idx
+    jmp L_REMOVE_SHIFT_HEAD
+
+L_REMOVE_STORE:
+    next_len = sub len, 1
+    store deque+VecDeque_len, next_len as u64
+    store deque+VecDeque_head, 0 as u64
+    store out_value_slot+0, removed as u64
+    !next_len
+    !done
+    !idx
+    !last_index
+    !removed
+    !remove_ptr
+    !remove_off
+    !buf
+    !in_bounds
+    !len
+    !index
+    !out_value_slot
+    !deque
+    return 1
+
+L_REMOVE_MISS:
+    store out_value_slot+0, 0 as u64
+    !in_bounds
+    !len
+    !index
+    !out_value_slot
+    !deque
+    return 0
+
+@export sa_vec_deque_try_swap_remove_front(&deque: ptr, index: u64, &out_value_slot: ptr) -> i32:
+L_ENTRY:
+    len = load deque+VecDeque_len as u64
+    in_bounds = ult index, len
+    br in_bounds -> L_SWAP_REMOVE_FRONT_READY, L_SWAP_REMOVE_FRONT_MISS
+
+L_SWAP_REMOVE_FRONT_READY:
+    removed = call @sa_vec_deque_get(&deque, index)
+    front_value = call @sa_vec_deque_front(&deque)
+    ptr_slot = stack_alloc 8
+    ptr_ok = call @sa_vec_deque_try_get_mut_ptr(&deque, index, &ptr_slot)
+    slot = load ptr_slot+0 as ptr
+    store slot+0, front_value as u64
+    pop_slot = stack_alloc 8
+    pop_ok = call @sa_vec_deque_try_pop_front(&deque, &pop_slot)
+    store out_value_slot+0, removed as u64
+    !pop_ok
+    !slot
+    !ptr_ok
+    !front_value
+    !removed
+    !in_bounds
+    !len
+    !index
+    !out_value_slot
+    !deque
+    return 1
+
+L_SWAP_REMOVE_FRONT_MISS:
+    store out_value_slot+0, 0 as u64
+    !in_bounds
+    !len
+    !index
+    !out_value_slot
+    !deque
+    return 0
+
+@export sa_vec_deque_try_swap_remove_back(&deque: ptr, index: u64, &out_value_slot: ptr) -> i32:
+L_ENTRY:
+    len = load deque+VecDeque_len as u64
+    in_bounds = ult index, len
+    br in_bounds -> L_SWAP_REMOVE_BACK_READY, L_SWAP_REMOVE_BACK_MISS
+
+L_SWAP_REMOVE_BACK_READY:
+    removed = call @sa_vec_deque_get(&deque, index)
+    back_value = call @sa_vec_deque_back(&deque)
+    ptr_slot = stack_alloc 8
+    ptr_ok = call @sa_vec_deque_try_get_mut_ptr(&deque, index, &ptr_slot)
+    slot = load ptr_slot+0 as ptr
+    store slot+0, back_value as u64
+    pop_slot = stack_alloc 8
+    pop_ok = call @sa_vec_deque_try_pop_back(&deque, &pop_slot)
+    store out_value_slot+0, removed as u64
+    !pop_ok
+    !slot
+    !ptr_ok
+    !back_value
+    !removed
+    !in_bounds
+    !len
+    !index
+    !out_value_slot
+    !deque
+    return 1
+
+L_SWAP_REMOVE_BACK_MISS:
+    store out_value_slot+0, 0 as u64
+    !in_bounds
+    !len
+    !index
+    !out_value_slot
+    !deque
+    return 0
+
+@export sa_vec_deque_push_back(&deque: ptr, value: u64) -> void:
+L_ENTRY:
+    len = load deque+VecDeque_len as u64
+    cap = load deque+VecDeque_cap as u64
+    room = ult len, cap
+    br room -> L_PUSH_BACK_OK, L_PUSH_BACK_FULL
+L_PUSH_BACK_OK:
+    buf = load deque+VecDeque_buf as ptr
+    head = load deque+VecDeque_head as u64
+    tail_sum = add head, len
+    tail_index = urem tail_sum, cap
+    tail_off = mul tail_index, VecDeque_SLOT_SIZE
+    tail_ptr = ptr_add buf, tail_off
+    store tail_ptr+0, value as u64
+    next_len = add len, 1
+    store deque+VecDeque_len, next_len as u64
+    !tail_ptr
+    !tail_off
+    !tail_index
+    !tail_sum
+    !next_len
+    !room
+    !buf
+    !head
+    !cap
+    !len
+    !value
+    !deque
+    return
+L_PUSH_BACK_FULL:
+    call @sa_vec_deque_reserve(&deque, 1)
+    !room
+    !cap
+    !len
+    jmp L_ENTRY
+
+@export sa_vec_deque_push_front(&deque: ptr, value: u64) -> void:
+L_ENTRY:
+    len = load deque+VecDeque_len as u64
+    cap = load deque+VecDeque_cap as u64
+    room = ult len, cap
+    br room -> L_PUSH_FRONT_OK, L_PUSH_FRONT_FULL
+L_PUSH_FRONT_OK:
+    buf = load deque+VecDeque_buf as ptr
+    head = load deque+VecDeque_head as u64
+    cap_minus_one = sub cap, 1
+    head_plus = add head, cap_minus_one
+    new_head = urem head_plus, cap
+    head_off = mul new_head, VecDeque_SLOT_SIZE
+    head_ptr = ptr_add buf, head_off
+    store head_ptr+0, value as u64
+    next_len = add len, 1
+    store deque+VecDeque_head, new_head as u64
+    store deque+VecDeque_len, next_len as u64
+    !head_ptr
+    !head_off
+    !new_head
+    !cap_minus_one
+    !head_plus
+    !room
+    !buf
+    !head
+    !cap
+    !next_len
+    !len
+    !value
+    !deque
+    return
+L_PUSH_FRONT_FULL:
+    call @sa_vec_deque_reserve(&deque, 1)
+    !room
+    !cap
+    !len
+    jmp L_ENTRY
+
+@export sa_vec_deque_try_pop_front(&deque: ptr, &out_value_slot: ptr) -> i32:
+L_ENTRY:
+    len = load deque+VecDeque_len as u64
+    empty = eq len, 0
+    br empty -> L_POP_FRONT_EMPTY, L_POP_FRONT_READY
+L_POP_FRONT_READY:
+    buf = load deque+VecDeque_buf as ptr
+    head = load deque+VecDeque_head as u64
+    cap = load deque+VecDeque_cap as u64
+    head_off = mul head, VecDeque_SLOT_SIZE
+    head_ptr = ptr_add buf, head_off
+    value = load head_ptr+0 as u64
+    next_head = add head, 1
+    next_head2 = urem next_head, cap
+L_POP_FRONT_STORE:
+    next_len = sub len, 1
+    store out_value_slot+0, value as u64
+    store deque+VecDeque_len, next_len as u64
+    store deque+VecDeque_head, next_head2 as u64
+    !next_head2
+    !next_head
+    !next_len
+    !value
+    !head_ptr
+    !head_off
+    !head
+    !cap
+    !buf
+    !len
+    !out_value_slot
+    !deque
+    return 1
+L_POP_FRONT_EMPTY:
+    store out_value_slot+0, 0 as u64
+    !empty
+    !len
+    !out_value_slot
+    !deque
+    return 0
+
+@export sa_vec_deque_try_pop_back(&deque: ptr, &out_value_slot: ptr) -> i32:
+L_ENTRY:
+    len = load deque+VecDeque_len as u64
+    empty = eq len, 0
+    br empty -> L_POP_BACK_EMPTY, L_POP_BACK_READY
+L_POP_BACK_READY:
+    buf = load deque+VecDeque_buf as ptr
+    head = load deque+VecDeque_head as u64
+    cap = load deque+VecDeque_cap as u64
+    last_index = sub len, 1
+    tail_sum = add head, last_index
+    tail_index = urem tail_sum, cap
+    tail_off = mul tail_index, VecDeque_SLOT_SIZE
+    tail_ptr = ptr_add buf, tail_off
+    value = load tail_ptr+0 as u64
+    next_len = sub len, 1
+L_POP_BACK_STORE:
+    store out_value_slot+0, value as u64
+    store deque+VecDeque_len, next_len as u64
+    store deque+VecDeque_head, head as u64
+    !tail_sum
+    !tail_index
+    !tail_ptr
+    !tail_off
+    !last_index
+    !next_len
+    !value
+    !head
+    !cap
+    !buf
+    !len
+    !out_value_slot
+    !deque
+    return 1
+L_POP_BACK_EMPTY:
+    store out_value_slot+0, 0 as u64
+    !empty
+    !len
+    !out_value_slot
+    !deque
+    return 0
+
+@export sa_vec_deque_front(&deque: ptr) -> u64:
+L_ENTRY:
+    len = load deque+VecDeque_len as u64
+    empty = eq len, 0
+    br empty -> L_FRONT_EMPTY, L_FRONT_READY
+L_FRONT_READY:
+    buf = load deque+VecDeque_buf as ptr
+    head = load deque+VecDeque_head as u64
+    head_off = mul head, VecDeque_SLOT_SIZE
+    head_ptr = ptr_add buf, head_off
+    value = load head_ptr+0 as u64
+    !head_ptr
+    !head_off
+    !head
+    !buf
+    !empty
+    !len
+    !deque
+    return value
+L_FRONT_EMPTY:
+    !empty
+    !len
+    !deque
+    return 0
+
+@export sa_vec_deque_back(&deque: ptr) -> u64:
+L_ENTRY:
+    len = load deque+VecDeque_len as u64
+    empty = eq len, 0
+    br empty -> L_BACK_EMPTY, L_BACK_READY
+L_BACK_READY:
+    buf = load deque+VecDeque_buf as ptr
+    head = load deque+VecDeque_head as u64
+    cap = load deque+VecDeque_cap as u64
+    last_index = sub len, 1
+    tail_sum = add head, last_index
+    tail_index = urem tail_sum, cap
+    tail_off = mul tail_index, VecDeque_SLOT_SIZE
+    tail_ptr = ptr_add buf, tail_off
+    value = load tail_ptr+0 as u64
+    !tail_ptr
+    !tail_off
+    !tail_index
+    !tail_sum
+    !last_index
+    !cap
+    !head
+    !buf
+    !empty
+    !len
+    !deque
+    return value
+L_BACK_EMPTY:
+    !empty
+    !len
+    !deque
+    return 0
+
+@export sa_vec_deque_try_front(&deque: ptr, &out_value_slot: ptr) -> i32:
+L_ENTRY:
+    ok = call @sa_vec_deque_try_get(&deque, 0, &out_value_slot)
+    !out_value_slot
+    !deque
+    return ok
+
+@export sa_vec_deque_try_back(&deque: ptr, &out_value_slot: ptr) -> i32:
+L_ENTRY:
+    len = load deque+VecDeque_len as u64
+    empty = eq len, 0
+    br empty -> L_TRY_BACK_EMPTY, L_TRY_BACK_READY
+
+L_TRY_BACK_READY:
+    last = sub len, 1
+    ok = call @sa_vec_deque_try_get(&deque, last, &out_value_slot)
+    !last
+    !empty
+    !len
+    !out_value_slot
+    !deque
+    return ok
+
+L_TRY_BACK_EMPTY:
+    store out_value_slot+0, 0 as u64
+    !empty
+    !len
+    !out_value_slot
+    !deque
+    return 0
+
+@export sa_vec_deque_clear(&deque: ptr) -> void:
+L_ENTRY:
+    buf = load deque+VecDeque_buf as ptr
+    cap = load deque+VecDeque_cap as u64
+    EXPAND NUM_U64_CHECKED_MUL clear_bytes_ok, bytes, cap, VecDeque_SLOT_SIZE
+    br clear_bytes_ok -> L_CLEAR_BYTES_OK, L_CLEAR_BYTES_OVERFLOW
+
+L_CLEAR_BYTES_OVERFLOW:
+    panic(1906)
+
+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
+    !clear_bytes_ok
+    store deque+VecDeque_head, 0 as u64
+    store deque+VecDeque_len, 0 as u64
+    !has_buf
+    !buf
+    !cap
+    !deque
+    return
+L_CLEAR_SKIP:
+    !bytes
+    !clear_bytes_ok
+    store deque+VecDeque_head, 0 as u64
+    store deque+VecDeque_len, 0 as u64
+    !has_buf
+    !buf
+    !cap
+    !deque
+    return
+
+@export sa_vec_deque_rotate_left(&deque: ptr, count: u64) -> void:
+L_ENTRY:
+    len = load deque+VecDeque_len as u64
+    short = ule len, 1
+    br short -> L_ROTATE_LEFT_DONE_SHORT, L_ROTATE_LEFT_RUN
+L_ROTATE_LEFT_RUN:
+    shift = urem count, len
+    no_move = eq shift, 0
+    br no_move -> L_ROTATE_LEFT_DONE_RUN, L_ROTATE_LEFT_BODY
+L_ROTATE_LEFT_BODY:
+    head = load deque+VecDeque_head as u64
+    cap = load deque+VecDeque_cap as u64
+    next_sum = add head, shift
+    next_head = urem next_sum, cap
+    store deque+VecDeque_head, next_head as u64
+    !next_sum
+    !next_head
+    !shift
+    !cap
+    !head
+    !no_move
+    !short
+    !len
+    !count
+    !deque
+    return
+L_ROTATE_LEFT_DONE_SHORT:
+    !short
+    !len
+    !count
+    !deque
+    return
+L_ROTATE_LEFT_DONE_RUN:
+    !no_move
+    !shift
+    !short
+    !len
+    !count
+    !deque
+    return
+
+@export sa_vec_deque_rotate_right(&deque: ptr, count: u64) -> void:
+L_ENTRY:
+    len = load deque+VecDeque_len as u64
+    short = ule len, 1
+    br short -> L_ROTATE_RIGHT_DONE_SHORT, L_ROTATE_RIGHT_RUN
+L_ROTATE_RIGHT_RUN:
+    shift = urem count, len
+    back_shift = sub len, shift
+    no_move = eq shift, 0
+    br no_move -> L_ROTATE_RIGHT_DONE_RUN, L_ROTATE_RIGHT_BODY
+L_ROTATE_RIGHT_BODY:
+    head = load deque+VecDeque_head as u64
+    cap = load deque+VecDeque_cap as u64
+    next_sum = add head, back_shift
+    next_head = urem next_sum, cap
+    store deque+VecDeque_head, next_head as u64
+    !next_sum
+    !next_head
+    !back_shift
+    !shift
+    !cap
+    !head
+    !no_move
+    !short
+    !len
+    !count
+    !deque
+    return
+L_ROTATE_RIGHT_DONE_SHORT:
+    !short
+    !len
+    !count
+    !deque
+    return
+L_ROTATE_RIGHT_DONE_RUN:
+    !no_move
+    !back_shift
+    !shift
+    !short
+    !len
+    !count
+    !deque
+    return
+
+@export sa_vec_deque_truncate(&deque: ptr, new_len: u64) -> void:
+L_ENTRY:
+    len = load deque+VecDeque_len as u64
+    should_shrink = ult new_len, len
+    br should_shrink -> L_TRUNCATE_RUN, L_TRUNCATE_DONE
+
+L_TRUNCATE_RUN:
+    store deque+VecDeque_len, new_len as u64
+    !should_shrink
+    !len
+    !new_len
+    !deque
+    return
+
+L_TRUNCATE_DONE:
+    !should_shrink
+    !len
+    !new_len
+    !deque
+    return
+
+// Rust VecDeque::truncate_front: keep only the last `new_len` elements.
+@export sa_vec_deque_truncate_front(&deque: ptr, new_len: u64) -> void:
+L_ENTRY:
+    target_slot = stack_alloc 8
+    pop_slot = stack_alloc 8
+    store target_slot+0, new_len as u64
+    jmp L_TRUNCATE_FRONT_HEAD
+
+L_TRUNCATE_FRONT_HEAD:
+    len = load deque+VecDeque_len as u64
+    target = load target_slot+0 as u64
+    done = ule len, target
+    br done -> L_TRUNCATE_FRONT_DONE, L_TRUNCATE_FRONT_BODY
+
+L_TRUNCATE_FRONT_BODY:
+    pop_ok = call @sa_vec_deque_try_pop_front(&deque, &pop_slot)
+    !pop_ok
+    !done
+    !target
+    !len
+    jmp L_TRUNCATE_FRONT_HEAD
+
+L_TRUNCATE_FRONT_DONE:
+    !done
+    !target
+    !len
+    !new_len
+    !deque
+    return
+
+@export sa_vec_deque_try_split_off(&deque: ptr, index: u64, &out_deque_slot: ptr) -> i32:
+L_ENTRY:
+    len = load deque+VecDeque_len as u64
+    in_bounds = ule index, len
+    br in_bounds -> L_SPLIT_READY, L_SPLIT_MISS
+
+L_SPLIT_READY:
+    tail_len = sub len, index
+    out_deque = call @sa_vec_deque_with_capacity(tail_len)
+    idx_slot = stack_alloc 8
+    store idx_slot+0, 0 as u64
+    jmp L_SPLIT_COPY_HEAD
+
+L_SPLIT_COPY_HEAD:
+    idx = load idx_slot+0 as u64
+    done = eq idx, tail_len
+    br done -> L_SPLIT_STORE, L_SPLIT_COPY_BODY
+
+L_SPLIT_COPY_BODY:
+    src_index = add index, idx
+    value = call @sa_vec_deque_get(&deque, src_index)
+    call @sa_vec_deque_push_back(&out_deque, value)
+    next_idx = add idx, 1
+    store idx_slot+0, next_idx as u64
+    !next_idx
+    !value
+    !src_index
+    !done
+    !idx
+    jmp L_SPLIT_COPY_HEAD
+
+L_SPLIT_STORE:
+    store deque+VecDeque_len, index as u64
+    store out_deque_slot+0, out_deque as ptr
+    !out_deque
+    !done
+    !idx
+    !tail_len
+    !in_bounds
+    !len
+    !index
+    !out_deque_slot
+    !deque
+    return 1
+
+L_SPLIT_MISS:
+    store out_deque_slot+0, 0 as ptr
+    !in_bounds
+    !len
+    !index
+    !out_deque_slot
+    !deque
+    return 0
+
+@export sa_vec_deque_append(&deque: ptr, &other: ptr) -> void:
+L_ENTRY:
+    other_len = load other+VecDeque_len as u64
+    call @sa_vec_deque_reserve(&deque, other_len)
+    value_slot = stack_alloc 8
+    !other_len
+    jmp L_APPEND_LOOP
+
+L_APPEND_LOOP:
+    ok = call @sa_vec_deque_try_pop_front(&other, &value_slot)
+    br ok -> L_APPEND_PUSH, L_APPEND_DONE
+
+L_APPEND_PUSH:
+    value = load value_slot+0 as u64
+    call @sa_vec_deque_push_back(&deque, value)
+    !value
+    !ok
+    jmp L_APPEND_LOOP
+
+L_APPEND_DONE:
+    !ok
+    !other
+    !deque
+    return
+
+[MACRO] VEC_DEQUE_NEW %out_deque
+    %out_deque = call @sa_vec_deque_new()
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_WITH_CAPACITY %out_deque, %capacity
+    %out_deque = call @sa_vec_deque_with_capacity(%capacity)
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_TRY_WITH_CAPACITY %out_ok, %out_deque, %capacity
+    EXPAND VEC_DEQUE_WITH_CAPACITY %out_deque, %capacity
+    %out_ok = ne %out_deque, 0
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_FREE %deque_reg
+    call @sa_vec_deque_free(^%deque_reg)
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_LEN %out_len, %deque_reg
+    %out_len = call @sa_vec_deque_len(&%deque_reg)
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_CAPACITY %out_cap, %deque_reg
+    %out_cap = call @sa_vec_deque_capacity(&%deque_reg)
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_IS_EMPTY %out_flag, %deque_reg
+    %out_flag = call @sa_vec_deque_is_empty(&%deque_reg)
+[END_MACRO]
+[MACRO] VEC_DEQUE_EXTRA_CAPACITY %out_extra, %deque_reg
+    __vec_deque_ec_cap_%out_extra = call @sa_vec_deque_capacity(&%deque_reg)
+    __vec_deque_ec_len_%out_extra = call @sa_vec_deque_len(&%deque_reg)
+    %out_extra = sub __vec_deque_ec_cap_%out_extra, __vec_deque_ec_len_%out_extra
+    !__vec_deque_ec_len_%out_extra
+    !__vec_deque_ec_cap_%out_extra
+[END_MACRO]
+
+
+[MACRO] VEC_DEQUE_GET %out_value, %deque_reg, %index
+    %out_value = call @sa_vec_deque_get(&%deque_reg, %index)
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_TRY_GET %out_ok, %out_value, %deque_reg, %index
+    __vec_deque_get_slot_%out_ok = stack_alloc 8
+    __vec_deque_get_ok_%out_ok = call @sa_vec_deque_try_get(&%deque_reg, %index, &__vec_deque_get_slot_%out_ok)
+    %out_value = load __vec_deque_get_slot_%out_ok+0 as u64
+    %out_ok = __vec_deque_get_ok_%out_ok
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_TRY_GET_U64 %out_ok, %out_value, %deque_reg, %index
+    EXPAND VEC_DEQUE_TRY_GET %out_ok, %out_value, %deque_reg, %index
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_GET_U64 %out_value, %deque_reg, %index
+    EXPAND VEC_DEQUE_GET %out_value, %deque_reg, %index
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_TRY_GET_MUT_PTR %out_ok, %out_ptr, %deque_reg, %index
+    __vec_deque_get_mut_slot_%out_ok = stack_alloc 8
+    __vec_deque_get_mut_ok_%out_ok = call @sa_vec_deque_try_get_mut_ptr(&%deque_reg, %index, &__vec_deque_get_mut_slot_%out_ok)
+    %out_ptr = load __vec_deque_get_mut_slot_%out_ok+0 as ptr
+    %out_ok = __vec_deque_get_mut_ok_%out_ok
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_GET_MUT_PTR %out_ok, %out_ptr, %deque_reg, %index
+    EXPAND VEC_DEQUE_TRY_GET_MUT_PTR %out_ok, %out_ptr, %deque_reg, %index
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_GET_MUT %out_ok, %out_ptr, %deque_reg, %index
+    EXPAND VEC_DEQUE_TRY_GET_MUT_PTR %out_ok, %out_ptr, %deque_reg, %index
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_SET %out_ok, %deque_reg, %index, %value
+    %out_ok = call @sa_vec_deque_set(&%deque_reg, %index, %value)
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_CONTAINS %out_bool, %deque_reg, %needle
+    EXPAND VEC_DEQUE_CONTAINS_U64 %out_bool, %deque_reg, %needle
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_CONTAINS_U64 %out_bool, %deque_reg, %needle
+    %out_bool = call @sa_vec_deque_contains(&%deque_reg, %needle)
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_SWAP %out_ok, %deque_reg, %left, %right
+    %out_ok = call @sa_vec_deque_swap(&%deque_reg, %left, %right)
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_PUSH_BACK %deque_reg, %value
+    call @sa_vec_deque_push_back(&%deque_reg, %value)
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_PUSH_BACK_MUT_PTR %out_ptr, %deque_reg, %value
+    __vec_deque_push_back_mut_len_%out_ptr = call @sa_vec_deque_len(&%deque_reg)
+    call @sa_vec_deque_push_back(&%deque_reg, %value)
+    __vec_deque_push_back_mut_slot_%out_ptr = stack_alloc 8
+    __vec_deque_push_back_mut_ok_%out_ptr = call @sa_vec_deque_try_get_mut_ptr(&%deque_reg, __vec_deque_push_back_mut_len_%out_ptr, &__vec_deque_push_back_mut_slot_%out_ptr)
+    %out_ptr = load __vec_deque_push_back_mut_slot_%out_ptr+0 as ptr
+    !__vec_deque_push_back_mut_ok_%out_ptr
+    !__vec_deque_push_back_mut_len_%out_ptr
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_PUSH_BACK_MUT %out_ptr, %deque_reg, %value
+    EXPAND VEC_DEQUE_PUSH_BACK_MUT_PTR %out_ptr, %deque_reg, %value
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_PUSH_FRONT %deque_reg, %value
+    call @sa_vec_deque_push_front(&%deque_reg, %value)
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_PUSH_FRONT_MUT_PTR %out_ptr, %deque_reg, %value
+    call @sa_vec_deque_push_front(&%deque_reg, %value)
+    __vec_deque_push_front_mut_slot_%out_ptr = stack_alloc 8
+    __vec_deque_push_front_mut_ok_%out_ptr = call @sa_vec_deque_try_front_mut_ptr(&%deque_reg, &__vec_deque_push_front_mut_slot_%out_ptr)
+    %out_ptr = load __vec_deque_push_front_mut_slot_%out_ptr+0 as ptr
+    !__vec_deque_push_front_mut_ok_%out_ptr
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_PUSH_FRONT_MUT %out_ptr, %deque_reg, %value
+    EXPAND VEC_DEQUE_PUSH_FRONT_MUT_PTR %out_ptr, %deque_reg, %value
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_TRY_POP_FRONT %out_ok, %out_value, %deque_reg
+    __vec_deque_value_slot_%out_ok = stack_alloc 8
+    __vec_deque_ok_%out_ok = call @sa_vec_deque_try_pop_front(&%deque_reg, &__vec_deque_value_slot_%out_ok)
+    %out_value = load __vec_deque_value_slot_%out_ok+0 as u64
+    %out_ok = __vec_deque_ok_%out_ok
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_TRY_POP_BACK %out_ok, %out_value, %deque_reg
+    __vec_deque_value_slot_%out_ok = stack_alloc 8
+    __vec_deque_ok_%out_ok = call @sa_vec_deque_try_pop_back(&%deque_reg, &__vec_deque_value_slot_%out_ok)
+    %out_value = load __vec_deque_value_slot_%out_ok+0 as u64
+    %out_ok = __vec_deque_ok_%out_ok
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_TRY_POP_FRONT_IF_U64 %out_ok, %out_value, %deque_reg, %pred_fn
+    __vec_deque_pop_front_if_pop_slot_%out_ok = stack_alloc 8
+    __vec_deque_pop_front_if_ok_slot_%out_ok = stack_alloc 8
+    store __vec_deque_pop_front_if_pop_slot_%out_ok+0, 0 as u64
+    store __vec_deque_pop_front_if_ok_slot_%out_ok+0, 0 as u64
+    EXPAND VEC_DEQUE_TRY_FRONT __vec_deque_pop_front_if_has_%out_ok, __vec_deque_pop_front_if_value_%out_ok, %deque_reg
+    br __vec_deque_pop_front_if_has_%out_ok -> L_VEC_DEQUE_POP_FRONT_IF_CHECK_%out_ok, L_VEC_DEQUE_POP_FRONT_IF_EMPTY_%out_ok
+
+L_VEC_DEQUE_POP_FRONT_IF_CHECK_%out_ok:
+    __vec_deque_pop_front_if_pred_%out_ok = call %pred_fn(__vec_deque_pop_front_if_value_%out_ok)
+    __vec_deque_pop_front_if_take_%out_ok = ne __vec_deque_pop_front_if_pred_%out_ok, 0
+    br __vec_deque_pop_front_if_take_%out_ok -> L_VEC_DEQUE_POP_FRONT_IF_TAKE_%out_ok, L_VEC_DEQUE_POP_FRONT_IF_KEEP_%out_ok
+
+L_VEC_DEQUE_POP_FRONT_IF_TAKE_%out_ok:
+    __vec_deque_pop_front_if_pop_ok_%out_ok = call @sa_vec_deque_try_pop_front(&%deque_reg, &__vec_deque_pop_front_if_pop_slot_%out_ok)
+    store __vec_deque_pop_front_if_ok_slot_%out_ok+0, __vec_deque_pop_front_if_pop_ok_%out_ok as u64
+    !__vec_deque_pop_front_if_pop_ok_%out_ok
+    !__vec_deque_pop_front_if_take_%out_ok
+    !__vec_deque_pop_front_if_pred_%out_ok
+    !__vec_deque_pop_front_if_value_%out_ok
+    !__vec_deque_pop_front_if_has_%out_ok
+    jmp L_VEC_DEQUE_POP_FRONT_IF_END_%out_ok
+
+L_VEC_DEQUE_POP_FRONT_IF_KEEP_%out_ok:
+    store __vec_deque_pop_front_if_ok_slot_%out_ok+0, 0 as u64
+    store __vec_deque_pop_front_if_pop_slot_%out_ok+0, 0 as u64
+    !__vec_deque_pop_front_if_take_%out_ok
+    !__vec_deque_pop_front_if_pred_%out_ok
+    !__vec_deque_pop_front_if_value_%out_ok
+    !__vec_deque_pop_front_if_has_%out_ok
+    jmp L_VEC_DEQUE_POP_FRONT_IF_END_%out_ok
+
+L_VEC_DEQUE_POP_FRONT_IF_EMPTY_%out_ok:
+    store __vec_deque_pop_front_if_ok_slot_%out_ok+0, 0 as u64
+    store __vec_deque_pop_front_if_pop_slot_%out_ok+0, 0 as u64
+    !__vec_deque_pop_front_if_value_%out_ok
+    !__vec_deque_pop_front_if_has_%out_ok
+
+L_VEC_DEQUE_POP_FRONT_IF_END_%out_ok:
+    %out_value = load __vec_deque_pop_front_if_pop_slot_%out_ok+0 as u64
+    %out_ok = load __vec_deque_pop_front_if_ok_slot_%out_ok+0 as u64
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_TRY_POP_FRONT_IF_U64.
+[MACRO] VEC_DEQUE_TRY_POP_FRONT_IF %out_ok, %out_value, %deque_reg, %pred_fn
+    EXPAND VEC_DEQUE_TRY_POP_FRONT_IF_U64 %out_ok, %out_value, %deque_reg, %pred_fn
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_POP_FRONT_IF_U64 %out_ok, %out_value, %deque_reg, %pred_fn
+    EXPAND VEC_DEQUE_TRY_POP_FRONT_IF_U64 %out_ok, %out_value, %deque_reg, %pred_fn
+[END_MACRO]
+
+// Rust method-name alias: VecDeque::pop_front_if.
+[MACRO] VEC_DEQUE_POP_FRONT_IF %out_ok, %out_value, %deque_reg, %pred_fn
+    EXPAND VEC_DEQUE_TRY_POP_FRONT_IF_U64 %out_ok, %out_value, %deque_reg, %pred_fn
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_TRY_POP_BACK_IF_U64 %out_ok, %out_value, %deque_reg, %pred_fn
+    __vec_deque_pop_back_if_pop_slot_%out_ok = stack_alloc 8
+    __vec_deque_pop_back_if_ok_slot_%out_ok = stack_alloc 8
+    store __vec_deque_pop_back_if_pop_slot_%out_ok+0, 0 as u64
+    store __vec_deque_pop_back_if_ok_slot_%out_ok+0, 0 as u64
+    EXPAND VEC_DEQUE_TRY_BACK __vec_deque_pop_back_if_has_%out_ok, __vec_deque_pop_back_if_value_%out_ok, %deque_reg
+    br __vec_deque_pop_back_if_has_%out_ok -> L_VEC_DEQUE_POP_BACK_IF_CHECK_%out_ok, L_VEC_DEQUE_POP_BACK_IF_EMPTY_%out_ok
+
+L_VEC_DEQUE_POP_BACK_IF_CHECK_%out_ok:
+    __vec_deque_pop_back_if_pred_%out_ok = call %pred_fn(__vec_deque_pop_back_if_value_%out_ok)
+    __vec_deque_pop_back_if_take_%out_ok = ne __vec_deque_pop_back_if_pred_%out_ok, 0
+    br __vec_deque_pop_back_if_take_%out_ok -> L_VEC_DEQUE_POP_BACK_IF_TAKE_%out_ok, L_VEC_DEQUE_POP_BACK_IF_KEEP_%out_ok
+
+L_VEC_DEQUE_POP_BACK_IF_TAKE_%out_ok:
+    __vec_deque_pop_back_if_pop_ok_%out_ok = call @sa_vec_deque_try_pop_back(&%deque_reg, &__vec_deque_pop_back_if_pop_slot_%out_ok)
+    store __vec_deque_pop_back_if_ok_slot_%out_ok+0, __vec_deque_pop_back_if_pop_ok_%out_ok as u64
+    !__vec_deque_pop_back_if_pop_ok_%out_ok
+    !__vec_deque_pop_back_if_take_%out_ok
+    !__vec_deque_pop_back_if_pred_%out_ok
+    !__vec_deque_pop_back_if_value_%out_ok
+    !__vec_deque_pop_back_if_has_%out_ok
+    jmp L_VEC_DEQUE_POP_BACK_IF_END_%out_ok
+
+L_VEC_DEQUE_POP_BACK_IF_KEEP_%out_ok:
+    store __vec_deque_pop_back_if_ok_slot_%out_ok+0, 0 as u64
+    store __vec_deque_pop_back_if_pop_slot_%out_ok+0, 0 as u64
+    !__vec_deque_pop_back_if_take_%out_ok
+    !__vec_deque_pop_back_if_pred_%out_ok
+    !__vec_deque_pop_back_if_value_%out_ok
+    !__vec_deque_pop_back_if_has_%out_ok
+    jmp L_VEC_DEQUE_POP_BACK_IF_END_%out_ok
+
+L_VEC_DEQUE_POP_BACK_IF_EMPTY_%out_ok:
+    store __vec_deque_pop_back_if_ok_slot_%out_ok+0, 0 as u64
+    store __vec_deque_pop_back_if_pop_slot_%out_ok+0, 0 as u64
+    !__vec_deque_pop_back_if_value_%out_ok
+    !__vec_deque_pop_back_if_has_%out_ok
+
+L_VEC_DEQUE_POP_BACK_IF_END_%out_ok:
+    %out_value = load __vec_deque_pop_back_if_pop_slot_%out_ok+0 as u64
+    %out_ok = load __vec_deque_pop_back_if_ok_slot_%out_ok+0 as u64
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_TRY_POP_BACK_IF_U64.
+[MACRO] VEC_DEQUE_TRY_POP_BACK_IF %out_ok, %out_value, %deque_reg, %pred_fn
+    EXPAND VEC_DEQUE_TRY_POP_BACK_IF_U64 %out_ok, %out_value, %deque_reg, %pred_fn
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_POP_BACK_IF_U64 %out_ok, %out_value, %deque_reg, %pred_fn
+    EXPAND VEC_DEQUE_TRY_POP_BACK_IF_U64 %out_ok, %out_value, %deque_reg, %pred_fn
+[END_MACRO]
+
+// Rust method-name alias: VecDeque::pop_back_if.
+[MACRO] VEC_DEQUE_POP_BACK_IF %out_ok, %out_value, %deque_reg, %pred_fn
+    EXPAND VEC_DEQUE_TRY_POP_BACK_IF_U64 %out_ok, %out_value, %deque_reg, %pred_fn
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_ROTATE_LEFT %deque_reg, %count
+    call @sa_vec_deque_rotate_left(&%deque_reg, %count)
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_ROTATE_RIGHT %deque_reg, %count
+    call @sa_vec_deque_rotate_right(&%deque_reg, %count)
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_FRONT %out_value, %deque_reg
+    %out_value = call @sa_vec_deque_front(&%deque_reg)
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_TRY_FRONT %out_ok, %out_value, %deque_reg
+    __vec_deque_front_slot_%out_ok = stack_alloc 8
+    __vec_deque_front_ok_%out_ok = call @sa_vec_deque_try_front(&%deque_reg, &__vec_deque_front_slot_%out_ok)
+    %out_value = load __vec_deque_front_slot_%out_ok+0 as u64
+    %out_ok = __vec_deque_front_ok_%out_ok
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_BACK %out_value, %deque_reg
+    %out_value = call @sa_vec_deque_back(&%deque_reg)
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_TRY_BACK %out_ok, %out_value, %deque_reg
+    __vec_deque_back_slot_%out_ok = stack_alloc 8
+    __vec_deque_back_ok_%out_ok = call @sa_vec_deque_try_back(&%deque_reg, &__vec_deque_back_slot_%out_ok)
+    %out_value = load __vec_deque_back_slot_%out_ok+0 as u64
+    %out_ok = __vec_deque_back_ok_%out_ok
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_FRONT_U64 %out_value, %deque_reg
+    EXPAND VEC_DEQUE_FRONT %out_value, %deque_reg
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_TRY_FRONT_U64 %out_ok, %out_value, %deque_reg
+    EXPAND VEC_DEQUE_TRY_FRONT %out_ok, %out_value, %deque_reg
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_BACK_U64 %out_value, %deque_reg
+    EXPAND VEC_DEQUE_BACK %out_value, %deque_reg
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_TRY_BACK_U64 %out_ok, %out_value, %deque_reg
+    EXPAND VEC_DEQUE_TRY_BACK %out_ok, %out_value, %deque_reg
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_CLEAR %deque_reg
+    call @sa_vec_deque_clear(&%deque_reg)
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_DRAIN_U64 %out_vec, %deque_reg
+    __vec_deque_drain_len_%out_vec = load %deque_reg+VecDeque_len as u64
+    EXPAND VEC_WITH_CAPACITY_U64 %out_vec, __vec_deque_drain_len_%out_vec
+    __vec_deque_drain_idx_slot_%out_vec = stack_alloc 8
+    store __vec_deque_drain_idx_slot_%out_vec+0, 0 as u64
+    jmp L_VEC_DEQUE_DRAIN_HEAD_%out_vec
+
+L_VEC_DEQUE_DRAIN_HEAD_%out_vec:
+    __vec_deque_drain_idx_%out_vec = load __vec_deque_drain_idx_slot_%out_vec+0 as u64
+    __vec_deque_drain_done_%out_vec = eq __vec_deque_drain_idx_%out_vec, __vec_deque_drain_len_%out_vec
+    br __vec_deque_drain_done_%out_vec -> L_VEC_DEQUE_DRAIN_DONE_%out_vec, L_VEC_DEQUE_DRAIN_BODY_%out_vec
+
+L_VEC_DEQUE_DRAIN_BODY_%out_vec:
+    __vec_deque_drain_value_%out_vec = call @sa_vec_deque_get(&%deque_reg, __vec_deque_drain_idx_%out_vec)
+    EXPAND VEC_PUSH_U64 %out_vec, __vec_deque_drain_value_%out_vec
+    __vec_deque_drain_next_%out_vec = add __vec_deque_drain_idx_%out_vec, 1
+    store __vec_deque_drain_idx_slot_%out_vec+0, __vec_deque_drain_next_%out_vec as u64
+    !__vec_deque_drain_next_%out_vec
+    !__vec_deque_drain_value_%out_vec
+    !__vec_deque_drain_done_%out_vec
+    !__vec_deque_drain_idx_%out_vec
+    jmp L_VEC_DEQUE_DRAIN_HEAD_%out_vec
+
+L_VEC_DEQUE_DRAIN_DONE_%out_vec:
+    call @sa_vec_deque_clear(&%deque_reg)
+    !__vec_deque_drain_done_%out_vec
+    !__vec_deque_drain_idx_%out_vec
+    !__vec_deque_drain_len_%out_vec
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_DRAIN_U64.
+[MACRO] VEC_DEQUE_DRAIN %out_vec, %deque_reg
+    EXPAND VEC_DEQUE_DRAIN_U64 %out_vec, %deque_reg
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_TRY_DRAIN_RANGE_U64 %out_ok, %out_vec, %deque_reg, %start, %length
+    EXPAND VEC_DEQUE_MAKE_CONTIGUOUS __vec_deque_drain_range_slice_%out_ok, %deque_reg
+    EXPAND VEC_FROM_SLICE_U64 __vec_deque_drain_range_vec_%out_ok, __vec_deque_drain_range_slice_%out_ok
+    EXPAND VEC_DRAIN_U64 %out_ok, %out_vec, __vec_deque_drain_range_vec_%out_ok, %start, %length
+    __vec_deque_drain_range_hit_%out_ok = ne %out_ok, 0
+    br __vec_deque_drain_range_hit_%out_ok -> L_VEC_DEQUE_DRAIN_RANGE_REBUILD_%out_ok, L_VEC_DEQUE_DRAIN_RANGE_MISS_%out_ok
+
+L_VEC_DEQUE_DRAIN_RANGE_REBUILD_%out_ok:
+    EXPAND VEC_DEQUE_CLEAR %deque_reg
+    EXPAND VEC_LEN __vec_deque_drain_range_new_len_%out_ok, __vec_deque_drain_range_vec_%out_ok
+    __vec_deque_drain_range_idx_slot_%out_ok = stack_alloc 8
+    store __vec_deque_drain_range_idx_slot_%out_ok+0, 0 as u64
+    jmp L_VEC_DEQUE_DRAIN_RANGE_COPY_HEAD_%out_ok
+
+L_VEC_DEQUE_DRAIN_RANGE_COPY_HEAD_%out_ok:
+    __vec_deque_drain_range_idx_%out_ok = load __vec_deque_drain_range_idx_slot_%out_ok+0 as u64
+    __vec_deque_drain_range_copy_done_%out_ok = eq __vec_deque_drain_range_idx_%out_ok, __vec_deque_drain_range_new_len_%out_ok
+    br __vec_deque_drain_range_copy_done_%out_ok -> L_VEC_DEQUE_DRAIN_RANGE_COPY_END_%out_ok, L_VEC_DEQUE_DRAIN_RANGE_COPY_BODY_%out_ok
+
+L_VEC_DEQUE_DRAIN_RANGE_COPY_BODY_%out_ok:
+    EXPAND VEC_GET_U64 __vec_deque_drain_range_value_%out_ok, __vec_deque_drain_range_vec_%out_ok, __vec_deque_drain_range_idx_%out_ok
+    EXPAND VEC_DEQUE_PUSH_BACK %deque_reg, __vec_deque_drain_range_value_%out_ok
+    __vec_deque_drain_range_next_%out_ok = add __vec_deque_drain_range_idx_%out_ok, 1
+    store __vec_deque_drain_range_idx_slot_%out_ok+0, __vec_deque_drain_range_next_%out_ok as u64
+    !__vec_deque_drain_range_next_%out_ok
+    !__vec_deque_drain_range_value_%out_ok
+    !__vec_deque_drain_range_copy_done_%out_ok
+    !__vec_deque_drain_range_idx_%out_ok
+    jmp L_VEC_DEQUE_DRAIN_RANGE_COPY_HEAD_%out_ok
+
+L_VEC_DEQUE_DRAIN_RANGE_COPY_END_%out_ok:
+    !__vec_deque_drain_range_copy_done_%out_ok
+    !__vec_deque_drain_range_idx_%out_ok
+    !__vec_deque_drain_range_new_len_%out_ok
+    !__vec_deque_drain_range_hit_%out_ok
+    jmp L_VEC_DEQUE_DRAIN_RANGE_DONE_%out_ok
+
+L_VEC_DEQUE_DRAIN_RANGE_MISS_%out_ok:
+    !__vec_deque_drain_range_hit_%out_ok
+    jmp L_VEC_DEQUE_DRAIN_RANGE_DONE_%out_ok
+
+L_VEC_DEQUE_DRAIN_RANGE_DONE_%out_ok:
+    EXPAND VEC_FREE __vec_deque_drain_range_vec_%out_ok
+    !__vec_deque_drain_range_slice_%out_ok
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_TRY_DRAIN_RANGE_U64.
+[MACRO] VEC_DEQUE_TRY_DRAIN_RANGE %out_ok, %out_vec, %deque_reg, %start, %length
+    EXPAND VEC_DEQUE_TRY_DRAIN_RANGE_U64 %out_ok, %out_vec, %deque_reg, %start, %length
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_DRAIN_RANGE_U64 %out_ok, %out_vec, %deque_reg, %start, %length
+    EXPAND VEC_DEQUE_TRY_DRAIN_RANGE_U64 %out_ok, %out_vec, %deque_reg, %start, %length
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_DRAIN_RANGE_U64.
+[MACRO] VEC_DEQUE_DRAIN_RANGE %out_ok, %out_vec, %deque_reg, %start, %length
+    EXPAND VEC_DEQUE_DRAIN_RANGE_U64 %out_ok, %out_vec, %deque_reg, %start, %length
+[END_MACRO]
+
+// Concrete iterator facades use an explicit front-to-back backing Vec. The
+// borrowed form snapshots values; the consuming form drains the deque.
+[MACRO] VEC_DEQUE_ITER_U64 %out_iter, %out_vec, %deque_reg
+    __vec_deque_iter_len_%out_iter = load %deque_reg+VecDeque_len as u64
+    EXPAND VEC_WITH_CAPACITY_U64 %out_vec, __vec_deque_iter_len_%out_iter
+    __vec_deque_iter_idx_slot_%out_iter = stack_alloc 8
+    store __vec_deque_iter_idx_slot_%out_iter+0, 0 as u64
+    jmp L_VEC_DEQUE_ITER_HEAD_%out_iter
+L_VEC_DEQUE_ITER_HEAD_%out_iter:
+    __vec_deque_iter_idx_%out_iter = load __vec_deque_iter_idx_slot_%out_iter+0 as u64
+    __vec_deque_iter_done_%out_iter = eq __vec_deque_iter_idx_%out_iter, __vec_deque_iter_len_%out_iter
+    br __vec_deque_iter_done_%out_iter -> L_VEC_DEQUE_ITER_BUILD_%out_iter, L_VEC_DEQUE_ITER_BODY_%out_iter
+L_VEC_DEQUE_ITER_BODY_%out_iter:
+    __vec_deque_iter_value_%out_iter = call @sa_vec_deque_get(&%deque_reg, __vec_deque_iter_idx_%out_iter)
+    EXPAND VEC_PUSH_U64 %out_vec, __vec_deque_iter_value_%out_iter
+    __vec_deque_iter_next_%out_iter = add __vec_deque_iter_idx_%out_iter, 1
+    store __vec_deque_iter_idx_slot_%out_iter+0, __vec_deque_iter_next_%out_iter as u64
+    !__vec_deque_iter_next_%out_iter
+    !__vec_deque_iter_value_%out_iter
+    !__vec_deque_iter_done_%out_iter
+    !__vec_deque_iter_idx_%out_iter
+    jmp L_VEC_DEQUE_ITER_HEAD_%out_iter
+L_VEC_DEQUE_ITER_BUILD_%out_iter:
+    EXPAND VEC_AS_SLICE __vec_deque_iter_slice_%out_iter, %out_vec
+    EXPAND ITER_FROM_SLICE %out_iter, __vec_deque_iter_slice_%out_iter
+    !__vec_deque_iter_slice_%out_iter
+    !__vec_deque_iter_done_%out_iter
+    !__vec_deque_iter_idx_%out_iter
+    !__vec_deque_iter_len_%out_iter
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_ITER_U64.
+[MACRO] VEC_DEQUE_ITER %out_iter, %out_vec, %deque_reg
+    EXPAND VEC_DEQUE_ITER_U64 %out_iter, %out_vec, %deque_reg
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_ITER_MUT_U64 %out_iter, %out_slice, %deque_reg
+    EXPAND VEC_DEQUE_MAKE_CONTIGUOUS %out_slice, %deque_reg
+    EXPAND ITER_FROM_SLICE %out_iter, %out_slice
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_ITER_MUT_U64.
+[MACRO] VEC_DEQUE_ITER_MUT %out_iter, %out_slice, %deque_reg
+    EXPAND VEC_DEQUE_ITER_MUT_U64 %out_iter, %out_slice, %deque_reg
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_REF_INTO_ITER_U64 %out_iter, %out_vec, %deque_reg
+    EXPAND VEC_DEQUE_ITER_U64 %out_iter, %out_vec, %deque_reg
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_REF_INTO_ITER_U64.
+[MACRO] VEC_DEQUE_REF_INTO_ITER %out_iter, %out_vec, %deque_reg
+    EXPAND VEC_DEQUE_REF_INTO_ITER_U64 %out_iter, %out_vec, %deque_reg
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_MUT_REF_INTO_ITER_U64 %out_iter, %out_slice, %deque_reg
+    EXPAND VEC_DEQUE_ITER_MUT_U64 %out_iter, %out_slice, %deque_reg
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_MUT_REF_INTO_ITER_U64.
+[MACRO] VEC_DEQUE_MUT_REF_INTO_ITER %out_iter, %out_slice, %deque_reg
+    EXPAND VEC_DEQUE_MUT_REF_INTO_ITER_U64 %out_iter, %out_slice, %deque_reg
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INTO_ITER_U64 %out_iter, %out_vec, %deque_reg
+    EXPAND VEC_DEQUE_DRAIN_U64 %out_vec, %deque_reg
+    EXPAND VEC_AS_SLICE __vec_deque_into_iter_slice_%out_iter, %out_vec
+    EXPAND ITER_FROM_SLICE %out_iter, __vec_deque_into_iter_slice_%out_iter
+    !__vec_deque_into_iter_slice_%out_iter
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_INTO_ITER_U64.
+[MACRO] VEC_DEQUE_INTO_ITER %out_iter, %out_vec, %deque_reg
+    EXPAND VEC_DEQUE_INTO_ITER_U64 %out_iter, %out_vec, %deque_reg
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_ITER_DEFAULT_U64 %out_iter
+    __vec_deque_iter_default_slice_%out_iter = stack_alloc Slice_SIZE
+    EXPAND SLICE_NEW __vec_deque_iter_default_slice_%out_iter, 0, 0
+    EXPAND ITER_FROM_SLICE %out_iter, __vec_deque_iter_default_slice_%out_iter
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_ITER_DEFAULT_U64.
+[MACRO] VEC_DEQUE_ITER_DEFAULT %out_iter
+    EXPAND VEC_DEQUE_ITER_DEFAULT_U64 %out_iter
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_ITER_AS_REF_SLICE_U64 %out_slice, %iter_reg
+    EXPAND ITER_AS_SLICE_U64 %out_slice, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_ITER_AS_REF_SLICE_U64.
+[MACRO] VEC_DEQUE_ITER_AS_REF_SLICE %out_slice, %iter_reg
+    EXPAND VEC_DEQUE_ITER_AS_REF_SLICE_U64 %out_slice, %iter_reg
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_ITER_MUT_AS_REF_SLICE_U64 %out_slice, %iter_reg
+    EXPAND ITER_AS_SLICE_U64 %out_slice, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_ITER_MUT_AS_REF_SLICE_U64.
+[MACRO] VEC_DEQUE_ITER_MUT_AS_REF_SLICE %out_slice, %iter_reg
+    EXPAND VEC_DEQUE_ITER_MUT_AS_REF_SLICE_U64 %out_slice, %iter_reg
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_ITER_MUT_AS_MUT_SLICE_U64 %out_slice, %iter_reg
+    EXPAND ITER_AS_SLICE_U64 %out_slice, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_ITER_MUT_AS_MUT_SLICE_U64.
+[MACRO] VEC_DEQUE_ITER_MUT_AS_MUT_SLICE %out_slice, %iter_reg
+    EXPAND VEC_DEQUE_ITER_MUT_AS_MUT_SLICE_U64 %out_slice, %iter_reg
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_ITER_CLONE_U64 %out_iter, %iter_reg
+    EXPAND ITER_CLONE %out_iter, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_ITER_CLONE_U64.
+[MACRO] VEC_DEQUE_ITER_CLONE %out_iter, %iter_reg
+    EXPAND VEC_DEQUE_ITER_CLONE_U64 %out_iter, %iter_reg
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_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 VEC_DEQUE_INTO_ITER_DEFAULT_U64.
+[MACRO] VEC_DEQUE_INTO_ITER_DEFAULT %out_iter, %out_vec
+    EXPAND VEC_DEQUE_INTO_ITER_DEFAULT_U64 %out_iter, %out_vec
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INTO_ITER_AS_SLICE_U64 %out_slice, %iter_reg
+    EXPAND ITER_AS_SLICE_U64 %out_slice, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_INTO_ITER_AS_SLICE_U64.
+[MACRO] VEC_DEQUE_INTO_ITER_AS_SLICE %out_slice, %iter_reg
+    EXPAND VEC_DEQUE_INTO_ITER_AS_SLICE_U64 %out_slice, %iter_reg
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INTO_ITER_AS_MUT_SLICE_U64 %out_slice, %iter_reg
+    EXPAND ITER_AS_SLICE_U64 %out_slice, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_INTO_ITER_AS_MUT_SLICE_U64.
+[MACRO] VEC_DEQUE_INTO_ITER_AS_MUT_SLICE %out_slice, %iter_reg
+    EXPAND VEC_DEQUE_INTO_ITER_AS_MUT_SLICE_U64 %out_slice, %iter_reg
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INTO_ITER_AS_REF_SLICE_U64 %out_slice, %iter_reg
+    EXPAND VEC_DEQUE_INTO_ITER_AS_SLICE_U64 %out_slice, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_INTO_ITER_AS_REF_SLICE_U64.
+[MACRO] VEC_DEQUE_INTO_ITER_AS_REF_SLICE %out_slice, %iter_reg
+    EXPAND VEC_DEQUE_INTO_ITER_AS_REF_SLICE_U64 %out_slice, %iter_reg
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_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 VEC_DEQUE_INTO_ITER_CLONE_U64.
+[MACRO] VEC_DEQUE_INTO_ITER_CLONE %out_iter, %out_vec, %iter_reg
+    EXPAND VEC_DEQUE_INTO_ITER_CLONE_U64 %out_iter, %out_vec, %iter_reg
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_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 VEC_DEQUE_ITER_NEXT_U64.
+[MACRO] VEC_DEQUE_ITER_NEXT %out_has, %out_value, %iter_reg
+    EXPAND VEC_DEQUE_ITER_NEXT_U64 %out_has, %out_value, %iter_reg
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_ITER_MUT_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 VEC_DEQUE_ITER_MUT_NEXT_U64.
+[MACRO] VEC_DEQUE_ITER_MUT_NEXT %out_has, %out_value, %iter_reg
+    EXPAND VEC_DEQUE_ITER_MUT_NEXT_U64 %out_has, %out_value, %iter_reg
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_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 VEC_DEQUE_ITER_NEXT_BACK_U64.
+[MACRO] VEC_DEQUE_ITER_NEXT_BACK %out_has, %out_value, %iter_reg
+    EXPAND VEC_DEQUE_ITER_NEXT_BACK_U64 %out_has, %out_value, %iter_reg
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_ITER_MUT_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 VEC_DEQUE_ITER_MUT_NEXT_BACK_U64.
+[MACRO] VEC_DEQUE_ITER_MUT_NEXT_BACK %out_has, %out_value, %iter_reg
+    EXPAND VEC_DEQUE_ITER_MUT_NEXT_BACK_U64 %out_has, %out_value, %iter_reg
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_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 VEC_DEQUE_ITER_NTH_U64.
+[MACRO] VEC_DEQUE_ITER_NTH %out_has, %out_value, %iter_reg, %nth
+    EXPAND VEC_DEQUE_ITER_NTH_U64 %out_has, %out_value, %iter_reg, %nth
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_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 VEC_DEQUE_ITER_NTH_BACK_U64.
+[MACRO] VEC_DEQUE_ITER_NTH_BACK %out_has, %out_value, %iter_reg, %nth
+    EXPAND VEC_DEQUE_ITER_NTH_BACK_U64 %out_has, %out_value, %iter_reg, %nth
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_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 VEC_DEQUE_ITER_TRY_NEXT_CHUNK_U64.
+[MACRO] VEC_DEQUE_ITER_TRY_NEXT_CHUNK %out_ok, %out_filled, %iter_reg, %dst_ptr, %count
+    EXPAND VEC_DEQUE_ITER_TRY_NEXT_CHUNK_U64 %out_ok, %out_filled, %iter_reg, %dst_ptr, %count
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_ITER_ADVANCE_BY %out_ok, %out_remaining, %iter_reg, %count
+    EXPAND ITER_ADVANCE_BY %out_ok, %out_remaining, %iter_reg, %count
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_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] VEC_DEQUE_ITER_COUNT_U64 %out_count, %iter_reg
+    EXPAND ITER_COUNT %out_count, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_ITER_COUNT_U64.
+[MACRO] VEC_DEQUE_ITER_COUNT %out_count, %iter_reg
+    EXPAND VEC_DEQUE_ITER_COUNT_U64 %out_count, %iter_reg
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_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 VEC_DEQUE_ITER_LAST_U64.
+[MACRO] VEC_DEQUE_ITER_LAST %out_has, %out_value, %iter_reg
+    EXPAND VEC_DEQUE_ITER_LAST_U64 %out_has, %out_value, %iter_reg
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_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 VEC_DEQUE_ITER_FIND_U64.
+[MACRO] VEC_DEQUE_ITER_FIND %out_has, %out_value, %iter_reg, %pred_fn
+    EXPAND VEC_DEQUE_ITER_FIND_U64 %out_has, %out_value, %iter_reg, %pred_fn
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_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 VEC_DEQUE_ITER_TRY_FIND_U64.
+[MACRO] VEC_DEQUE_ITER_TRY_FIND %out_ok, %out_has, %out_value, %iter_reg, %pred_fn
+    EXPAND VEC_DEQUE_ITER_TRY_FIND_U64 %out_ok, %out_has, %out_value, %iter_reg, %pred_fn
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_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 VEC_DEQUE_ITER_FIND_MAP_U64.
+[MACRO] VEC_DEQUE_ITER_FIND_MAP %out_has, %out_value, %iter_reg, %map_fn
+    EXPAND VEC_DEQUE_ITER_FIND_MAP_U64 %out_has, %out_value, %iter_reg, %map_fn
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_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 VEC_DEQUE_ITER_POSITION_U64.
+[MACRO] VEC_DEQUE_ITER_POSITION %out_has, %out_index, %iter_reg, %pred_fn
+    EXPAND VEC_DEQUE_ITER_POSITION_U64 %out_has, %out_index, %iter_reg, %pred_fn
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_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 VEC_DEQUE_ITER_RPOSITION_U64.
+[MACRO] VEC_DEQUE_ITER_RPOSITION %out_has, %out_index, %iter_reg, %pred_fn
+    EXPAND VEC_DEQUE_ITER_RPOSITION_U64 %out_has, %out_index, %iter_reg, %pred_fn
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_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 VEC_DEQUE_ITER_RFIND_U64.
+[MACRO] VEC_DEQUE_ITER_RFIND %out_has, %out_value, %iter_reg, %pred_fn
+    EXPAND VEC_DEQUE_ITER_RFIND_U64 %out_has, %out_value, %iter_reg, %pred_fn
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_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 VEC_DEQUE_ITER_ANY_U64.
+[MACRO] VEC_DEQUE_ITER_ANY %out_bool, %iter_reg, %pred_fn
+    EXPAND VEC_DEQUE_ITER_ANY_U64 %out_bool, %iter_reg, %pred_fn
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_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 VEC_DEQUE_ITER_ALL_U64.
+[MACRO] VEC_DEQUE_ITER_ALL %out_bool, %iter_reg, %pred_fn
+    EXPAND VEC_DEQUE_ITER_ALL_U64 %out_bool, %iter_reg, %pred_fn
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_ITER_FOR_EACH_U64 %iter_reg, %each_fn
+    EXPAND ITER_FOR_EACH_U64 %iter_reg, %each_fn
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_ITER_FOR_EACH_U64.
+[MACRO] VEC_DEQUE_ITER_FOR_EACH %iter_reg, %each_fn
+    EXPAND VEC_DEQUE_ITER_FOR_EACH_U64 %iter_reg, %each_fn
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_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 VEC_DEQUE_ITER_TRY_FOR_EACH_U64.
+[MACRO] VEC_DEQUE_ITER_TRY_FOR_EACH %out_ok, %iter_reg, %each_fn
+    EXPAND VEC_DEQUE_ITER_TRY_FOR_EACH_U64 %out_ok, %iter_reg, %each_fn
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_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 VEC_DEQUE_ITER_FOLD_U64.
+[MACRO] VEC_DEQUE_ITER_FOLD %out_value, %iter_reg, %init_value, %fold_fn
+    EXPAND VEC_DEQUE_ITER_FOLD_U64 %out_value, %iter_reg, %init_value, %fold_fn
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_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 VEC_DEQUE_ITER_TRY_FOLD_U64.
+[MACRO] VEC_DEQUE_ITER_TRY_FOLD %out_ok, %out_value, %iter_reg, %init_value, %fold_fn
+    EXPAND VEC_DEQUE_ITER_TRY_FOLD_U64 %out_ok, %out_value, %iter_reg, %init_value, %fold_fn
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_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 VEC_DEQUE_ITER_RFOLD_U64.
+[MACRO] VEC_DEQUE_ITER_RFOLD %out_value, %iter_reg, %init_value, %fold_fn
+    EXPAND VEC_DEQUE_ITER_RFOLD_U64 %out_value, %iter_reg, %init_value, %fold_fn
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_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 VEC_DEQUE_ITER_TRY_RFOLD_U64.
+[MACRO] VEC_DEQUE_ITER_TRY_RFOLD %out_ok, %out_value, %iter_reg, %init_value, %fold_fn
+    EXPAND VEC_DEQUE_ITER_TRY_RFOLD_U64 %out_ok, %out_value, %iter_reg, %init_value, %fold_fn
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_ITER_SUM_U64 %out_value, %iter_reg
+    EXPAND ITER_SUM_U64 %out_value, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_ITER_SUM_U64.
+[MACRO] VEC_DEQUE_ITER_SUM %out_value, %iter_reg
+    EXPAND VEC_DEQUE_ITER_SUM_U64 %out_value, %iter_reg
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_ITER_PRODUCT_U64 %out_value, %iter_reg
+    EXPAND ITER_PRODUCT_U64 %out_value, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_ITER_PRODUCT_U64.
+[MACRO] VEC_DEQUE_ITER_PRODUCT %out_value, %iter_reg
+    EXPAND VEC_DEQUE_ITER_PRODUCT_U64 %out_value, %iter_reg
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_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 VEC_DEQUE_ITER_MIN_U64.
+[MACRO] VEC_DEQUE_ITER_MIN %out_has, %out_value, %iter_reg
+    EXPAND VEC_DEQUE_ITER_MIN_U64 %out_has, %out_value, %iter_reg
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_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 VEC_DEQUE_ITER_MAX_U64.
+[MACRO] VEC_DEQUE_ITER_MAX %out_has, %out_value, %iter_reg
+    EXPAND VEC_DEQUE_ITER_MAX_U64 %out_has, %out_value, %iter_reg
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_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 VEC_DEQUE_ITER_REDUCE_U64.
+[MACRO] VEC_DEQUE_ITER_REDUCE %out_has, %out_value, %iter_reg, %reduce_fn
+    EXPAND VEC_DEQUE_ITER_REDUCE_U64 %out_has, %out_value, %iter_reg, %reduce_fn
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_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 VEC_DEQUE_ITER_TRY_REDUCE_U64.
+[MACRO] VEC_DEQUE_ITER_TRY_REDUCE %out_ok, %out_has, %out_value, %iter_reg, %reduce_fn
+    EXPAND VEC_DEQUE_ITER_TRY_REDUCE_U64 %out_ok, %out_has, %out_value, %iter_reg, %reduce_fn
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_ITER_MIN_BY_U64 %out_has, %out_value, %iter_reg, %compare_fn
+    EXPAND ITER_MIN_BY_U64 %out_has, %out_value, %iter_reg, %compare_fn
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_ITER_MIN_BY_U64.
+[MACRO] VEC_DEQUE_ITER_MIN_BY %out_has, %out_value, %iter_reg, %compare_fn
+    EXPAND VEC_DEQUE_ITER_MIN_BY_U64 %out_has, %out_value, %iter_reg, %compare_fn
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_ITER_MAX_BY_U64 %out_has, %out_value, %iter_reg, %compare_fn
+    EXPAND ITER_MAX_BY_U64 %out_has, %out_value, %iter_reg, %compare_fn
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_ITER_MAX_BY_U64.
+[MACRO] VEC_DEQUE_ITER_MAX_BY %out_has, %out_value, %iter_reg, %compare_fn
+    EXPAND VEC_DEQUE_ITER_MAX_BY_U64 %out_has, %out_value, %iter_reg, %compare_fn
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_ITER_MIN_BY_KEY_U64 %out_has, %out_value, %iter_reg, %key_fn
+    EXPAND ITER_MIN_BY_KEY_U64 %out_has, %out_value, %iter_reg, %key_fn
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_ITER_MIN_BY_KEY_U64.
+[MACRO] VEC_DEQUE_ITER_MIN_BY_KEY %out_has, %out_value, %iter_reg, %key_fn
+    EXPAND VEC_DEQUE_ITER_MIN_BY_KEY_U64 %out_has, %out_value, %iter_reg, %key_fn
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_ITER_MAX_BY_KEY_U64 %out_has, %out_value, %iter_reg, %key_fn
+    EXPAND ITER_MAX_BY_KEY_U64 %out_has, %out_value, %iter_reg, %key_fn
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_ITER_MAX_BY_KEY_U64.
+[MACRO] VEC_DEQUE_ITER_MAX_BY_KEY %out_has, %out_value, %iter_reg, %key_fn
+    EXPAND VEC_DEQUE_ITER_MAX_BY_KEY_U64 %out_has, %out_value, %iter_reg, %key_fn
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_ITER_CMP_U64 %out_ordering, %left_iter, %right_iter
+    EXPAND ITER_CMP_U64 %out_ordering, %left_iter, %right_iter
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_ITER_CMP_U64.
+[MACRO] VEC_DEQUE_ITER_CMP %out_ordering, %left_iter, %right_iter
+    EXPAND VEC_DEQUE_ITER_CMP_U64 %out_ordering, %left_iter, %right_iter
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_ITER_CMP_BY_U64 %out_ordering, %left_iter, %right_iter, %compare_fn
+    EXPAND ITER_CMP_BY_U64 %out_ordering, %left_iter, %right_iter, %compare_fn
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_ITER_CMP_BY_U64.
+[MACRO] VEC_DEQUE_ITER_CMP_BY %out_ordering, %left_iter, %right_iter, %compare_fn
+    EXPAND VEC_DEQUE_ITER_CMP_BY_U64 %out_ordering, %left_iter, %right_iter, %compare_fn
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_ITER_PARTIAL_CMP_U64 %out_ordering, %left_iter, %right_iter
+    EXPAND ITER_PARTIAL_CMP_U64 %out_ordering, %left_iter, %right_iter
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_ITER_PARTIAL_CMP_U64.
+[MACRO] VEC_DEQUE_ITER_PARTIAL_CMP %out_ordering, %left_iter, %right_iter
+    EXPAND VEC_DEQUE_ITER_PARTIAL_CMP_U64 %out_ordering, %left_iter, %right_iter
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_ITER_PARTIAL_CMP_BY_U64 %out_ok, %out_ordering, %left_iter, %right_iter, %compare_fn
+    EXPAND ITER_PARTIAL_CMP_BY_U64 %out_ok, %out_ordering, %left_iter, %right_iter, %compare_fn
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_ITER_PARTIAL_CMP_BY_U64.
+[MACRO] VEC_DEQUE_ITER_PARTIAL_CMP_BY %out_ok, %out_ordering, %left_iter, %right_iter, %compare_fn
+    EXPAND VEC_DEQUE_ITER_PARTIAL_CMP_BY_U64 %out_ok, %out_ordering, %left_iter, %right_iter, %compare_fn
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_ITER_EQ_BY_U64 %out_bool, %left_iter, %right_iter, %eq_fn
+    EXPAND ITER_EQ_BY_U64 %out_bool, %left_iter, %right_iter, %eq_fn
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_ITER_EQ_BY_U64.
+[MACRO] VEC_DEQUE_ITER_EQ_BY %out_bool, %left_iter, %right_iter, %eq_fn
+    EXPAND VEC_DEQUE_ITER_EQ_BY_U64 %out_bool, %left_iter, %right_iter, %eq_fn
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_ITER_EQ_U64 %out_bool, %left_iter, %right_iter
+    EXPAND ITER_EQ_U64 %out_bool, %left_iter, %right_iter
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_ITER_EQ_U64.
+[MACRO] VEC_DEQUE_ITER_EQ %out_bool, %left_iter, %right_iter
+    EXPAND VEC_DEQUE_ITER_EQ_U64 %out_bool, %left_iter, %right_iter
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_ITER_PARTIAL_EQ_U64 %out_bool, %left_iter, %right_iter
+    EXPAND ITER_PARTIAL_EQ_U64 %out_bool, %left_iter, %right_iter
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_ITER_PARTIAL_EQ_U64.
+[MACRO] VEC_DEQUE_ITER_PARTIAL_EQ %out_bool, %left_iter, %right_iter
+    EXPAND VEC_DEQUE_ITER_PARTIAL_EQ_U64 %out_bool, %left_iter, %right_iter
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_ITER_NE_U64 %out_bool, %left_iter, %right_iter
+    EXPAND ITER_NE_U64 %out_bool, %left_iter, %right_iter
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_ITER_NE_U64.
+[MACRO] VEC_DEQUE_ITER_NE %out_bool, %left_iter, %right_iter
+    EXPAND VEC_DEQUE_ITER_NE_U64 %out_bool, %left_iter, %right_iter
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_ITER_LT_U64 %out_bool, %left_iter, %right_iter
+    EXPAND ITER_LT_U64 %out_bool, %left_iter, %right_iter
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_ITER_LT_U64.
+[MACRO] VEC_DEQUE_ITER_LT %out_bool, %left_iter, %right_iter
+    EXPAND VEC_DEQUE_ITER_LT_U64 %out_bool, %left_iter, %right_iter
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_ITER_LE_U64 %out_bool, %left_iter, %right_iter
+    EXPAND ITER_LE_U64 %out_bool, %left_iter, %right_iter
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_ITER_LE_U64.
+[MACRO] VEC_DEQUE_ITER_LE %out_bool, %left_iter, %right_iter
+    EXPAND VEC_DEQUE_ITER_LE_U64 %out_bool, %left_iter, %right_iter
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_ITER_GT_U64 %out_bool, %left_iter, %right_iter
+    EXPAND ITER_GT_U64 %out_bool, %left_iter, %right_iter
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_ITER_GT_U64.
+[MACRO] VEC_DEQUE_ITER_GT %out_bool, %left_iter, %right_iter
+    EXPAND VEC_DEQUE_ITER_GT_U64 %out_bool, %left_iter, %right_iter
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_ITER_GE_U64 %out_bool, %left_iter, %right_iter
+    EXPAND ITER_GE_U64 %out_bool, %left_iter, %right_iter
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_ITER_GE_U64.
+[MACRO] VEC_DEQUE_ITER_GE %out_bool, %left_iter, %right_iter
+    EXPAND VEC_DEQUE_ITER_GE_U64 %out_bool, %left_iter, %right_iter
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_ITER_IS_SORTED_U64 %out_bool, %iter_reg
+    EXPAND ITER_IS_SORTED_U64 %out_bool, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_ITER_IS_SORTED_U64.
+[MACRO] VEC_DEQUE_ITER_IS_SORTED %out_bool, %iter_reg
+    EXPAND VEC_DEQUE_ITER_IS_SORTED_U64 %out_bool, %iter_reg
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_ITER_IS_SORTED_BY_U64 %out_bool, %iter_reg, %compare_fn
+    EXPAND ITER_IS_SORTED_BY_U64 %out_bool, %iter_reg, %compare_fn
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_ITER_IS_SORTED_BY_U64.
+[MACRO] VEC_DEQUE_ITER_IS_SORTED_BY %out_bool, %iter_reg, %compare_fn
+    EXPAND VEC_DEQUE_ITER_IS_SORTED_BY_U64 %out_bool, %iter_reg, %compare_fn
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_ITER_IS_SORTED_BY_KEY_U64 %out_bool, %iter_reg, %key_fn
+    EXPAND ITER_IS_SORTED_BY_KEY_U64 %out_bool, %iter_reg, %key_fn
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_ITER_IS_SORTED_BY_KEY_U64.
+[MACRO] VEC_DEQUE_ITER_IS_SORTED_BY_KEY %out_bool, %iter_reg, %key_fn
+    EXPAND VEC_DEQUE_ITER_IS_SORTED_BY_KEY_U64 %out_bool, %iter_reg, %key_fn
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_ITER_PARTITION_U64 %out_true_vec, %out_false_vec, %iter_reg, %pred_fn
+    EXPAND ITER_PARTITION_U64 %out_true_vec, %out_false_vec, %iter_reg, %pred_fn
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_ITER_PARTITION_U64.
+[MACRO] VEC_DEQUE_ITER_PARTITION %out_true_vec, %out_false_vec, %iter_reg, %pred_fn
+    EXPAND VEC_DEQUE_ITER_PARTITION_U64 %out_true_vec, %out_false_vec, %iter_reg, %pred_fn
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_ITER_IS_PARTITIONED_U64 %out_bool, %iter_reg, %pred_fn
+    EXPAND ITER_IS_PARTITIONED_U64 %out_bool, %iter_reg, %pred_fn
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_ITER_IS_PARTITIONED_U64.
+[MACRO] VEC_DEQUE_ITER_IS_PARTITIONED %out_bool, %iter_reg, %pred_fn
+    EXPAND VEC_DEQUE_ITER_IS_PARTITIONED_U64 %out_bool, %iter_reg, %pred_fn
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_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 VEC_DEQUE_ITER_SIZE_HINT_U64.
+[MACRO] VEC_DEQUE_ITER_SIZE_HINT %out_lower, %out_upper, %iter_reg
+    EXPAND VEC_DEQUE_ITER_SIZE_HINT_U64 %out_lower, %out_upper, %iter_reg
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_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 VEC_DEQUE_ITER_EXACT_SIZE_LEN_U64.
+[MACRO] VEC_DEQUE_ITER_EXACT_SIZE_LEN %out_len, %iter_reg
+    EXPAND VEC_DEQUE_ITER_EXACT_SIZE_LEN_U64 %out_len, %iter_reg
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_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 VEC_DEQUE_ITER_EXACT_SIZE_IS_EMPTY_U64.
+[MACRO] VEC_DEQUE_ITER_EXACT_SIZE_IS_EMPTY %out_bool, %iter_reg
+    EXPAND VEC_DEQUE_ITER_EXACT_SIZE_IS_EMPTY_U64 %out_bool, %iter_reg
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_ITER_MUT_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 VEC_DEQUE_ITER_MUT_SIZE_HINT_U64.
+[MACRO] VEC_DEQUE_ITER_MUT_SIZE_HINT %out_lower, %out_upper, %iter_reg
+    EXPAND VEC_DEQUE_ITER_MUT_SIZE_HINT_U64 %out_lower, %out_upper, %iter_reg
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_ITER_MUT_EXACT_SIZE_LEN_U64 %out_len, %iter_reg
+    EXPAND ITER_EXACT_SIZE_LEN %out_len, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_ITER_MUT_EXACT_SIZE_LEN_U64.
+[MACRO] VEC_DEQUE_ITER_MUT_EXACT_SIZE_LEN %out_len, %iter_reg
+    EXPAND VEC_DEQUE_ITER_MUT_EXACT_SIZE_LEN_U64 %out_len, %iter_reg
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_ITER_MUT_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 VEC_DEQUE_ITER_MUT_EXACT_SIZE_IS_EMPTY_U64.
+[MACRO] VEC_DEQUE_ITER_MUT_EXACT_SIZE_IS_EMPTY %out_bool, %iter_reg
+    EXPAND VEC_DEQUE_ITER_MUT_EXACT_SIZE_IS_EMPTY_U64 %out_bool, %iter_reg
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_ITER_COLLECT_U64 %out_vec, %iter_reg
+    EXPAND ITER_COLLECT_U64 %out_vec, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_ITER_COLLECT_U64.
+[MACRO] VEC_DEQUE_ITER_COLLECT %out_vec, %iter_reg
+    EXPAND VEC_DEQUE_ITER_COLLECT_U64 %out_vec, %iter_reg
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_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 VEC_DEQUE_ITER_TRY_COLLECT_U64.
+[MACRO] VEC_DEQUE_ITER_TRY_COLLECT %out_ok, %out_vec, %iter_reg, %try_fn
+    EXPAND VEC_DEQUE_ITER_TRY_COLLECT_U64 %out_ok, %out_vec, %iter_reg, %try_fn
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_ITER_COLLECT_INTO_U64 %vec_reg, %iter_reg
+    EXPAND ITER_COLLECT_INTO_U64 %vec_reg, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_ITER_COLLECT_INTO_U64.
+[MACRO] VEC_DEQUE_ITER_COLLECT_INTO %vec_reg, %iter_reg
+    EXPAND VEC_DEQUE_ITER_COLLECT_INTO_U64 %vec_reg, %iter_reg
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_ITER_COPIED_COLLECT_U64 %out_vec, %iter_reg
+    EXPAND ITER_COPIED_COLLECT_U64 %out_vec, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_ITER_COPIED_COLLECT_U64.
+[MACRO] VEC_DEQUE_ITER_COPIED_COLLECT %out_vec, %iter_reg
+    EXPAND VEC_DEQUE_ITER_COPIED_COLLECT_U64 %out_vec, %iter_reg
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_ITER_CLONED_COLLECT_U64 %out_vec, %iter_reg
+    EXPAND ITER_CLONED_COLLECT_U64 %out_vec, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_ITER_CLONED_COLLECT_U64.
+[MACRO] VEC_DEQUE_ITER_CLONED_COLLECT %out_vec, %iter_reg
+    EXPAND VEC_DEQUE_ITER_CLONED_COLLECT_U64 %out_vec, %iter_reg
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_ITER_TAKE_COLLECT_U64 %out_vec, %iter_reg, %count
+    EXPAND ITER_TAKE_COLLECT_U64 %out_vec, %iter_reg, %count
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_ITER_TAKE_COLLECT_U64.
+[MACRO] VEC_DEQUE_ITER_TAKE_COLLECT %out_vec, %iter_reg, %count
+    EXPAND VEC_DEQUE_ITER_TAKE_COLLECT_U64 %out_vec, %iter_reg, %count
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_ITER_SKIP_COLLECT_U64 %out_vec, %iter_reg, %count
+    EXPAND ITER_SKIP_COLLECT_U64 %out_vec, %iter_reg, %count
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_ITER_SKIP_COLLECT_U64.
+[MACRO] VEC_DEQUE_ITER_SKIP_COLLECT %out_vec, %iter_reg, %count
+    EXPAND VEC_DEQUE_ITER_SKIP_COLLECT_U64 %out_vec, %iter_reg, %count
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_ITER_REV_COLLECT_U64 %out_vec, %iter_reg
+    EXPAND ITER_REV_COLLECT_U64 %out_vec, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_ITER_REV_COLLECT_U64.
+[MACRO] VEC_DEQUE_ITER_REV_COLLECT %out_vec, %iter_reg
+    EXPAND VEC_DEQUE_ITER_REV_COLLECT_U64 %out_vec, %iter_reg
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_ITER_TRY_STEP_BY_COLLECT_U64 %out_ok, %out_vec, %iter_reg, %step
+    EXPAND ITER_TRY_STEP_BY_COLLECT_U64 %out_ok, %out_vec, %iter_reg, %step
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_ITER_TRY_STEP_BY_COLLECT_U64.
+[MACRO] VEC_DEQUE_ITER_TRY_STEP_BY_COLLECT %out_ok, %out_vec, %iter_reg, %step
+    EXPAND VEC_DEQUE_ITER_TRY_STEP_BY_COLLECT_U64 %out_ok, %out_vec, %iter_reg, %step
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_ITER_STEP_BY_COLLECT_U64 %out_vec, %iter_reg, %step
+    EXPAND ITER_STEP_BY_COLLECT_U64 %out_vec, %iter_reg, %step
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_ITER_STEP_BY_COLLECT_U64.
+[MACRO] VEC_DEQUE_ITER_STEP_BY_COLLECT %out_vec, %iter_reg, %step
+    EXPAND VEC_DEQUE_ITER_STEP_BY_COLLECT_U64 %out_vec, %iter_reg, %step
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_ITER_MAP_COLLECT_U64 %out_vec, %iter_reg, %map_fn
+    EXPAND ITER_MAP_COLLECT_U64 %out_vec, %iter_reg, %map_fn
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_ITER_MAP_COLLECT_U64.
+[MACRO] VEC_DEQUE_ITER_MAP_COLLECT %out_vec, %iter_reg, %map_fn
+    EXPAND VEC_DEQUE_ITER_MAP_COLLECT_U64 %out_vec, %iter_reg, %map_fn
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_ITER_INSPECT_COLLECT_U64 %out_vec, %iter_reg, %inspect_fn
+    EXPAND ITER_INSPECT_COLLECT_U64 %out_vec, %iter_reg, %inspect_fn
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_ITER_INSPECT_COLLECT_U64.
+[MACRO] VEC_DEQUE_ITER_INSPECT_COLLECT %out_vec, %iter_reg, %inspect_fn
+    EXPAND VEC_DEQUE_ITER_INSPECT_COLLECT_U64 %out_vec, %iter_reg, %inspect_fn
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_ITER_SCAN_COLLECT_U64 %out_vec, %iter_reg, %initial_state, %scan_fn
+    EXPAND ITER_SCAN_COLLECT_U64 %out_vec, %iter_reg, %initial_state, %scan_fn
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_ITER_SCAN_COLLECT_U64.
+[MACRO] VEC_DEQUE_ITER_SCAN_COLLECT %out_vec, %iter_reg, %initial_state, %scan_fn
+    EXPAND VEC_DEQUE_ITER_SCAN_COLLECT_U64 %out_vec, %iter_reg, %initial_state, %scan_fn
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_ITER_FILTER_COLLECT_U64 %out_vec, %iter_reg, %pred_fn
+    EXPAND ITER_FILTER_COLLECT_U64 %out_vec, %iter_reg, %pred_fn
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_ITER_FILTER_COLLECT_U64.
+[MACRO] VEC_DEQUE_ITER_FILTER_COLLECT %out_vec, %iter_reg, %pred_fn
+    EXPAND VEC_DEQUE_ITER_FILTER_COLLECT_U64 %out_vec, %iter_reg, %pred_fn
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_ITER_FILTER_MAP_COLLECT_U64 %out_vec, %iter_reg, %map_fn
+    EXPAND ITER_FILTER_MAP_COLLECT_U64 %out_vec, %iter_reg, %map_fn
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_ITER_FILTER_MAP_COLLECT_U64.
+[MACRO] VEC_DEQUE_ITER_FILTER_MAP_COLLECT %out_vec, %iter_reg, %map_fn
+    EXPAND VEC_DEQUE_ITER_FILTER_MAP_COLLECT_U64 %out_vec, %iter_reg, %map_fn
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_ITER_MAP_WHILE_COLLECT_U64 %out_vec, %iter_reg, %map_fn
+    EXPAND ITER_MAP_WHILE_COLLECT_U64 %out_vec, %iter_reg, %map_fn
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_ITER_MAP_WHILE_COLLECT_U64.
+[MACRO] VEC_DEQUE_ITER_MAP_WHILE_COLLECT %out_vec, %iter_reg, %map_fn
+    EXPAND VEC_DEQUE_ITER_MAP_WHILE_COLLECT_U64 %out_vec, %iter_reg, %map_fn
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_ITER_INTERSPERSE_COLLECT_U64 %out_vec, %iter_reg, %separator
+    EXPAND ITER_INTERSPERSE_COLLECT_U64 %out_vec, %iter_reg, %separator
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_ITER_INTERSPERSE_COLLECT_U64.
+[MACRO] VEC_DEQUE_ITER_INTERSPERSE_COLLECT %out_vec, %iter_reg, %separator
+    EXPAND VEC_DEQUE_ITER_INTERSPERSE_COLLECT_U64 %out_vec, %iter_reg, %separator
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_ITER_INTERSPERSE_WITH_COLLECT_U64 %out_vec, %iter_reg, %sep_fn
+    EXPAND ITER_INTERSPERSE_WITH_COLLECT_U64 %out_vec, %iter_reg, %sep_fn
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_ITER_INTERSPERSE_WITH_COLLECT_U64.
+[MACRO] VEC_DEQUE_ITER_INTERSPERSE_WITH_COLLECT %out_vec, %iter_reg, %sep_fn
+    EXPAND VEC_DEQUE_ITER_INTERSPERSE_WITH_COLLECT_U64 %out_vec, %iter_reg, %sep_fn
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_ITER_CYCLE_TAKE_COLLECT_U64 %out_vec, %iter_reg, %count
+    EXPAND ITER_CYCLE_TAKE_COLLECT_U64 %out_vec, %iter_reg, %count
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_ITER_CYCLE_TAKE_COLLECT_U64.
+[MACRO] VEC_DEQUE_ITER_CYCLE_TAKE_COLLECT %out_vec, %iter_reg, %count
+    EXPAND VEC_DEQUE_ITER_CYCLE_TAKE_COLLECT_U64 %out_vec, %iter_reg, %count
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_ITER_TAKE_WHILE_COLLECT_U64 %out_vec, %iter_reg, %pred_fn
+    EXPAND ITER_TAKE_WHILE_COLLECT_U64 %out_vec, %iter_reg, %pred_fn
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_ITER_TAKE_WHILE_COLLECT_U64.
+[MACRO] VEC_DEQUE_ITER_TAKE_WHILE_COLLECT %out_vec, %iter_reg, %pred_fn
+    EXPAND VEC_DEQUE_ITER_TAKE_WHILE_COLLECT_U64 %out_vec, %iter_reg, %pred_fn
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_ITER_SKIP_WHILE_COLLECT_U64 %out_vec, %iter_reg, %pred_fn
+    EXPAND ITER_SKIP_WHILE_COLLECT_U64 %out_vec, %iter_reg, %pred_fn
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_ITER_SKIP_WHILE_COLLECT_U64.
+[MACRO] VEC_DEQUE_ITER_SKIP_WHILE_COLLECT %out_vec, %iter_reg, %pred_fn
+    EXPAND VEC_DEQUE_ITER_SKIP_WHILE_COLLECT_U64 %out_vec, %iter_reg, %pred_fn
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_ITER_ENUMERATE_COLLECT_U64 %out_vec, %iter_reg
+    EXPAND ITER_ENUMERATE_COLLECT_U64 %out_vec, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_ITER_ENUMERATE_COLLECT_U64.
+[MACRO] VEC_DEQUE_ITER_ENUMERATE_COLLECT %out_vec, %iter_reg
+    EXPAND VEC_DEQUE_ITER_ENUMERATE_COLLECT_U64 %out_vec, %iter_reg
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_ITER_ZIP_COLLECT_U64 %out_vec, %left_iter, %right_iter
+    EXPAND ITER_ZIP_COLLECT_U64 %out_vec, %left_iter, %right_iter
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_ITER_ZIP_COLLECT_U64.
+[MACRO] VEC_DEQUE_ITER_ZIP_COLLECT %out_vec, %left_iter, %right_iter
+    EXPAND VEC_DEQUE_ITER_ZIP_COLLECT_U64 %out_vec, %left_iter, %right_iter
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_ITER_CHAIN_COLLECT_U64 %out_vec, %left_iter, %right_iter
+    EXPAND ITER_CHAIN_COLLECT_U64 %out_vec, %left_iter, %right_iter
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_ITER_CHAIN_COLLECT_U64.
+[MACRO] VEC_DEQUE_ITER_CHAIN_COLLECT %out_vec, %left_iter, %right_iter
+    EXPAND VEC_DEQUE_ITER_CHAIN_COLLECT_U64 %out_vec, %left_iter, %right_iter
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_ITER_BY_REF_COLLECT_U64 %out_vec, %iter_reg
+    EXPAND ITER_BY_REF_COLLECT_U64 %out_vec, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_ITER_BY_REF_COLLECT_U64.
+[MACRO] VEC_DEQUE_ITER_BY_REF_COLLECT %out_vec, %iter_reg
+    EXPAND VEC_DEQUE_ITER_BY_REF_COLLECT_U64 %out_vec, %iter_reg
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_ITER_FUSE_COLLECT_U64 %out_vec, %iter_reg
+    EXPAND ITER_FUSE_COLLECT_U64 %out_vec, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_ITER_FUSE_COLLECT_U64.
+[MACRO] VEC_DEQUE_ITER_FUSE_COLLECT %out_vec, %iter_reg
+    EXPAND VEC_DEQUE_ITER_FUSE_COLLECT_U64 %out_vec, %iter_reg
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_ITER_PEEKABLE_COLLECT_U64 %out_vec, %iter_reg
+    EXPAND ITER_PEEKABLE_COLLECT_U64 %out_vec, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_ITER_PEEKABLE_COLLECT_U64.
+[MACRO] VEC_DEQUE_ITER_PEEKABLE_COLLECT %out_vec, %iter_reg
+    EXPAND VEC_DEQUE_ITER_PEEKABLE_COLLECT_U64 %out_vec, %iter_reg
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_ITER_ARRAY_CHUNKS_COLLECT_U64 %out_ok, %out_vec, %iter_reg, %chunk_size
+    EXPAND ITER_ARRAY_CHUNKS_COLLECT_U64 %out_ok, %out_vec, %iter_reg, %chunk_size
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_ITER_ARRAY_CHUNKS_COLLECT_U64.
+[MACRO] VEC_DEQUE_ITER_ARRAY_CHUNKS_COLLECT %out_ok, %out_vec, %iter_reg, %chunk_size
+    EXPAND VEC_DEQUE_ITER_ARRAY_CHUNKS_COLLECT_U64 %out_ok, %out_vec, %iter_reg, %chunk_size
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_ITER_MAP_WINDOWS_COLLECT_U64 %out_ok, %out_vec, %iter_reg, %window_size, %map_fn
+    EXPAND ITER_MAP_WINDOWS_COLLECT_U64 %out_ok, %out_vec, %iter_reg, %window_size, %map_fn
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_ITER_MAP_WINDOWS_COLLECT_U64.
+[MACRO] VEC_DEQUE_ITER_MAP_WINDOWS_COLLECT %out_ok, %out_vec, %iter_reg, %window_size, %map_fn
+    EXPAND VEC_DEQUE_ITER_MAP_WINDOWS_COLLECT_U64 %out_ok, %out_vec, %iter_reg, %window_size, %map_fn
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INTO_ITER_NEXT_U64 %out_has, %out_value, %iter_reg
+    EXPAND VEC_DEQUE_ITER_NEXT_U64 %out_has, %out_value, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_INTO_ITER_NEXT_U64.
+[MACRO] VEC_DEQUE_INTO_ITER_NEXT %out_has, %out_value, %iter_reg
+    EXPAND VEC_DEQUE_INTO_ITER_NEXT_U64 %out_has, %out_value, %iter_reg
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INTO_ITER_NEXT_BACK_U64 %out_has, %out_value, %iter_reg
+    EXPAND VEC_DEQUE_ITER_NEXT_BACK_U64 %out_has, %out_value, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_INTO_ITER_NEXT_BACK_U64.
+[MACRO] VEC_DEQUE_INTO_ITER_NEXT_BACK %out_has, %out_value, %iter_reg
+    EXPAND VEC_DEQUE_INTO_ITER_NEXT_BACK_U64 %out_has, %out_value, %iter_reg
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INTO_ITER_NTH_U64 %out_has, %out_value, %iter_reg, %nth
+    EXPAND VEC_DEQUE_ITER_NTH_U64 %out_has, %out_value, %iter_reg, %nth
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_INTO_ITER_NTH_U64.
+[MACRO] VEC_DEQUE_INTO_ITER_NTH %out_has, %out_value, %iter_reg, %nth
+    EXPAND VEC_DEQUE_INTO_ITER_NTH_U64 %out_has, %out_value, %iter_reg, %nth
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INTO_ITER_NTH_BACK_U64 %out_has, %out_value, %iter_reg, %nth
+    EXPAND VEC_DEQUE_ITER_NTH_BACK_U64 %out_has, %out_value, %iter_reg, %nth
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_INTO_ITER_NTH_BACK_U64.
+[MACRO] VEC_DEQUE_INTO_ITER_NTH_BACK %out_has, %out_value, %iter_reg, %nth
+    EXPAND VEC_DEQUE_INTO_ITER_NTH_BACK_U64 %out_has, %out_value, %iter_reg, %nth
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INTO_ITER_TRY_NEXT_CHUNK_U64 %out_ok, %out_filled, %iter_reg, %dst_ptr, %count
+    EXPAND VEC_DEQUE_ITER_TRY_NEXT_CHUNK_U64 %out_ok, %out_filled, %iter_reg, %dst_ptr, %count
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_INTO_ITER_TRY_NEXT_CHUNK_U64.
+[MACRO] VEC_DEQUE_INTO_ITER_TRY_NEXT_CHUNK %out_ok, %out_filled, %iter_reg, %dst_ptr, %count
+    EXPAND VEC_DEQUE_INTO_ITER_TRY_NEXT_CHUNK_U64 %out_ok, %out_filled, %iter_reg, %dst_ptr, %count
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INTO_ITER_ADVANCE_BY %out_ok, %out_remaining, %iter_reg, %count
+    EXPAND VEC_DEQUE_ITER_ADVANCE_BY %out_ok, %out_remaining, %iter_reg, %count
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INTO_ITER_ADVANCE_BACK_BY %out_ok, %out_remaining, %iter_reg, %count
+    EXPAND VEC_DEQUE_ITER_ADVANCE_BACK_BY %out_ok, %out_remaining, %iter_reg, %count
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INTO_ITER_COUNT_U64 %out_count, %iter_reg
+    EXPAND VEC_DEQUE_ITER_COUNT_U64 %out_count, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_INTO_ITER_COUNT_U64.
+[MACRO] VEC_DEQUE_INTO_ITER_COUNT %out_count, %iter_reg
+    EXPAND VEC_DEQUE_INTO_ITER_COUNT_U64 %out_count, %iter_reg
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INTO_ITER_LAST_U64 %out_has, %out_value, %iter_reg
+    EXPAND VEC_DEQUE_ITER_LAST_U64 %out_has, %out_value, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_INTO_ITER_LAST_U64.
+[MACRO] VEC_DEQUE_INTO_ITER_LAST %out_has, %out_value, %iter_reg
+    EXPAND VEC_DEQUE_INTO_ITER_LAST_U64 %out_has, %out_value, %iter_reg
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INTO_ITER_FIND_U64 %out_has, %out_value, %iter_reg, %pred_fn
+    EXPAND VEC_DEQUE_ITER_FIND_U64 %out_has, %out_value, %iter_reg, %pred_fn
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_INTO_ITER_FIND_U64.
+[MACRO] VEC_DEQUE_INTO_ITER_FIND %out_has, %out_value, %iter_reg, %pred_fn
+    EXPAND VEC_DEQUE_INTO_ITER_FIND_U64 %out_has, %out_value, %iter_reg, %pred_fn
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INTO_ITER_TRY_FIND_U64 %out_ok, %out_has, %out_value, %iter_reg, %pred_fn
+    EXPAND VEC_DEQUE_ITER_TRY_FIND_U64 %out_ok, %out_has, %out_value, %iter_reg, %pred_fn
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_INTO_ITER_TRY_FIND_U64.
+[MACRO] VEC_DEQUE_INTO_ITER_TRY_FIND %out_ok, %out_has, %out_value, %iter_reg, %pred_fn
+    EXPAND VEC_DEQUE_INTO_ITER_TRY_FIND_U64 %out_ok, %out_has, %out_value, %iter_reg, %pred_fn
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INTO_ITER_FIND_MAP_U64 %out_has, %out_value, %iter_reg, %map_fn
+    EXPAND VEC_DEQUE_ITER_FIND_MAP_U64 %out_has, %out_value, %iter_reg, %map_fn
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_INTO_ITER_FIND_MAP_U64.
+[MACRO] VEC_DEQUE_INTO_ITER_FIND_MAP %out_has, %out_value, %iter_reg, %map_fn
+    EXPAND VEC_DEQUE_INTO_ITER_FIND_MAP_U64 %out_has, %out_value, %iter_reg, %map_fn
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INTO_ITER_POSITION_U64 %out_has, %out_index, %iter_reg, %pred_fn
+    EXPAND VEC_DEQUE_ITER_POSITION_U64 %out_has, %out_index, %iter_reg, %pred_fn
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_INTO_ITER_POSITION_U64.
+[MACRO] VEC_DEQUE_INTO_ITER_POSITION %out_has, %out_index, %iter_reg, %pred_fn
+    EXPAND VEC_DEQUE_INTO_ITER_POSITION_U64 %out_has, %out_index, %iter_reg, %pred_fn
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INTO_ITER_RPOSITION_U64 %out_has, %out_index, %iter_reg, %pred_fn
+    EXPAND VEC_DEQUE_ITER_RPOSITION_U64 %out_has, %out_index, %iter_reg, %pred_fn
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_INTO_ITER_RPOSITION_U64.
+[MACRO] VEC_DEQUE_INTO_ITER_RPOSITION %out_has, %out_index, %iter_reg, %pred_fn
+    EXPAND VEC_DEQUE_INTO_ITER_RPOSITION_U64 %out_has, %out_index, %iter_reg, %pred_fn
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INTO_ITER_RFIND_U64 %out_has, %out_value, %iter_reg, %pred_fn
+    EXPAND VEC_DEQUE_ITER_RFIND_U64 %out_has, %out_value, %iter_reg, %pred_fn
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_INTO_ITER_RFIND_U64.
+[MACRO] VEC_DEQUE_INTO_ITER_RFIND %out_has, %out_value, %iter_reg, %pred_fn
+    EXPAND VEC_DEQUE_INTO_ITER_RFIND_U64 %out_has, %out_value, %iter_reg, %pred_fn
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INTO_ITER_ANY_U64 %out_bool, %iter_reg, %pred_fn
+    EXPAND VEC_DEQUE_ITER_ANY_U64 %out_bool, %iter_reg, %pred_fn
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_INTO_ITER_ANY_U64.
+[MACRO] VEC_DEQUE_INTO_ITER_ANY %out_bool, %iter_reg, %pred_fn
+    EXPAND VEC_DEQUE_INTO_ITER_ANY_U64 %out_bool, %iter_reg, %pred_fn
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INTO_ITER_ALL_U64 %out_bool, %iter_reg, %pred_fn
+    EXPAND VEC_DEQUE_ITER_ALL_U64 %out_bool, %iter_reg, %pred_fn
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_INTO_ITER_ALL_U64.
+[MACRO] VEC_DEQUE_INTO_ITER_ALL %out_bool, %iter_reg, %pred_fn
+    EXPAND VEC_DEQUE_INTO_ITER_ALL_U64 %out_bool, %iter_reg, %pred_fn
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INTO_ITER_FOR_EACH_U64 %iter_reg, %each_fn
+    EXPAND VEC_DEQUE_ITER_FOR_EACH_U64 %iter_reg, %each_fn
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_INTO_ITER_FOR_EACH_U64.
+[MACRO] VEC_DEQUE_INTO_ITER_FOR_EACH %iter_reg, %each_fn
+    EXPAND VEC_DEQUE_INTO_ITER_FOR_EACH_U64 %iter_reg, %each_fn
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INTO_ITER_TRY_FOR_EACH_U64 %out_ok, %iter_reg, %each_fn
+    EXPAND VEC_DEQUE_ITER_TRY_FOR_EACH_U64 %out_ok, %iter_reg, %each_fn
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_INTO_ITER_TRY_FOR_EACH_U64.
+[MACRO] VEC_DEQUE_INTO_ITER_TRY_FOR_EACH %out_ok, %iter_reg, %each_fn
+    EXPAND VEC_DEQUE_INTO_ITER_TRY_FOR_EACH_U64 %out_ok, %iter_reg, %each_fn
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INTO_ITER_FOLD_U64 %out_value, %iter_reg, %init_value, %fold_fn
+    EXPAND VEC_DEQUE_ITER_FOLD_U64 %out_value, %iter_reg, %init_value, %fold_fn
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_INTO_ITER_FOLD_U64.
+[MACRO] VEC_DEQUE_INTO_ITER_FOLD %out_value, %iter_reg, %init_value, %fold_fn
+    EXPAND VEC_DEQUE_INTO_ITER_FOLD_U64 %out_value, %iter_reg, %init_value, %fold_fn
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INTO_ITER_TRY_FOLD_U64 %out_ok, %out_value, %iter_reg, %init_value, %fold_fn
+    EXPAND VEC_DEQUE_ITER_TRY_FOLD_U64 %out_ok, %out_value, %iter_reg, %init_value, %fold_fn
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_INTO_ITER_TRY_FOLD_U64.
+[MACRO] VEC_DEQUE_INTO_ITER_TRY_FOLD %out_ok, %out_value, %iter_reg, %init_value, %fold_fn
+    EXPAND VEC_DEQUE_INTO_ITER_TRY_FOLD_U64 %out_ok, %out_value, %iter_reg, %init_value, %fold_fn
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INTO_ITER_RFOLD_U64 %out_value, %iter_reg, %init_value, %fold_fn
+    EXPAND VEC_DEQUE_ITER_RFOLD_U64 %out_value, %iter_reg, %init_value, %fold_fn
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_INTO_ITER_RFOLD_U64.
+[MACRO] VEC_DEQUE_INTO_ITER_RFOLD %out_value, %iter_reg, %init_value, %fold_fn
+    EXPAND VEC_DEQUE_INTO_ITER_RFOLD_U64 %out_value, %iter_reg, %init_value, %fold_fn
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INTO_ITER_TRY_RFOLD_U64 %out_ok, %out_value, %iter_reg, %init_value, %fold_fn
+    EXPAND VEC_DEQUE_ITER_TRY_RFOLD_U64 %out_ok, %out_value, %iter_reg, %init_value, %fold_fn
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_INTO_ITER_TRY_RFOLD_U64.
+[MACRO] VEC_DEQUE_INTO_ITER_TRY_RFOLD %out_ok, %out_value, %iter_reg, %init_value, %fold_fn
+    EXPAND VEC_DEQUE_INTO_ITER_TRY_RFOLD_U64 %out_ok, %out_value, %iter_reg, %init_value, %fold_fn
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INTO_ITER_SUM_U64 %out_value, %iter_reg
+    EXPAND VEC_DEQUE_ITER_SUM_U64 %out_value, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_INTO_ITER_SUM_U64.
+[MACRO] VEC_DEQUE_INTO_ITER_SUM %out_value, %iter_reg
+    EXPAND VEC_DEQUE_INTO_ITER_SUM_U64 %out_value, %iter_reg
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INTO_ITER_PRODUCT_U64 %out_value, %iter_reg
+    EXPAND VEC_DEQUE_ITER_PRODUCT_U64 %out_value, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_INTO_ITER_PRODUCT_U64.
+[MACRO] VEC_DEQUE_INTO_ITER_PRODUCT %out_value, %iter_reg
+    EXPAND VEC_DEQUE_INTO_ITER_PRODUCT_U64 %out_value, %iter_reg
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INTO_ITER_MIN_U64 %out_has, %out_value, %iter_reg
+    EXPAND VEC_DEQUE_ITER_MIN_U64 %out_has, %out_value, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_INTO_ITER_MIN_U64.
+[MACRO] VEC_DEQUE_INTO_ITER_MIN %out_has, %out_value, %iter_reg
+    EXPAND VEC_DEQUE_INTO_ITER_MIN_U64 %out_has, %out_value, %iter_reg
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INTO_ITER_MAX_U64 %out_has, %out_value, %iter_reg
+    EXPAND VEC_DEQUE_ITER_MAX_U64 %out_has, %out_value, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_INTO_ITER_MAX_U64.
+[MACRO] VEC_DEQUE_INTO_ITER_MAX %out_has, %out_value, %iter_reg
+    EXPAND VEC_DEQUE_INTO_ITER_MAX_U64 %out_has, %out_value, %iter_reg
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INTO_ITER_REDUCE_U64 %out_has, %out_value, %iter_reg, %reduce_fn
+    EXPAND VEC_DEQUE_ITER_REDUCE_U64 %out_has, %out_value, %iter_reg, %reduce_fn
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_INTO_ITER_REDUCE_U64.
+[MACRO] VEC_DEQUE_INTO_ITER_REDUCE %out_has, %out_value, %iter_reg, %reduce_fn
+    EXPAND VEC_DEQUE_INTO_ITER_REDUCE_U64 %out_has, %out_value, %iter_reg, %reduce_fn
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INTO_ITER_TRY_REDUCE_U64 %out_ok, %out_has, %out_value, %iter_reg, %reduce_fn
+    EXPAND VEC_DEQUE_ITER_TRY_REDUCE_U64 %out_ok, %out_has, %out_value, %iter_reg, %reduce_fn
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_INTO_ITER_TRY_REDUCE_U64.
+[MACRO] VEC_DEQUE_INTO_ITER_TRY_REDUCE %out_ok, %out_has, %out_value, %iter_reg, %reduce_fn
+    EXPAND VEC_DEQUE_INTO_ITER_TRY_REDUCE_U64 %out_ok, %out_has, %out_value, %iter_reg, %reduce_fn
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INTO_ITER_MIN_BY_U64 %out_has, %out_value, %iter_reg, %compare_fn
+    EXPAND VEC_DEQUE_ITER_MIN_BY_U64 %out_has, %out_value, %iter_reg, %compare_fn
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_INTO_ITER_MIN_BY_U64.
+[MACRO] VEC_DEQUE_INTO_ITER_MIN_BY %out_has, %out_value, %iter_reg, %compare_fn
+    EXPAND VEC_DEQUE_INTO_ITER_MIN_BY_U64 %out_has, %out_value, %iter_reg, %compare_fn
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INTO_ITER_MAX_BY_U64 %out_has, %out_value, %iter_reg, %compare_fn
+    EXPAND VEC_DEQUE_ITER_MAX_BY_U64 %out_has, %out_value, %iter_reg, %compare_fn
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_INTO_ITER_MAX_BY_U64.
+[MACRO] VEC_DEQUE_INTO_ITER_MAX_BY %out_has, %out_value, %iter_reg, %compare_fn
+    EXPAND VEC_DEQUE_INTO_ITER_MAX_BY_U64 %out_has, %out_value, %iter_reg, %compare_fn
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INTO_ITER_MIN_BY_KEY_U64 %out_has, %out_value, %iter_reg, %key_fn
+    EXPAND VEC_DEQUE_ITER_MIN_BY_KEY_U64 %out_has, %out_value, %iter_reg, %key_fn
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_INTO_ITER_MIN_BY_KEY_U64.
+[MACRO] VEC_DEQUE_INTO_ITER_MIN_BY_KEY %out_has, %out_value, %iter_reg, %key_fn
+    EXPAND VEC_DEQUE_INTO_ITER_MIN_BY_KEY_U64 %out_has, %out_value, %iter_reg, %key_fn
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INTO_ITER_MAX_BY_KEY_U64 %out_has, %out_value, %iter_reg, %key_fn
+    EXPAND VEC_DEQUE_ITER_MAX_BY_KEY_U64 %out_has, %out_value, %iter_reg, %key_fn
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_INTO_ITER_MAX_BY_KEY_U64.
+[MACRO] VEC_DEQUE_INTO_ITER_MAX_BY_KEY %out_has, %out_value, %iter_reg, %key_fn
+    EXPAND VEC_DEQUE_INTO_ITER_MAX_BY_KEY_U64 %out_has, %out_value, %iter_reg, %key_fn
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INTO_ITER_CMP_U64 %out_ordering, %left_iter, %right_iter
+    EXPAND VEC_DEQUE_ITER_CMP_U64 %out_ordering, %left_iter, %right_iter
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_INTO_ITER_CMP_U64.
+[MACRO] VEC_DEQUE_INTO_ITER_CMP %out_ordering, %left_iter, %right_iter
+    EXPAND VEC_DEQUE_INTO_ITER_CMP_U64 %out_ordering, %left_iter, %right_iter
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INTO_ITER_CMP_BY_U64 %out_ordering, %left_iter, %right_iter, %compare_fn
+    EXPAND VEC_DEQUE_ITER_CMP_BY_U64 %out_ordering, %left_iter, %right_iter, %compare_fn
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_INTO_ITER_CMP_BY_U64.
+[MACRO] VEC_DEQUE_INTO_ITER_CMP_BY %out_ordering, %left_iter, %right_iter, %compare_fn
+    EXPAND VEC_DEQUE_INTO_ITER_CMP_BY_U64 %out_ordering, %left_iter, %right_iter, %compare_fn
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INTO_ITER_PARTIAL_CMP_U64 %out_ordering, %left_iter, %right_iter
+    EXPAND VEC_DEQUE_ITER_PARTIAL_CMP_U64 %out_ordering, %left_iter, %right_iter
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_INTO_ITER_PARTIAL_CMP_U64.
+[MACRO] VEC_DEQUE_INTO_ITER_PARTIAL_CMP %out_ordering, %left_iter, %right_iter
+    EXPAND VEC_DEQUE_INTO_ITER_PARTIAL_CMP_U64 %out_ordering, %left_iter, %right_iter
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INTO_ITER_PARTIAL_CMP_BY_U64 %out_ok, %out_ordering, %left_iter, %right_iter, %compare_fn
+    EXPAND VEC_DEQUE_ITER_PARTIAL_CMP_BY_U64 %out_ok, %out_ordering, %left_iter, %right_iter, %compare_fn
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_INTO_ITER_PARTIAL_CMP_BY_U64.
+[MACRO] VEC_DEQUE_INTO_ITER_PARTIAL_CMP_BY %out_ok, %out_ordering, %left_iter, %right_iter, %compare_fn
+    EXPAND VEC_DEQUE_INTO_ITER_PARTIAL_CMP_BY_U64 %out_ok, %out_ordering, %left_iter, %right_iter, %compare_fn
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INTO_ITER_EQ_BY_U64 %out_bool, %left_iter, %right_iter, %eq_fn
+    EXPAND VEC_DEQUE_ITER_EQ_BY_U64 %out_bool, %left_iter, %right_iter, %eq_fn
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_INTO_ITER_EQ_BY_U64.
+[MACRO] VEC_DEQUE_INTO_ITER_EQ_BY %out_bool, %left_iter, %right_iter, %eq_fn
+    EXPAND VEC_DEQUE_INTO_ITER_EQ_BY_U64 %out_bool, %left_iter, %right_iter, %eq_fn
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INTO_ITER_EQ_U64 %out_bool, %left_iter, %right_iter
+    EXPAND VEC_DEQUE_ITER_EQ_U64 %out_bool, %left_iter, %right_iter
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_INTO_ITER_EQ_U64.
+[MACRO] VEC_DEQUE_INTO_ITER_EQ %out_bool, %left_iter, %right_iter
+    EXPAND VEC_DEQUE_INTO_ITER_EQ_U64 %out_bool, %left_iter, %right_iter
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INTO_ITER_PARTIAL_EQ_U64 %out_bool, %left_iter, %right_iter
+    EXPAND VEC_DEQUE_ITER_PARTIAL_EQ_U64 %out_bool, %left_iter, %right_iter
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_INTO_ITER_PARTIAL_EQ_U64.
+[MACRO] VEC_DEQUE_INTO_ITER_PARTIAL_EQ %out_bool, %left_iter, %right_iter
+    EXPAND VEC_DEQUE_INTO_ITER_PARTIAL_EQ_U64 %out_bool, %left_iter, %right_iter
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INTO_ITER_NE_U64 %out_bool, %left_iter, %right_iter
+    EXPAND VEC_DEQUE_ITER_NE_U64 %out_bool, %left_iter, %right_iter
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_INTO_ITER_NE_U64.
+[MACRO] VEC_DEQUE_INTO_ITER_NE %out_bool, %left_iter, %right_iter
+    EXPAND VEC_DEQUE_INTO_ITER_NE_U64 %out_bool, %left_iter, %right_iter
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INTO_ITER_LT_U64 %out_bool, %left_iter, %right_iter
+    EXPAND VEC_DEQUE_ITER_LT_U64 %out_bool, %left_iter, %right_iter
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_INTO_ITER_LT_U64.
+[MACRO] VEC_DEQUE_INTO_ITER_LT %out_bool, %left_iter, %right_iter
+    EXPAND VEC_DEQUE_INTO_ITER_LT_U64 %out_bool, %left_iter, %right_iter
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INTO_ITER_LE_U64 %out_bool, %left_iter, %right_iter
+    EXPAND VEC_DEQUE_ITER_LE_U64 %out_bool, %left_iter, %right_iter
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_INTO_ITER_LE_U64.
+[MACRO] VEC_DEQUE_INTO_ITER_LE %out_bool, %left_iter, %right_iter
+    EXPAND VEC_DEQUE_INTO_ITER_LE_U64 %out_bool, %left_iter, %right_iter
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INTO_ITER_GT_U64 %out_bool, %left_iter, %right_iter
+    EXPAND VEC_DEQUE_ITER_GT_U64 %out_bool, %left_iter, %right_iter
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_INTO_ITER_GT_U64.
+[MACRO] VEC_DEQUE_INTO_ITER_GT %out_bool, %left_iter, %right_iter
+    EXPAND VEC_DEQUE_INTO_ITER_GT_U64 %out_bool, %left_iter, %right_iter
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INTO_ITER_GE_U64 %out_bool, %left_iter, %right_iter
+    EXPAND VEC_DEQUE_ITER_GE_U64 %out_bool, %left_iter, %right_iter
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_INTO_ITER_GE_U64.
+[MACRO] VEC_DEQUE_INTO_ITER_GE %out_bool, %left_iter, %right_iter
+    EXPAND VEC_DEQUE_INTO_ITER_GE_U64 %out_bool, %left_iter, %right_iter
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INTO_ITER_IS_SORTED_U64 %out_bool, %iter_reg
+    EXPAND VEC_DEQUE_ITER_IS_SORTED_U64 %out_bool, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_INTO_ITER_IS_SORTED_U64.
+[MACRO] VEC_DEQUE_INTO_ITER_IS_SORTED %out_bool, %iter_reg
+    EXPAND VEC_DEQUE_INTO_ITER_IS_SORTED_U64 %out_bool, %iter_reg
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INTO_ITER_IS_SORTED_BY_U64 %out_bool, %iter_reg, %compare_fn
+    EXPAND VEC_DEQUE_ITER_IS_SORTED_BY_U64 %out_bool, %iter_reg, %compare_fn
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_INTO_ITER_IS_SORTED_BY_U64.
+[MACRO] VEC_DEQUE_INTO_ITER_IS_SORTED_BY %out_bool, %iter_reg, %compare_fn
+    EXPAND VEC_DEQUE_INTO_ITER_IS_SORTED_BY_U64 %out_bool, %iter_reg, %compare_fn
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INTO_ITER_IS_SORTED_BY_KEY_U64 %out_bool, %iter_reg, %key_fn
+    EXPAND VEC_DEQUE_ITER_IS_SORTED_BY_KEY_U64 %out_bool, %iter_reg, %key_fn
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_INTO_ITER_IS_SORTED_BY_KEY_U64.
+[MACRO] VEC_DEQUE_INTO_ITER_IS_SORTED_BY_KEY %out_bool, %iter_reg, %key_fn
+    EXPAND VEC_DEQUE_INTO_ITER_IS_SORTED_BY_KEY_U64 %out_bool, %iter_reg, %key_fn
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INTO_ITER_PARTITION_U64 %out_true_vec, %out_false_vec, %iter_reg, %pred_fn
+    EXPAND VEC_DEQUE_ITER_PARTITION_U64 %out_true_vec, %out_false_vec, %iter_reg, %pred_fn
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_INTO_ITER_PARTITION_U64.
+[MACRO] VEC_DEQUE_INTO_ITER_PARTITION %out_true_vec, %out_false_vec, %iter_reg, %pred_fn
+    EXPAND VEC_DEQUE_INTO_ITER_PARTITION_U64 %out_true_vec, %out_false_vec, %iter_reg, %pred_fn
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INTO_ITER_IS_PARTITIONED_U64 %out_bool, %iter_reg, %pred_fn
+    EXPAND VEC_DEQUE_ITER_IS_PARTITIONED_U64 %out_bool, %iter_reg, %pred_fn
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_INTO_ITER_IS_PARTITIONED_U64.
+[MACRO] VEC_DEQUE_INTO_ITER_IS_PARTITIONED %out_bool, %iter_reg, %pred_fn
+    EXPAND VEC_DEQUE_INTO_ITER_IS_PARTITIONED_U64 %out_bool, %iter_reg, %pred_fn
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INTO_ITER_SIZE_HINT_U64 %out_lower, %out_upper, %iter_reg
+    EXPAND VEC_DEQUE_ITER_SIZE_HINT_U64 %out_lower, %out_upper, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_INTO_ITER_SIZE_HINT_U64.
+[MACRO] VEC_DEQUE_INTO_ITER_SIZE_HINT %out_lower, %out_upper, %iter_reg
+    EXPAND VEC_DEQUE_INTO_ITER_SIZE_HINT_U64 %out_lower, %out_upper, %iter_reg
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INTO_ITER_EXACT_SIZE_LEN_U64 %out_len, %iter_reg
+    EXPAND VEC_DEQUE_ITER_EXACT_SIZE_LEN_U64 %out_len, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_INTO_ITER_EXACT_SIZE_LEN_U64.
+[MACRO] VEC_DEQUE_INTO_ITER_EXACT_SIZE_LEN %out_len, %iter_reg
+    EXPAND VEC_DEQUE_INTO_ITER_EXACT_SIZE_LEN_U64 %out_len, %iter_reg
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INTO_ITER_EXACT_SIZE_IS_EMPTY_U64 %out_bool, %iter_reg
+    EXPAND VEC_DEQUE_ITER_EXACT_SIZE_IS_EMPTY_U64 %out_bool, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_INTO_ITER_EXACT_SIZE_IS_EMPTY_U64.
+[MACRO] VEC_DEQUE_INTO_ITER_EXACT_SIZE_IS_EMPTY %out_bool, %iter_reg
+    EXPAND VEC_DEQUE_INTO_ITER_EXACT_SIZE_IS_EMPTY_U64 %out_bool, %iter_reg
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INTO_ITER_COLLECT_U64 %out_vec, %iter_reg
+    EXPAND VEC_DEQUE_ITER_COLLECT_U64 %out_vec, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_INTO_ITER_COLLECT_U64.
+[MACRO] VEC_DEQUE_INTO_ITER_COLLECT %out_vec, %iter_reg
+    EXPAND VEC_DEQUE_INTO_ITER_COLLECT_U64 %out_vec, %iter_reg
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INTO_ITER_TRY_COLLECT_U64 %out_ok, %out_vec, %iter_reg, %try_fn
+    EXPAND VEC_DEQUE_ITER_TRY_COLLECT_U64 %out_ok, %out_vec, %iter_reg, %try_fn
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_INTO_ITER_TRY_COLLECT_U64.
+[MACRO] VEC_DEQUE_INTO_ITER_TRY_COLLECT %out_ok, %out_vec, %iter_reg, %try_fn
+    EXPAND VEC_DEQUE_INTO_ITER_TRY_COLLECT_U64 %out_ok, %out_vec, %iter_reg, %try_fn
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INTO_ITER_COLLECT_INTO_U64 %vec_reg, %iter_reg
+    EXPAND VEC_DEQUE_ITER_COLLECT_INTO_U64 %vec_reg, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_INTO_ITER_COLLECT_INTO_U64.
+[MACRO] VEC_DEQUE_INTO_ITER_COLLECT_INTO %vec_reg, %iter_reg
+    EXPAND VEC_DEQUE_INTO_ITER_COLLECT_INTO_U64 %vec_reg, %iter_reg
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INTO_ITER_COPIED_COLLECT_U64 %out_vec, %iter_reg
+    EXPAND VEC_DEQUE_ITER_COPIED_COLLECT_U64 %out_vec, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_INTO_ITER_COPIED_COLLECT_U64.
+[MACRO] VEC_DEQUE_INTO_ITER_COPIED_COLLECT %out_vec, %iter_reg
+    EXPAND VEC_DEQUE_INTO_ITER_COPIED_COLLECT_U64 %out_vec, %iter_reg
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INTO_ITER_CLONED_COLLECT_U64 %out_vec, %iter_reg
+    EXPAND VEC_DEQUE_ITER_CLONED_COLLECT_U64 %out_vec, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_INTO_ITER_CLONED_COLLECT_U64.
+[MACRO] VEC_DEQUE_INTO_ITER_CLONED_COLLECT %out_vec, %iter_reg
+    EXPAND VEC_DEQUE_INTO_ITER_CLONED_COLLECT_U64 %out_vec, %iter_reg
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INTO_ITER_TAKE_COLLECT_U64 %out_vec, %iter_reg, %count
+    EXPAND VEC_DEQUE_ITER_TAKE_COLLECT_U64 %out_vec, %iter_reg, %count
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_INTO_ITER_TAKE_COLLECT_U64.
+[MACRO] VEC_DEQUE_INTO_ITER_TAKE_COLLECT %out_vec, %iter_reg, %count
+    EXPAND VEC_DEQUE_INTO_ITER_TAKE_COLLECT_U64 %out_vec, %iter_reg, %count
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INTO_ITER_SKIP_COLLECT_U64 %out_vec, %iter_reg, %count
+    EXPAND VEC_DEQUE_ITER_SKIP_COLLECT_U64 %out_vec, %iter_reg, %count
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_INTO_ITER_SKIP_COLLECT_U64.
+[MACRO] VEC_DEQUE_INTO_ITER_SKIP_COLLECT %out_vec, %iter_reg, %count
+    EXPAND VEC_DEQUE_INTO_ITER_SKIP_COLLECT_U64 %out_vec, %iter_reg, %count
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INTO_ITER_REV_COLLECT_U64 %out_vec, %iter_reg
+    EXPAND VEC_DEQUE_ITER_REV_COLLECT_U64 %out_vec, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_INTO_ITER_REV_COLLECT_U64.
+[MACRO] VEC_DEQUE_INTO_ITER_REV_COLLECT %out_vec, %iter_reg
+    EXPAND VEC_DEQUE_INTO_ITER_REV_COLLECT_U64 %out_vec, %iter_reg
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INTO_ITER_TRY_STEP_BY_COLLECT_U64 %out_ok, %out_vec, %iter_reg, %step
+    EXPAND VEC_DEQUE_ITER_TRY_STEP_BY_COLLECT_U64 %out_ok, %out_vec, %iter_reg, %step
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_INTO_ITER_TRY_STEP_BY_COLLECT_U64.
+[MACRO] VEC_DEQUE_INTO_ITER_TRY_STEP_BY_COLLECT %out_ok, %out_vec, %iter_reg, %step
+    EXPAND VEC_DEQUE_INTO_ITER_TRY_STEP_BY_COLLECT_U64 %out_ok, %out_vec, %iter_reg, %step
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INTO_ITER_STEP_BY_COLLECT_U64 %out_vec, %iter_reg, %step
+    EXPAND VEC_DEQUE_ITER_STEP_BY_COLLECT_U64 %out_vec, %iter_reg, %step
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_INTO_ITER_STEP_BY_COLLECT_U64.
+[MACRO] VEC_DEQUE_INTO_ITER_STEP_BY_COLLECT %out_vec, %iter_reg, %step
+    EXPAND VEC_DEQUE_INTO_ITER_STEP_BY_COLLECT_U64 %out_vec, %iter_reg, %step
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INTO_ITER_MAP_COLLECT_U64 %out_vec, %iter_reg, %map_fn
+    EXPAND VEC_DEQUE_ITER_MAP_COLLECT_U64 %out_vec, %iter_reg, %map_fn
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_INTO_ITER_MAP_COLLECT_U64.
+[MACRO] VEC_DEQUE_INTO_ITER_MAP_COLLECT %out_vec, %iter_reg, %map_fn
+    EXPAND VEC_DEQUE_INTO_ITER_MAP_COLLECT_U64 %out_vec, %iter_reg, %map_fn
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INTO_ITER_INSPECT_COLLECT_U64 %out_vec, %iter_reg, %inspect_fn
+    EXPAND VEC_DEQUE_ITER_INSPECT_COLLECT_U64 %out_vec, %iter_reg, %inspect_fn
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_INTO_ITER_INSPECT_COLLECT_U64.
+[MACRO] VEC_DEQUE_INTO_ITER_INSPECT_COLLECT %out_vec, %iter_reg, %inspect_fn
+    EXPAND VEC_DEQUE_INTO_ITER_INSPECT_COLLECT_U64 %out_vec, %iter_reg, %inspect_fn
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INTO_ITER_SCAN_COLLECT_U64 %out_vec, %iter_reg, %initial_state, %scan_fn
+    EXPAND VEC_DEQUE_ITER_SCAN_COLLECT_U64 %out_vec, %iter_reg, %initial_state, %scan_fn
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_INTO_ITER_SCAN_COLLECT_U64.
+[MACRO] VEC_DEQUE_INTO_ITER_SCAN_COLLECT %out_vec, %iter_reg, %initial_state, %scan_fn
+    EXPAND VEC_DEQUE_INTO_ITER_SCAN_COLLECT_U64 %out_vec, %iter_reg, %initial_state, %scan_fn
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INTO_ITER_FILTER_COLLECT_U64 %out_vec, %iter_reg, %pred_fn
+    EXPAND VEC_DEQUE_ITER_FILTER_COLLECT_U64 %out_vec, %iter_reg, %pred_fn
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_INTO_ITER_FILTER_COLLECT_U64.
+[MACRO] VEC_DEQUE_INTO_ITER_FILTER_COLLECT %out_vec, %iter_reg, %pred_fn
+    EXPAND VEC_DEQUE_INTO_ITER_FILTER_COLLECT_U64 %out_vec, %iter_reg, %pred_fn
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INTO_ITER_FILTER_MAP_COLLECT_U64 %out_vec, %iter_reg, %map_fn
+    EXPAND VEC_DEQUE_ITER_FILTER_MAP_COLLECT_U64 %out_vec, %iter_reg, %map_fn
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_INTO_ITER_FILTER_MAP_COLLECT_U64.
+[MACRO] VEC_DEQUE_INTO_ITER_FILTER_MAP_COLLECT %out_vec, %iter_reg, %map_fn
+    EXPAND VEC_DEQUE_INTO_ITER_FILTER_MAP_COLLECT_U64 %out_vec, %iter_reg, %map_fn
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INTO_ITER_MAP_WHILE_COLLECT_U64 %out_vec, %iter_reg, %map_fn
+    EXPAND VEC_DEQUE_ITER_MAP_WHILE_COLLECT_U64 %out_vec, %iter_reg, %map_fn
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_INTO_ITER_MAP_WHILE_COLLECT_U64.
+[MACRO] VEC_DEQUE_INTO_ITER_MAP_WHILE_COLLECT %out_vec, %iter_reg, %map_fn
+    EXPAND VEC_DEQUE_INTO_ITER_MAP_WHILE_COLLECT_U64 %out_vec, %iter_reg, %map_fn
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INTO_ITER_INTERSPERSE_COLLECT_U64 %out_vec, %iter_reg, %separator
+    EXPAND VEC_DEQUE_ITER_INTERSPERSE_COLLECT_U64 %out_vec, %iter_reg, %separator
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_INTO_ITER_INTERSPERSE_COLLECT_U64.
+[MACRO] VEC_DEQUE_INTO_ITER_INTERSPERSE_COLLECT %out_vec, %iter_reg, %separator
+    EXPAND VEC_DEQUE_INTO_ITER_INTERSPERSE_COLLECT_U64 %out_vec, %iter_reg, %separator
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INTO_ITER_INTERSPERSE_WITH_COLLECT_U64 %out_vec, %iter_reg, %sep_fn
+    EXPAND VEC_DEQUE_ITER_INTERSPERSE_WITH_COLLECT_U64 %out_vec, %iter_reg, %sep_fn
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_INTO_ITER_INTERSPERSE_WITH_COLLECT_U64.
+[MACRO] VEC_DEQUE_INTO_ITER_INTERSPERSE_WITH_COLLECT %out_vec, %iter_reg, %sep_fn
+    EXPAND VEC_DEQUE_INTO_ITER_INTERSPERSE_WITH_COLLECT_U64 %out_vec, %iter_reg, %sep_fn
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INTO_ITER_CYCLE_TAKE_COLLECT_U64 %out_vec, %iter_reg, %count
+    EXPAND VEC_DEQUE_ITER_CYCLE_TAKE_COLLECT_U64 %out_vec, %iter_reg, %count
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_INTO_ITER_CYCLE_TAKE_COLLECT_U64.
+[MACRO] VEC_DEQUE_INTO_ITER_CYCLE_TAKE_COLLECT %out_vec, %iter_reg, %count
+    EXPAND VEC_DEQUE_INTO_ITER_CYCLE_TAKE_COLLECT_U64 %out_vec, %iter_reg, %count
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INTO_ITER_TAKE_WHILE_COLLECT_U64 %out_vec, %iter_reg, %pred_fn
+    EXPAND VEC_DEQUE_ITER_TAKE_WHILE_COLLECT_U64 %out_vec, %iter_reg, %pred_fn
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_INTO_ITER_TAKE_WHILE_COLLECT_U64.
+[MACRO] VEC_DEQUE_INTO_ITER_TAKE_WHILE_COLLECT %out_vec, %iter_reg, %pred_fn
+    EXPAND VEC_DEQUE_INTO_ITER_TAKE_WHILE_COLLECT_U64 %out_vec, %iter_reg, %pred_fn
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INTO_ITER_SKIP_WHILE_COLLECT_U64 %out_vec, %iter_reg, %pred_fn
+    EXPAND VEC_DEQUE_ITER_SKIP_WHILE_COLLECT_U64 %out_vec, %iter_reg, %pred_fn
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_INTO_ITER_SKIP_WHILE_COLLECT_U64.
+[MACRO] VEC_DEQUE_INTO_ITER_SKIP_WHILE_COLLECT %out_vec, %iter_reg, %pred_fn
+    EXPAND VEC_DEQUE_INTO_ITER_SKIP_WHILE_COLLECT_U64 %out_vec, %iter_reg, %pred_fn
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INTO_ITER_ENUMERATE_COLLECT_U64 %out_vec, %iter_reg
+    EXPAND VEC_DEQUE_ITER_ENUMERATE_COLLECT_U64 %out_vec, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_INTO_ITER_ENUMERATE_COLLECT_U64.
+[MACRO] VEC_DEQUE_INTO_ITER_ENUMERATE_COLLECT %out_vec, %iter_reg
+    EXPAND VEC_DEQUE_INTO_ITER_ENUMERATE_COLLECT_U64 %out_vec, %iter_reg
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INTO_ITER_ZIP_COLLECT_U64 %out_vec, %left_iter, %right_iter
+    EXPAND VEC_DEQUE_ITER_ZIP_COLLECT_U64 %out_vec, %left_iter, %right_iter
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_INTO_ITER_ZIP_COLLECT_U64.
+[MACRO] VEC_DEQUE_INTO_ITER_ZIP_COLLECT %out_vec, %left_iter, %right_iter
+    EXPAND VEC_DEQUE_INTO_ITER_ZIP_COLLECT_U64 %out_vec, %left_iter, %right_iter
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INTO_ITER_CHAIN_COLLECT_U64 %out_vec, %left_iter, %right_iter
+    EXPAND VEC_DEQUE_ITER_CHAIN_COLLECT_U64 %out_vec, %left_iter, %right_iter
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_INTO_ITER_CHAIN_COLLECT_U64.
+[MACRO] VEC_DEQUE_INTO_ITER_CHAIN_COLLECT %out_vec, %left_iter, %right_iter
+    EXPAND VEC_DEQUE_INTO_ITER_CHAIN_COLLECT_U64 %out_vec, %left_iter, %right_iter
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INTO_ITER_BY_REF_COLLECT_U64 %out_vec, %iter_reg
+    EXPAND VEC_DEQUE_ITER_BY_REF_COLLECT_U64 %out_vec, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_INTO_ITER_BY_REF_COLLECT_U64.
+[MACRO] VEC_DEQUE_INTO_ITER_BY_REF_COLLECT %out_vec, %iter_reg
+    EXPAND VEC_DEQUE_INTO_ITER_BY_REF_COLLECT_U64 %out_vec, %iter_reg
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INTO_ITER_FUSE_COLLECT_U64 %out_vec, %iter_reg
+    EXPAND VEC_DEQUE_ITER_FUSE_COLLECT_U64 %out_vec, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_INTO_ITER_FUSE_COLLECT_U64.
+[MACRO] VEC_DEQUE_INTO_ITER_FUSE_COLLECT %out_vec, %iter_reg
+    EXPAND VEC_DEQUE_INTO_ITER_FUSE_COLLECT_U64 %out_vec, %iter_reg
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INTO_ITER_PEEKABLE_COLLECT_U64 %out_vec, %iter_reg
+    EXPAND VEC_DEQUE_ITER_PEEKABLE_COLLECT_U64 %out_vec, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_INTO_ITER_PEEKABLE_COLLECT_U64.
+[MACRO] VEC_DEQUE_INTO_ITER_PEEKABLE_COLLECT %out_vec, %iter_reg
+    EXPAND VEC_DEQUE_INTO_ITER_PEEKABLE_COLLECT_U64 %out_vec, %iter_reg
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INTO_ITER_ARRAY_CHUNKS_COLLECT_U64 %out_ok, %out_vec, %iter_reg, %chunk_size
+    EXPAND VEC_DEQUE_ITER_ARRAY_CHUNKS_COLLECT_U64 %out_ok, %out_vec, %iter_reg, %chunk_size
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_INTO_ITER_ARRAY_CHUNKS_COLLECT_U64.
+[MACRO] VEC_DEQUE_INTO_ITER_ARRAY_CHUNKS_COLLECT %out_ok, %out_vec, %iter_reg, %chunk_size
+    EXPAND VEC_DEQUE_INTO_ITER_ARRAY_CHUNKS_COLLECT_U64 %out_ok, %out_vec, %iter_reg, %chunk_size
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INTO_ITER_MAP_WINDOWS_COLLECT_U64 %out_ok, %out_vec, %iter_reg, %window_size, %map_fn
+    EXPAND VEC_DEQUE_ITER_MAP_WINDOWS_COLLECT_U64 %out_ok, %out_vec, %iter_reg, %window_size, %map_fn
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_INTO_ITER_MAP_WINDOWS_COLLECT_U64.
+[MACRO] VEC_DEQUE_INTO_ITER_MAP_WINDOWS_COLLECT %out_ok, %out_vec, %iter_reg, %window_size, %map_fn
+    EXPAND VEC_DEQUE_INTO_ITER_MAP_WINDOWS_COLLECT_U64 %out_ok, %out_vec, %iter_reg, %window_size, %map_fn
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_RESERVE %deque_reg, %additional
+    call @sa_vec_deque_reserve(&%deque_reg, %additional)
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_RESERVE_EXACT %deque_reg, %additional
+    call @sa_vec_deque_reserve_exact(&%deque_reg, %additional)
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_TRY_RESERVE %out_ok, %deque_reg, %additional
+    %out_ok = call @sa_vec_deque_try_reserve(&%deque_reg, %additional)
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_TRY_RESERVE_EXACT %out_ok, %deque_reg, %additional
+    %out_ok = call @sa_vec_deque_try_reserve_exact(&%deque_reg, %additional)
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_TRY_SHRINK_TO %out_ok, %deque_reg, %min_capacity
+    %out_ok = call @sa_vec_deque_try_shrink_to(&%deque_reg, %min_capacity)
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_TRY_SHRINK_TO_FIT %out_ok, %deque_reg
+    %out_ok = call @sa_vec_deque_try_shrink_to_fit(&%deque_reg)
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_SHRINK_TO %deque_reg, %min_capacity
+    call @sa_vec_deque_shrink_to(&%deque_reg, %min_capacity)
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_SHRINK_TO_FIT %deque_reg
+    call @sa_vec_deque_shrink_to_fit(&%deque_reg)
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_AS_SLICES %out_front_slice, %out_back_slice, %deque_reg
+    %out_front_slice = alloc Slice_SIZE
+    %out_back_slice = alloc Slice_SIZE
+    call @sa_vec_deque_as_slices(&%deque_reg, &%out_front_slice, &%out_back_slice)
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_AS_MUT_SLICES %out_front_slice, %out_back_slice, %deque_reg
+    %out_front_slice = alloc Slice_SIZE
+    %out_back_slice = alloc Slice_SIZE
+    call @sa_vec_deque_as_mut_slices(&%deque_reg, &%out_front_slice, &%out_back_slice)
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_MAKE_CONTIGUOUS %out_slice, %deque_reg
+    %out_slice = alloc Slice_SIZE
+    call @sa_vec_deque_make_contiguous(&%deque_reg, &%out_slice)
+[END_MACRO]
+
+[MACRO] DEFAULT_HASHER_WRITE_VEC_DEQUE_U64 %hasher, %deque_reg
+    EXPAND VEC_DEQUE_MAKE_CONTIGUOUS __vec_deque_hash_slice_%hasher, %deque_reg
+    EXPAND DEFAULT_HASHER_WRITE_SLICE_U64 %hasher, __vec_deque_hash_slice_%hasher
+    !__vec_deque_hash_slice_%hasher
+[END_MACRO]
+
+// Rust method-name alias over DEFAULT_HASHER_WRITE_VEC_DEQUE_U64.
+[MACRO] DEFAULT_HASHER_WRITE_VEC_DEQUE %hasher, %deque_reg
+    EXPAND DEFAULT_HASHER_WRITE_VEC_DEQUE_U64 %hasher, %deque_reg
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_HASH_U64 %out_hash, %deque_reg
+    __vec_deque_hash_hasher_%out_hash = stack_alloc DefaultHasher_SIZE
+    EXPAND DEFAULT_HASHER_NEW __vec_deque_hash_hasher_%out_hash
+    EXPAND DEFAULT_HASHER_WRITE_VEC_DEQUE_U64 __vec_deque_hash_hasher_%out_hash, %deque_reg
+    EXPAND DEFAULT_HASHER_FINISH %out_hash, __vec_deque_hash_hasher_%out_hash
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_HASH_U64.
+[MACRO] VEC_DEQUE_HASH %out_hash, %deque_reg
+    EXPAND VEC_DEQUE_HASH_U64 %out_hash, %deque_reg
+[END_MACRO]
+
+[MACRO] BUILD_HASHER_DEFAULT_HASH_ONE_VEC_DEQUE_U64 %out_hash, %builder, %deque_reg
+    __build_hash_one_vec_deque_u64_hasher_%out_hash = stack_alloc DefaultHasher_SIZE
+    EXPAND BUILD_HASHER_DEFAULT_BUILD __build_hash_one_vec_deque_u64_hasher_%out_hash, %builder
+    EXPAND DEFAULT_HASHER_WRITE_VEC_DEQUE_U64 __build_hash_one_vec_deque_u64_hasher_%out_hash, %deque_reg
+    EXPAND DEFAULT_HASHER_FINISH %out_hash, __build_hash_one_vec_deque_u64_hasher_%out_hash
+[END_MACRO]
+
+// Rust method-name alias over BUILD_HASHER_DEFAULT_HASH_ONE_VEC_DEQUE_U64.
+[MACRO] BUILD_HASHER_DEFAULT_HASH_ONE_VEC_DEQUE %out_hash, %builder, %deque_reg
+    EXPAND BUILD_HASHER_DEFAULT_HASH_ONE_VEC_DEQUE_U64 %out_hash, %builder, %deque_reg
+[END_MACRO]
+
+[MACRO] RANDOM_STATE_HASH_ONE_VEC_DEQUE_U64 %out_hash, %state, %deque_reg
+    __random_state_hash_one_vec_deque_u64_hasher_%out_hash = stack_alloc DefaultHasher_SIZE
+    EXPAND RANDOM_STATE_BUILD __random_state_hash_one_vec_deque_u64_hasher_%out_hash, %state
+    EXPAND DEFAULT_HASHER_WRITE_VEC_DEQUE_U64 __random_state_hash_one_vec_deque_u64_hasher_%out_hash, %deque_reg
+    EXPAND DEFAULT_HASHER_FINISH %out_hash, __random_state_hash_one_vec_deque_u64_hasher_%out_hash
+[END_MACRO]
+
+// Rust method-name alias over RANDOM_STATE_HASH_ONE_VEC_DEQUE_U64.
+[MACRO] RANDOM_STATE_HASH_ONE_VEC_DEQUE %out_hash, %state, %deque_reg
+    EXPAND RANDOM_STATE_HASH_ONE_VEC_DEQUE_U64 %out_hash, %state, %deque_reg
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_RETAIN_U64 %out_len, %deque_reg, %pred_fn
+    call @vec_deque_force_contiguous(&%deque_reg)
+    __vec_deque_retain_view_%out_len = & %deque_reg
+    __vec_deque_retain_ptr_%out_len = load __vec_deque_retain_view_%out_len+VecDeque_buf as ptr
+    __vec_deque_retain_len_%out_len = load __vec_deque_retain_view_%out_len+VecDeque_len as u64
+    __vec_deque_retain_read_slot_%out_len = stack_alloc 8
+    __vec_deque_retain_write_slot_%out_len = stack_alloc 8
+    store __vec_deque_retain_read_slot_%out_len+0, 0 as u64
+    store __vec_deque_retain_write_slot_%out_len+0, 0 as u64
+    jmp L_VEC_DEQUE_RETAIN_HEAD_%out_len
+
+L_VEC_DEQUE_RETAIN_HEAD_%out_len:
+    __vec_deque_retain_read_%out_len = load __vec_deque_retain_read_slot_%out_len+0 as u64
+    __vec_deque_retain_done_%out_len = eq __vec_deque_retain_read_%out_len, __vec_deque_retain_len_%out_len
+    br __vec_deque_retain_done_%out_len -> L_VEC_DEQUE_RETAIN_DONE_%out_len, L_VEC_DEQUE_RETAIN_BODY_%out_len
+
+L_VEC_DEQUE_RETAIN_BODY_%out_len:
+    __vec_deque_retain_read_off_%out_len = mul __vec_deque_retain_read_%out_len, VecDeque_SLOT_SIZE
+    __vec_deque_retain_read_ptr_%out_len = ptr_add __vec_deque_retain_ptr_%out_len, __vec_deque_retain_read_off_%out_len
+    __vec_deque_retain_value_%out_len = load __vec_deque_retain_read_ptr_%out_len+0 as u64
+    __vec_deque_retain_pred_%out_len = call %pred_fn(__vec_deque_retain_value_%out_len)
+    __vec_deque_retain_keep_%out_len = ne __vec_deque_retain_pred_%out_len, 0
+    br __vec_deque_retain_keep_%out_len -> L_VEC_DEQUE_RETAIN_KEEP_%out_len, L_VEC_DEQUE_RETAIN_SKIP_%out_len
+
+L_VEC_DEQUE_RETAIN_KEEP_%out_len:
+    __vec_deque_retain_write_%out_len = load __vec_deque_retain_write_slot_%out_len+0 as u64
+    __vec_deque_retain_write_off_%out_len = mul __vec_deque_retain_write_%out_len, VecDeque_SLOT_SIZE
+    __vec_deque_retain_write_ptr_%out_len = ptr_add __vec_deque_retain_ptr_%out_len, __vec_deque_retain_write_off_%out_len
+    store __vec_deque_retain_write_ptr_%out_len+0, __vec_deque_retain_value_%out_len as u64
+    __vec_deque_retain_next_write_%out_len = add __vec_deque_retain_write_%out_len, 1
+    store __vec_deque_retain_write_slot_%out_len+0, __vec_deque_retain_next_write_%out_len as u64
+    !__vec_deque_retain_next_write_%out_len
+    !__vec_deque_retain_write_ptr_%out_len
+    !__vec_deque_retain_write_off_%out_len
+    !__vec_deque_retain_write_%out_len
+    jmp L_VEC_DEQUE_RETAIN_NEXT_%out_len
+
+L_VEC_DEQUE_RETAIN_SKIP_%out_len:
+    jmp L_VEC_DEQUE_RETAIN_NEXT_%out_len
+
+L_VEC_DEQUE_RETAIN_NEXT_%out_len:
+    __vec_deque_retain_next_read_%out_len = add __vec_deque_retain_read_%out_len, 1
+    store __vec_deque_retain_read_slot_%out_len+0, __vec_deque_retain_next_read_%out_len as u64
+    !__vec_deque_retain_next_read_%out_len
+    !__vec_deque_retain_keep_%out_len
+    !__vec_deque_retain_pred_%out_len
+    !__vec_deque_retain_value_%out_len
+    !__vec_deque_retain_read_ptr_%out_len
+    !__vec_deque_retain_read_off_%out_len
+    !__vec_deque_retain_done_%out_len
+    !__vec_deque_retain_read_%out_len
+    jmp L_VEC_DEQUE_RETAIN_HEAD_%out_len
+
+L_VEC_DEQUE_RETAIN_DONE_%out_len:
+    %out_len = load __vec_deque_retain_write_slot_%out_len+0 as u64
+    store __vec_deque_retain_view_%out_len+VecDeque_len, %out_len as u64
+    store __vec_deque_retain_view_%out_len+VecDeque_head, 0 as u64
+    !__vec_deque_retain_done_%out_len
+    !__vec_deque_retain_read_%out_len
+    !__vec_deque_retain_len_%out_len
+    !__vec_deque_retain_ptr_%out_len
+    !__vec_deque_retain_view_%out_len
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_RETAIN_MUT_U64 %out_len, %deque_reg, %pred_fn
+    call @vec_deque_force_contiguous(&%deque_reg)
+    __vec_deque_retain_mut_view_%out_len = & %deque_reg
+    __vec_deque_retain_mut_ptr_%out_len = load __vec_deque_retain_mut_view_%out_len+VecDeque_buf as ptr
+    __vec_deque_retain_mut_len_%out_len = load __vec_deque_retain_mut_view_%out_len+VecDeque_len as u64
+    __vec_deque_retain_mut_read_slot_%out_len = stack_alloc 8
+    __vec_deque_retain_mut_write_slot_%out_len = stack_alloc 8
+    store __vec_deque_retain_mut_read_slot_%out_len+0, 0 as u64
+    store __vec_deque_retain_mut_write_slot_%out_len+0, 0 as u64
+    jmp L_VEC_DEQUE_RETAIN_MUT_HEAD_%out_len
+
+L_VEC_DEQUE_RETAIN_MUT_HEAD_%out_len:
+    __vec_deque_retain_mut_read_%out_len = load __vec_deque_retain_mut_read_slot_%out_len+0 as u64
+    __vec_deque_retain_mut_done_%out_len = eq __vec_deque_retain_mut_read_%out_len, __vec_deque_retain_mut_len_%out_len
+    br __vec_deque_retain_mut_done_%out_len -> L_VEC_DEQUE_RETAIN_MUT_DONE_%out_len, L_VEC_DEQUE_RETAIN_MUT_BODY_%out_len
+
+L_VEC_DEQUE_RETAIN_MUT_BODY_%out_len:
+    __vec_deque_retain_mut_read_off_%out_len = mul __vec_deque_retain_mut_read_%out_len, VecDeque_SLOT_SIZE
+    __vec_deque_retain_mut_read_ptr_%out_len = ptr_add __vec_deque_retain_mut_ptr_%out_len, __vec_deque_retain_mut_read_off_%out_len
+    __vec_deque_retain_mut_pred_%out_len = call %pred_fn(__vec_deque_retain_mut_read_ptr_%out_len)
+    __vec_deque_retain_mut_keep_%out_len = ne __vec_deque_retain_mut_pred_%out_len, 0
+    br __vec_deque_retain_mut_keep_%out_len -> L_VEC_DEQUE_RETAIN_MUT_KEEP_%out_len, L_VEC_DEQUE_RETAIN_MUT_SKIP_%out_len
+
+L_VEC_DEQUE_RETAIN_MUT_KEEP_%out_len:
+    __vec_deque_retain_mut_value_%out_len = load __vec_deque_retain_mut_read_ptr_%out_len+0 as u64
+    __vec_deque_retain_mut_write_%out_len = load __vec_deque_retain_mut_write_slot_%out_len+0 as u64
+    __vec_deque_retain_mut_write_off_%out_len = mul __vec_deque_retain_mut_write_%out_len, VecDeque_SLOT_SIZE
+    __vec_deque_retain_mut_write_ptr_%out_len = ptr_add __vec_deque_retain_mut_ptr_%out_len, __vec_deque_retain_mut_write_off_%out_len
+    store __vec_deque_retain_mut_write_ptr_%out_len+0, __vec_deque_retain_mut_value_%out_len as u64
+    __vec_deque_retain_mut_next_write_%out_len = add __vec_deque_retain_mut_write_%out_len, 1
+    store __vec_deque_retain_mut_write_slot_%out_len+0, __vec_deque_retain_mut_next_write_%out_len as u64
+    !__vec_deque_retain_mut_next_write_%out_len
+    !__vec_deque_retain_mut_write_ptr_%out_len
+    !__vec_deque_retain_mut_write_off_%out_len
+    !__vec_deque_retain_mut_write_%out_len
+    !__vec_deque_retain_mut_value_%out_len
+    jmp L_VEC_DEQUE_RETAIN_MUT_NEXT_%out_len
+
+L_VEC_DEQUE_RETAIN_MUT_SKIP_%out_len:
+    jmp L_VEC_DEQUE_RETAIN_MUT_NEXT_%out_len
+
+L_VEC_DEQUE_RETAIN_MUT_NEXT_%out_len:
+    __vec_deque_retain_mut_next_read_%out_len = add __vec_deque_retain_mut_read_%out_len, 1
+    store __vec_deque_retain_mut_read_slot_%out_len+0, __vec_deque_retain_mut_next_read_%out_len as u64
+    !__vec_deque_retain_mut_next_read_%out_len
+    !__vec_deque_retain_mut_keep_%out_len
+    !__vec_deque_retain_mut_pred_%out_len
+    !__vec_deque_retain_mut_read_ptr_%out_len
+    !__vec_deque_retain_mut_read_off_%out_len
+    !__vec_deque_retain_mut_done_%out_len
+    !__vec_deque_retain_mut_read_%out_len
+    jmp L_VEC_DEQUE_RETAIN_MUT_HEAD_%out_len
+
+L_VEC_DEQUE_RETAIN_MUT_DONE_%out_len:
+    %out_len = load __vec_deque_retain_mut_write_slot_%out_len+0 as u64
+    store __vec_deque_retain_mut_view_%out_len+VecDeque_len, %out_len as u64
+    store __vec_deque_retain_mut_view_%out_len+VecDeque_head, 0 as u64
+    !__vec_deque_retain_mut_done_%out_len
+    !__vec_deque_retain_mut_read_%out_len
+    !__vec_deque_retain_mut_len_%out_len
+    !__vec_deque_retain_mut_ptr_%out_len
+    !__vec_deque_retain_mut_view_%out_len
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_RETAIN %out_len, %deque_reg, %pred_fn
+    EXPAND VEC_DEQUE_RETAIN_U64 %out_len, %deque_reg, %pred_fn
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_RETAIN_MUT %out_len, %deque_reg, %pred_fn
+    EXPAND VEC_DEQUE_RETAIN_MUT_U64 %out_len, %deque_reg, %pred_fn
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_EXTRACT_IF_U64 %out_len, %out_vec, %deque_reg, %pred_fn
+    call @vec_deque_force_contiguous(&%deque_reg)
+    __vec_deque_extract_view_%out_len = & %deque_reg
+    __vec_deque_extract_ptr_%out_len = load __vec_deque_extract_view_%out_len+VecDeque_buf as ptr
+    __vec_deque_extract_len_%out_len = load __vec_deque_extract_view_%out_len+VecDeque_len as u64
+    EXPAND VEC_WITH_CAPACITY_U64 %out_vec, __vec_deque_extract_len_%out_len
+    __vec_deque_extract_read_slot_%out_len = stack_alloc 8
+    __vec_deque_extract_write_slot_%out_len = stack_alloc 8
+    store __vec_deque_extract_read_slot_%out_len+0, 0 as u64
+    store __vec_deque_extract_write_slot_%out_len+0, 0 as u64
+    jmp L_VEC_DEQUE_EXTRACT_HEAD_%out_len
+
+L_VEC_DEQUE_EXTRACT_HEAD_%out_len:
+    __vec_deque_extract_read_%out_len = load __vec_deque_extract_read_slot_%out_len+0 as u64
+    __vec_deque_extract_done_%out_len = eq __vec_deque_extract_read_%out_len, __vec_deque_extract_len_%out_len
+    br __vec_deque_extract_done_%out_len -> L_VEC_DEQUE_EXTRACT_DONE_%out_len, L_VEC_DEQUE_EXTRACT_BODY_%out_len
+
+L_VEC_DEQUE_EXTRACT_BODY_%out_len:
+    __vec_deque_extract_read_off_%out_len = mul __vec_deque_extract_read_%out_len, VecDeque_SLOT_SIZE
+    __vec_deque_extract_read_ptr_%out_len = ptr_add __vec_deque_extract_ptr_%out_len, __vec_deque_extract_read_off_%out_len
+    __vec_deque_extract_value_%out_len = load __vec_deque_extract_read_ptr_%out_len+0 as u64
+    __vec_deque_extract_pred_%out_len = call %pred_fn(__vec_deque_extract_value_%out_len)
+    __vec_deque_extract_take_%out_len = ne __vec_deque_extract_pred_%out_len, 0
+    br __vec_deque_extract_take_%out_len -> L_VEC_DEQUE_EXTRACT_TAKE_%out_len, L_VEC_DEQUE_EXTRACT_KEEP_%out_len
+
+L_VEC_DEQUE_EXTRACT_TAKE_%out_len:
+    EXPAND VEC_PUSH_U64 %out_vec, __vec_deque_extract_value_%out_len
+    jmp L_VEC_DEQUE_EXTRACT_NEXT_%out_len
+
+L_VEC_DEQUE_EXTRACT_KEEP_%out_len:
+    __vec_deque_extract_write_%out_len = load __vec_deque_extract_write_slot_%out_len+0 as u64
+    __vec_deque_extract_write_off_%out_len = mul __vec_deque_extract_write_%out_len, VecDeque_SLOT_SIZE
+    __vec_deque_extract_write_ptr_%out_len = ptr_add __vec_deque_extract_ptr_%out_len, __vec_deque_extract_write_off_%out_len
+    store __vec_deque_extract_write_ptr_%out_len+0, __vec_deque_extract_value_%out_len as u64
+    __vec_deque_extract_next_write_%out_len = add __vec_deque_extract_write_%out_len, 1
+    store __vec_deque_extract_write_slot_%out_len+0, __vec_deque_extract_next_write_%out_len as u64
+    !__vec_deque_extract_next_write_%out_len
+    !__vec_deque_extract_write_ptr_%out_len
+    !__vec_deque_extract_write_off_%out_len
+    !__vec_deque_extract_write_%out_len
+    jmp L_VEC_DEQUE_EXTRACT_NEXT_%out_len
+
+L_VEC_DEQUE_EXTRACT_NEXT_%out_len:
+    __vec_deque_extract_next_read_%out_len = add __vec_deque_extract_read_%out_len, 1
+    store __vec_deque_extract_read_slot_%out_len+0, __vec_deque_extract_next_read_%out_len as u64
+    !__vec_deque_extract_next_read_%out_len
+    !__vec_deque_extract_take_%out_len
+    !__vec_deque_extract_pred_%out_len
+    !__vec_deque_extract_value_%out_len
+    !__vec_deque_extract_read_ptr_%out_len
+    !__vec_deque_extract_read_off_%out_len
+    !__vec_deque_extract_done_%out_len
+    !__vec_deque_extract_read_%out_len
+    jmp L_VEC_DEQUE_EXTRACT_HEAD_%out_len
+
+L_VEC_DEQUE_EXTRACT_DONE_%out_len:
+    %out_len = load __vec_deque_extract_write_slot_%out_len+0 as u64
+    store __vec_deque_extract_view_%out_len+VecDeque_len, %out_len as u64
+    store __vec_deque_extract_view_%out_len+VecDeque_head, 0 as u64
+    !__vec_deque_extract_done_%out_len
+    !__vec_deque_extract_read_%out_len
+    !__vec_deque_extract_len_%out_len
+    !__vec_deque_extract_ptr_%out_len
+    !__vec_deque_extract_view_%out_len
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_EXTRACT_IF %out_len, %out_vec, %deque_reg, %pred_fn
+    EXPAND VEC_DEQUE_EXTRACT_IF_U64 %out_len, %out_vec, %deque_reg, %pred_fn
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_SPLICE_U64 %out_ok, %out_vec, %deque_reg, %start, %length, %replacement_slice
+    EXPAND VEC_DEQUE_MAKE_CONTIGUOUS __vec_deque_splice_slice_%out_ok, %deque_reg
+    EXPAND VEC_FROM_SLICE_U64 __vec_deque_splice_vec_%out_ok, __vec_deque_splice_slice_%out_ok
+    EXPAND VEC_SPLICE_U64 %out_ok, %out_vec, __vec_deque_splice_vec_%out_ok, %start, %length, %replacement_slice
+    __vec_deque_splice_hit_%out_ok = ne %out_ok, 0
+    br __vec_deque_splice_hit_%out_ok -> L_VEC_DEQUE_SPLICE_REBUILD_%out_ok, L_VEC_DEQUE_SPLICE_MISS_%out_ok
+
+L_VEC_DEQUE_SPLICE_REBUILD_%out_ok:
+    EXPAND VEC_DEQUE_CLEAR %deque_reg
+    EXPAND VEC_LEN __vec_deque_splice_new_len_%out_ok, __vec_deque_splice_vec_%out_ok
+    __vec_deque_splice_idx_slot_%out_ok = stack_alloc 8
+    store __vec_deque_splice_idx_slot_%out_ok+0, 0 as u64
+    jmp L_VEC_DEQUE_SPLICE_COPY_HEAD_%out_ok
+
+L_VEC_DEQUE_SPLICE_COPY_HEAD_%out_ok:
+    __vec_deque_splice_idx_%out_ok = load __vec_deque_splice_idx_slot_%out_ok+0 as u64
+    __vec_deque_splice_copy_done_%out_ok = eq __vec_deque_splice_idx_%out_ok, __vec_deque_splice_new_len_%out_ok
+    br __vec_deque_splice_copy_done_%out_ok -> L_VEC_DEQUE_SPLICE_COPY_END_%out_ok, L_VEC_DEQUE_SPLICE_COPY_BODY_%out_ok
+
+L_VEC_DEQUE_SPLICE_COPY_BODY_%out_ok:
+    EXPAND VEC_GET_U64 __vec_deque_splice_value_%out_ok, __vec_deque_splice_vec_%out_ok, __vec_deque_splice_idx_%out_ok
+    EXPAND VEC_DEQUE_PUSH_BACK %deque_reg, __vec_deque_splice_value_%out_ok
+    __vec_deque_splice_next_%out_ok = add __vec_deque_splice_idx_%out_ok, 1
+    store __vec_deque_splice_idx_slot_%out_ok+0, __vec_deque_splice_next_%out_ok as u64
+    !__vec_deque_splice_next_%out_ok
+    !__vec_deque_splice_value_%out_ok
+    !__vec_deque_splice_copy_done_%out_ok
+    !__vec_deque_splice_idx_%out_ok
+    jmp L_VEC_DEQUE_SPLICE_COPY_HEAD_%out_ok
+
+L_VEC_DEQUE_SPLICE_COPY_END_%out_ok:
+    !__vec_deque_splice_copy_done_%out_ok
+    !__vec_deque_splice_idx_%out_ok
+    !__vec_deque_splice_new_len_%out_ok
+    !__vec_deque_splice_hit_%out_ok
+    jmp L_VEC_DEQUE_SPLICE_DONE_%out_ok
+
+L_VEC_DEQUE_SPLICE_MISS_%out_ok:
+    !__vec_deque_splice_hit_%out_ok
+    jmp L_VEC_DEQUE_SPLICE_DONE_%out_ok
+
+L_VEC_DEQUE_SPLICE_DONE_%out_ok:
+    EXPAND VEC_FREE __vec_deque_splice_vec_%out_ok
+    !__vec_deque_splice_slice_%out_ok
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_SPLICE_U64.
+[MACRO] VEC_DEQUE_SPLICE %out_ok, %out_vec, %deque_reg, %start, %length, %replacement_slice
+    EXPAND VEC_DEQUE_SPLICE_U64 %out_ok, %out_vec, %deque_reg, %start, %length, %replacement_slice
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_TRY_FRONT_MUT_PTR %out_ok, %out_ptr, %deque_reg
+    __vec_deque_front_mut_slot_%out_ok = stack_alloc 8
+    __vec_deque_front_mut_ok_%out_ok = call @sa_vec_deque_try_front_mut_ptr(&%deque_reg, &__vec_deque_front_mut_slot_%out_ok)
+    %out_ptr = load __vec_deque_front_mut_slot_%out_ok+0 as ptr
+    %out_ok = __vec_deque_front_mut_ok_%out_ok
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_FRONT_MUT_PTR %out_ok, %out_ptr, %deque_reg
+    EXPAND VEC_DEQUE_TRY_FRONT_MUT_PTR %out_ok, %out_ptr, %deque_reg
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_FRONT_MUT %out_ok, %out_ptr, %deque_reg
+    EXPAND VEC_DEQUE_TRY_FRONT_MUT_PTR %out_ok, %out_ptr, %deque_reg
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_TRY_BACK_MUT_PTR %out_ok, %out_ptr, %deque_reg
+    __vec_deque_back_mut_slot_%out_ok = stack_alloc 8
+    __vec_deque_back_mut_ok_%out_ok = call @sa_vec_deque_try_back_mut_ptr(&%deque_reg, &__vec_deque_back_mut_slot_%out_ok)
+    %out_ptr = load __vec_deque_back_mut_slot_%out_ok+0 as ptr
+    %out_ok = __vec_deque_back_mut_ok_%out_ok
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_BACK_MUT_PTR %out_ok, %out_ptr, %deque_reg
+    EXPAND VEC_DEQUE_TRY_BACK_MUT_PTR %out_ok, %out_ptr, %deque_reg
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_BACK_MUT %out_ok, %out_ptr, %deque_reg
+    EXPAND VEC_DEQUE_TRY_BACK_MUT_PTR %out_ok, %out_ptr, %deque_reg
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_TRY_INSERT %out_ok, %deque_reg, %index, %value
+    %out_ok = call @sa_vec_deque_try_insert(&%deque_reg, %index, %value)
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_TRY_INSERT_MUT_PTR %out_ok, %out_ptr, %deque_reg, %index, %value
+    __vec_deque_insert_mut_ok_%out_ok = call @sa_vec_deque_try_insert(&%deque_reg, %index, %value)
+    br __vec_deque_insert_mut_ok_%out_ok -> L_VEC_DEQUE_INSERT_MUT_PTR_OK_%out_ok, L_VEC_DEQUE_INSERT_MUT_PTR_MISS_%out_ok
+L_VEC_DEQUE_INSERT_MUT_PTR_OK_%out_ok:
+    __vec_deque_insert_mut_slot_%out_ok = stack_alloc 8
+    __vec_deque_insert_mut_get_ok_%out_ok = call @sa_vec_deque_try_get_mut_ptr(&%deque_reg, %index, &__vec_deque_insert_mut_slot_%out_ok)
+    %out_ptr = load __vec_deque_insert_mut_slot_%out_ok+0 as ptr
+    %out_ok = __vec_deque_insert_mut_get_ok_%out_ok
+    !__vec_deque_insert_mut_ok_%out_ok
+    jmp L_VEC_DEQUE_INSERT_MUT_PTR_END_%out_ok
+L_VEC_DEQUE_INSERT_MUT_PTR_MISS_%out_ok:
+    %out_ptr = 0 as ptr
+    %out_ok = add 0, 0
+    !__vec_deque_insert_mut_ok_%out_ok
+L_VEC_DEQUE_INSERT_MUT_PTR_END_%out_ok:
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INSERT_MUT_PTR %out_ok, %out_ptr, %deque_reg, %index, %value
+    EXPAND VEC_DEQUE_TRY_INSERT_MUT_PTR %out_ok, %out_ptr, %deque_reg, %index, %value
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INSERT_MUT %out_ok, %out_ptr, %deque_reg, %index, %value
+    EXPAND VEC_DEQUE_TRY_INSERT_MUT_PTR %out_ok, %out_ptr, %deque_reg, %index, %value
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INSERT %out_ok, %deque_reg, %index, %value
+    EXPAND VEC_DEQUE_TRY_INSERT %out_ok, %deque_reg, %index, %value
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_TRY_REMOVE %out_ok, %out_value, %deque_reg, %index
+    __vec_deque_remove_slot_%out_ok = stack_alloc 8
+    __vec_deque_remove_ok_%out_ok = call @sa_vec_deque_try_remove(&%deque_reg, %index, &__vec_deque_remove_slot_%out_ok)
+    %out_value = load __vec_deque_remove_slot_%out_ok+0 as u64
+    %out_ok = __vec_deque_remove_ok_%out_ok
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_REMOVE %out_ok, %out_value, %deque_reg, %index
+    EXPAND VEC_DEQUE_TRY_REMOVE %out_ok, %out_value, %deque_reg, %index
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_TRY_SWAP_REMOVE_FRONT %out_ok, %out_value, %deque_reg, %index
+    __vec_deque_swap_remove_front_slot_%out_ok = stack_alloc 8
+    __vec_deque_swap_remove_front_ok_%out_ok = call @sa_vec_deque_try_swap_remove_front(&%deque_reg, %index, &__vec_deque_swap_remove_front_slot_%out_ok)
+    %out_value = load __vec_deque_swap_remove_front_slot_%out_ok+0 as u64
+    %out_ok = __vec_deque_swap_remove_front_ok_%out_ok
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_SWAP_REMOVE_FRONT %out_ok, %out_value, %deque_reg, %index
+    EXPAND VEC_DEQUE_TRY_SWAP_REMOVE_FRONT %out_ok, %out_value, %deque_reg, %index
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_TRY_SWAP_REMOVE_BACK %out_ok, %out_value, %deque_reg, %index
+    __vec_deque_swap_remove_back_slot_%out_ok = stack_alloc 8
+    __vec_deque_swap_remove_back_ok_%out_ok = call @sa_vec_deque_try_swap_remove_back(&%deque_reg, %index, &__vec_deque_swap_remove_back_slot_%out_ok)
+    %out_value = load __vec_deque_swap_remove_back_slot_%out_ok+0 as u64
+    %out_ok = __vec_deque_swap_remove_back_ok_%out_ok
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_SWAP_REMOVE_BACK %out_ok, %out_value, %deque_reg, %index
+    EXPAND VEC_DEQUE_TRY_SWAP_REMOVE_BACK %out_ok, %out_value, %deque_reg, %index
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_TRUNCATE %deque_reg, %new_len
+    call @sa_vec_deque_truncate(&%deque_reg, %new_len)
+[END_MACRO]
+
+// Rust method-name alias: VecDeque::truncate_front.
+[MACRO] VEC_DEQUE_TRUNCATE_FRONT %deque_reg, %new_len
+    call @sa_vec_deque_truncate_front(&%deque_reg, %new_len)
+[END_MACRO]
+
+// Rust VecDeque::binary_search via make_contiguous + slice binary search.
+[MACRO] VEC_DEQUE_TRY_BINARY_SEARCH_U64 %out_ok, %out_index, %deque_reg, %needle
+    EXPAND VEC_DEQUE_MAKE_CONTIGUOUS __vec_deque_binary_search_slice_%out_ok, %deque_reg
+    EXPAND SLICE_TRY_BINARY_SEARCH_U64 %out_ok, %out_index, __vec_deque_binary_search_slice_%out_ok, %needle
+    !__vec_deque_binary_search_slice_%out_ok
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_TRY_BINARY_SEARCH_U64.
+[MACRO] VEC_DEQUE_TRY_BINARY_SEARCH %out_ok, %out_index, %deque_reg, %needle
+    EXPAND VEC_DEQUE_TRY_BINARY_SEARCH_U64 %out_ok, %out_index, %deque_reg, %needle
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_BINARY_SEARCH_U64 %out_ok, %out_index, %deque_reg, %needle
+    EXPAND VEC_DEQUE_TRY_BINARY_SEARCH_U64 %out_ok, %out_index, %deque_reg, %needle
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_BINARY_SEARCH_U64.
+[MACRO] VEC_DEQUE_BINARY_SEARCH %out_ok, %out_index, %deque_reg, %needle
+    EXPAND VEC_DEQUE_BINARY_SEARCH_U64 %out_ok, %out_index, %deque_reg, %needle
+[END_MACRO]
+
+// Rust VecDeque::partition_point via make_contiguous + slice partition_point.
+[MACRO] VEC_DEQUE_PARTITION_POINT_U64 %out_index, %deque_reg, %pred_fn
+    EXPAND VEC_DEQUE_MAKE_CONTIGUOUS __vec_deque_partition_point_slice_%out_index, %deque_reg
+    EXPAND SLICE_PARTITION_POINT_U64 %out_index, __vec_deque_partition_point_slice_%out_index, %pred_fn
+    !__vec_deque_partition_point_slice_%out_index
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_PARTITION_POINT_U64.
+[MACRO] VEC_DEQUE_PARTITION_POINT %out_index, %deque_reg, %pred_fn
+    EXPAND VEC_DEQUE_PARTITION_POINT_U64 %out_index, %deque_reg, %pred_fn
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_RESIZE %out_ok, %deque_reg, %new_len, %value
+    __vec_deque_rs_lang_%out_ok = load %deque_reg+VecDeque_len as u64
+    __vec_deque_rs_shrink_%out_ok = ule %new_len, __vec_deque_rs_lang_%out_ok
+    br __vec_deque_rs_shrink_%out_ok -> L_VEC_DEQUE_RS_SHRINK_%out_ok, L_VEC_DEQUE_RS_GROW_%out_ok
+L_VEC_DEQUE_RS_SHRINK_%out_ok:
+    call @sa_vec_deque_truncate(&%deque_reg, %new_len)
+    !__vec_deque_rs_shrink_%out_ok
+    !__vec_deque_rs_lang_%out_ok
+    %out_ok = 1
+    jmp L_VEC_DEQUE_RS_END_%out_ok
+L_VEC_DEQUE_RS_GROW_%out_ok:
+    __vec_deque_rs_target_slot_%out_ok = stack_alloc 8
+    store __vec_deque_rs_target_slot_%out_ok+0, %new_len as u64
+    %out_ok = 1
+    jmp L_VEC_DEQUE_RS_GROW_HEAD_%out_ok
+L_VEC_DEQUE_RS_GROW_HEAD_%out_ok:
+    __vec_deque_rs_cur_%out_ok = load %deque_reg+VecDeque_len as u64
+    __vec_deque_rs_tgt_%out_ok = load __vec_deque_rs_target_slot_%out_ok+0 as u64
+    __vec_deque_rs_done_%out_ok = eq __vec_deque_rs_cur_%out_ok, __vec_deque_rs_tgt_%out_ok
+    br __vec_deque_rs_done_%out_ok -> L_VEC_DEQUE_RS_GROW_DONE_%out_ok, L_VEC_DEQUE_RS_GROW_BODY_%out_ok
+L_VEC_DEQUE_RS_GROW_BODY_%out_ok:
+    call @sa_vec_deque_push_back(&%deque_reg, %value)
+    !__vec_deque_rs_cur_%out_ok
+    !__vec_deque_rs_tgt_%out_ok
+    !__vec_deque_rs_done_%out_ok
+    jmp L_VEC_DEQUE_RS_GROW_HEAD_%out_ok
+L_VEC_DEQUE_RS_GROW_DONE_%out_ok:
+    !__vec_deque_rs_cur_%out_ok
+    !__vec_deque_rs_tgt_%out_ok
+    !__vec_deque_rs_done_%out_ok
+    !__vec_deque_rs_shrink_%out_ok
+    !__vec_deque_rs_lang_%out_ok
+    jmp L_VEC_DEQUE_RS_END_%out_ok
+L_VEC_DEQUE_RS_END_%out_ok:
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_RESIZE_U64 %out_ok, %deque_reg, %new_len, %value
+    EXPAND VEC_DEQUE_RESIZE %out_ok, %deque_reg, %new_len, %value
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_RESIZE_WITH %out_ok, %deque_reg, %new_len, %gen_fn
+    __vec_deque_rsw_lang_%out_ok = load %deque_reg+VecDeque_len as u64
+    __vec_deque_rsw_shrink_%out_ok = ule %new_len, __vec_deque_rsw_lang_%out_ok
+    br __vec_deque_rsw_shrink_%out_ok -> L_VEC_DEQUE_RSW_SHRINK_%out_ok, L_VEC_DEQUE_RSW_GROW_%out_ok
+L_VEC_DEQUE_RSW_SHRINK_%out_ok:
+    call @sa_vec_deque_truncate(&%deque_reg, %new_len)
+    !__vec_deque_rsw_shrink_%out_ok
+    !__vec_deque_rsw_lang_%out_ok
+    %out_ok = 1
+    jmp L_VEC_DEQUE_RSW_END_%out_ok
+L_VEC_DEQUE_RSW_GROW_%out_ok:
+    __vec_deque_rsw_target_slot_%out_ok = stack_alloc 8
+    store __vec_deque_rsw_target_slot_%out_ok+0, %new_len as u64
+    %out_ok = 1
+    jmp L_VEC_DEQUE_RSW_GROW_HEAD_%out_ok
+L_VEC_DEQUE_RSW_GROW_HEAD_%out_ok:
+    __vec_deque_rsw_cur_%out_ok = load %deque_reg+VecDeque_len as u64
+    __vec_deque_rsw_tgt_%out_ok = load __vec_deque_rsw_target_slot_%out_ok+0 as u64
+    __vec_deque_rsw_done_%out_ok = eq __vec_deque_rsw_cur_%out_ok, __vec_deque_rsw_tgt_%out_ok
+    br __vec_deque_rsw_done_%out_ok -> L_VEC_DEQUE_RSW_GROW_DONE_%out_ok, L_VEC_DEQUE_RSW_GROW_BODY_%out_ok
+L_VEC_DEQUE_RSW_GROW_BODY_%out_ok:
+    __vec_deque_rsw_value_%out_ok = call %gen_fn()
+    call @sa_vec_deque_push_back(&%deque_reg, __vec_deque_rsw_value_%out_ok)
+    !__vec_deque_rsw_value_%out_ok
+    !__vec_deque_rsw_cur_%out_ok
+    !__vec_deque_rsw_tgt_%out_ok
+    !__vec_deque_rsw_done_%out_ok
+    jmp L_VEC_DEQUE_RSW_GROW_HEAD_%out_ok
+L_VEC_DEQUE_RSW_GROW_DONE_%out_ok:
+    !__vec_deque_rsw_cur_%out_ok
+    !__vec_deque_rsw_tgt_%out_ok
+    !__vec_deque_rsw_done_%out_ok
+    !__vec_deque_rsw_shrink_%out_ok
+    !__vec_deque_rsw_lang_%out_ok
+    jmp L_VEC_DEQUE_RSW_END_%out_ok
+L_VEC_DEQUE_RSW_END_%out_ok:
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_RESIZE_WITH_U64 %out_ok, %deque_reg, %new_len, %gen_fn
+    EXPAND VEC_DEQUE_RESIZE_WITH %out_ok, %deque_reg, %new_len, %gen_fn
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_TRY_RESIZE_WITHIN_CAPACITY %out_ok, %deque_reg, %new_len, %value
+    __vec_deque_trswc_len_%out_ok = load %deque_reg+VecDeque_len as u64
+    __vec_deque_trswc_shrink_%out_ok = ule %new_len, __vec_deque_trswc_len_%out_ok
+    br __vec_deque_trswc_shrink_%out_ok -> L_VEC_DEQUE_TRSWC_SHRINK_%out_ok, L_VEC_DEQUE_TRSWC_GROW_CHECK_%out_ok
+L_VEC_DEQUE_TRSWC_SHRINK_%out_ok:
+    call @sa_vec_deque_truncate(&%deque_reg, %new_len)
+    !__vec_deque_trswc_shrink_%out_ok
+    !__vec_deque_trswc_len_%out_ok
+    %out_ok = 1
+    jmp L_VEC_DEQUE_TRSWC_END_%out_ok
+L_VEC_DEQUE_TRSWC_GROW_CHECK_%out_ok:
+    __vec_deque_trswc_cap_%out_ok = load %deque_reg+VecDeque_cap as u64
+    __vec_deque_trswc_room_ok_%out_ok = ule %new_len, __vec_deque_trswc_cap_%out_ok
+    br __vec_deque_trswc_room_ok_%out_ok -> L_VEC_DEQUE_TRSWC_GROW_%out_ok, L_VEC_DEQUE_TRSWC_MISS_%out_ok
+L_VEC_DEQUE_TRSWC_MISS_%out_ok:
+    !__vec_deque_trswc_room_ok_%out_ok
+    !__vec_deque_trswc_cap_%out_ok
+    !__vec_deque_trswc_shrink_%out_ok
+    !__vec_deque_trswc_len_%out_ok
+    %out_ok = 0
+    jmp L_VEC_DEQUE_TRSWC_END_%out_ok
+L_VEC_DEQUE_TRSWC_GROW_%out_ok:
+    __vec_deque_trswc_target_slot_%out_ok = stack_alloc 8
+    store __vec_deque_trswc_target_slot_%out_ok+0, %new_len as u64
+    !__vec_deque_trswc_room_ok_%out_ok
+    !__vec_deque_trswc_cap_%out_ok
+    %out_ok = 1
+    jmp L_VEC_DEQUE_TRSWC_GROW_HEAD_%out_ok
+L_VEC_DEQUE_TRSWC_GROW_HEAD_%out_ok:
+    __vec_deque_trswc_cur_%out_ok = load %deque_reg+VecDeque_len as u64
+    __vec_deque_trswc_tgt_%out_ok = load __vec_deque_trswc_target_slot_%out_ok+0 as u64
+    __vec_deque_trswc_done_%out_ok = eq __vec_deque_trswc_cur_%out_ok, __vec_deque_trswc_tgt_%out_ok
+    br __vec_deque_trswc_done_%out_ok -> L_VEC_DEQUE_TRSWC_GROW_DONE_%out_ok, L_VEC_DEQUE_TRSWC_GROW_BODY_%out_ok
+L_VEC_DEQUE_TRSWC_GROW_BODY_%out_ok:
+    call @sa_vec_deque_push_back(&%deque_reg, %value)
+    !__vec_deque_trswc_cur_%out_ok
+    !__vec_deque_trswc_tgt_%out_ok
+    !__vec_deque_trswc_done_%out_ok
+    jmp L_VEC_DEQUE_TRSWC_GROW_HEAD_%out_ok
+L_VEC_DEQUE_TRSWC_GROW_DONE_%out_ok:
+    !__vec_deque_trswc_cur_%out_ok
+    !__vec_deque_trswc_tgt_%out_ok
+    !__vec_deque_trswc_done_%out_ok
+    !__vec_deque_trswc_shrink_%out_ok
+    !__vec_deque_trswc_len_%out_ok
+    jmp L_VEC_DEQUE_TRSWC_END_%out_ok
+L_VEC_DEQUE_TRSWC_END_%out_ok:
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_TRY_RESIZE_WITHIN_CAPACITY_U64 %out_ok, %deque_reg, %new_len, %value
+    EXPAND VEC_DEQUE_TRY_RESIZE_WITHIN_CAPACITY %out_ok, %deque_reg, %new_len, %value
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_TRY_RESIZE_WITH_WITHIN_CAPACITY %out_ok, %deque_reg, %new_len, %gen_fn
+    __vec_deque_trswwc_len_%out_ok = load %deque_reg+VecDeque_len as u64
+    __vec_deque_trswwc_shrink_%out_ok = ule %new_len, __vec_deque_trswwc_len_%out_ok
+    br __vec_deque_trswwc_shrink_%out_ok -> L_VEC_DEQUE_TRSWWC_SHRINK_%out_ok, L_VEC_DEQUE_TRSWWC_GROW_CHECK_%out_ok
+L_VEC_DEQUE_TRSWWC_SHRINK_%out_ok:
+    call @sa_vec_deque_truncate(&%deque_reg, %new_len)
+    !__vec_deque_trswwc_shrink_%out_ok
+    !__vec_deque_trswwc_len_%out_ok
+    %out_ok = 1
+    jmp L_VEC_DEQUE_TRSWWC_END_%out_ok
+L_VEC_DEQUE_TRSWWC_GROW_CHECK_%out_ok:
+    __vec_deque_trswwc_cap_%out_ok = load %deque_reg+VecDeque_cap as u64
+    __vec_deque_trswwc_room_ok_%out_ok = ule %new_len, __vec_deque_trswwc_cap_%out_ok
+    br __vec_deque_trswwc_room_ok_%out_ok -> L_VEC_DEQUE_TRSWWC_GROW_%out_ok, L_VEC_DEQUE_TRSWWC_MISS_%out_ok
+L_VEC_DEQUE_TRSWWC_MISS_%out_ok:
+    !__vec_deque_trswwc_room_ok_%out_ok
+    !__vec_deque_trswwc_cap_%out_ok
+    !__vec_deque_trswwc_shrink_%out_ok
+    !__vec_deque_trswwc_len_%out_ok
+    %out_ok = 0
+    jmp L_VEC_DEQUE_TRSWWC_END_%out_ok
+L_VEC_DEQUE_TRSWWC_GROW_%out_ok:
+    __vec_deque_trswwc_target_slot_%out_ok = stack_alloc 8
+    store __vec_deque_trswwc_target_slot_%out_ok+0, %new_len as u64
+    !__vec_deque_trswwc_room_ok_%out_ok
+    !__vec_deque_trswwc_cap_%out_ok
+    %out_ok = 1
+    jmp L_VEC_DEQUE_TRSWWC_GROW_HEAD_%out_ok
+L_VEC_DEQUE_TRSWWC_GROW_HEAD_%out_ok:
+    __vec_deque_trswwc_cur_%out_ok = load %deque_reg+VecDeque_len as u64
+    __vec_deque_trswwc_tgt_%out_ok = load __vec_deque_trswwc_target_slot_%out_ok+0 as u64
+    __vec_deque_trswwc_done_%out_ok = eq __vec_deque_trswwc_cur_%out_ok, __vec_deque_trswwc_tgt_%out_ok
+    br __vec_deque_trswwc_done_%out_ok -> L_VEC_DEQUE_TRSWWC_GROW_DONE_%out_ok, L_VEC_DEQUE_TRSWWC_GROW_BODY_%out_ok
+L_VEC_DEQUE_TRSWWC_GROW_BODY_%out_ok:
+    __vec_deque_trswwc_value_%out_ok = call %gen_fn()
+    call @sa_vec_deque_push_back(&%deque_reg, __vec_deque_trswwc_value_%out_ok)
+    !__vec_deque_trswwc_value_%out_ok
+    !__vec_deque_trswwc_cur_%out_ok
+    !__vec_deque_trswwc_tgt_%out_ok
+    !__vec_deque_trswwc_done_%out_ok
+    jmp L_VEC_DEQUE_TRSWWC_GROW_HEAD_%out_ok
+L_VEC_DEQUE_TRSWWC_GROW_DONE_%out_ok:
+    !__vec_deque_trswwc_cur_%out_ok
+    !__vec_deque_trswwc_tgt_%out_ok
+    !__vec_deque_trswwc_done_%out_ok
+    !__vec_deque_trswwc_shrink_%out_ok
+    !__vec_deque_trswwc_len_%out_ok
+    jmp L_VEC_DEQUE_TRSWWC_END_%out_ok
+L_VEC_DEQUE_TRSWWC_END_%out_ok:
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_TRY_RESIZE_WITH_WITHIN_CAPACITY_U64 %out_ok, %deque_reg, %new_len, %gen_fn
+    EXPAND VEC_DEQUE_TRY_RESIZE_WITH_WITHIN_CAPACITY %out_ok, %deque_reg, %new_len, %gen_fn
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_RESIZE_WITHIN_CAPACITY %out_ok, %deque_reg, %new_len, %value
+    EXPAND VEC_DEQUE_TRY_RESIZE_WITHIN_CAPACITY %out_ok, %deque_reg, %new_len, %value
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_RESIZE_WITHIN_CAPACITY_U64 %out_ok, %deque_reg, %new_len, %value
+    EXPAND VEC_DEQUE_TRY_RESIZE_WITHIN_CAPACITY %out_ok, %deque_reg, %new_len, %value
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_RESIZE_WITH_WITHIN_CAPACITY %out_ok, %deque_reg, %new_len, %gen_fn
+    EXPAND VEC_DEQUE_TRY_RESIZE_WITH_WITHIN_CAPACITY %out_ok, %deque_reg, %new_len, %gen_fn
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_RESIZE_WITH_WITHIN_CAPACITY_U64 %out_ok, %deque_reg, %new_len, %gen_fn
+    EXPAND VEC_DEQUE_TRY_RESIZE_WITH_WITHIN_CAPACITY %out_ok, %deque_reg, %new_len, %gen_fn
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_TRY_EXTEND_FROM_SLICE_U64 %out_ok, %deque_reg, %src_slice
+    __vec_deque_efswc_len_%out_ok = load %deque_reg+VecDeque_len as u64
+    __vec_deque_efswc_cap_%out_ok = load %deque_reg+VecDeque_cap as u64
+    __vec_deque_efswc_src_len_%out_ok = load %src_slice+Slice_len as u64
+    __vec_deque_efswc_total_%out_ok = add __vec_deque_efswc_len_%out_ok, __vec_deque_efswc_src_len_%out_ok
+    __vec_deque_efswc_room_ok_%out_ok = ule __vec_deque_efswc_total_%out_ok, __vec_deque_efswc_cap_%out_ok
+    br __vec_deque_efswc_room_ok_%out_ok -> L_VEC_DEQUE_EFSWC_INIT_%out_ok, L_VEC_DEQUE_EFSWC_MISS_ROOM_%out_ok
+L_VEC_DEQUE_EFSWC_INIT_%out_ok:
+    __vec_deque_efswc_idx_slot_%out_ok = stack_alloc 8
+    store __vec_deque_efswc_idx_slot_%out_ok+0, 0 as u64
+    jmp L_VEC_DEQUE_EFSWC_HEAD_%out_ok
+L_VEC_DEQUE_EFSWC_HEAD_%out_ok:
+    __vec_deque_efswc_idx_%out_ok = load __vec_deque_efswc_idx_slot_%out_ok+0 as u64
+    __vec_deque_efswc_done_%out_ok = eq __vec_deque_efswc_idx_%out_ok, __vec_deque_efswc_src_len_%out_ok
+    br __vec_deque_efswc_done_%out_ok -> L_VEC_DEQUE_EFSWC_DONE_%out_ok, L_VEC_DEQUE_EFSWC_BODY_%out_ok
+L_VEC_DEQUE_EFSWC_BODY_%out_ok:
+    __vec_deque_efswc_src_ptr_%out_ok = load %src_slice+Slice_ptr as ptr
+    __vec_deque_efswc_off_%out_ok = mul __vec_deque_efswc_idx_%out_ok, 8
+    __vec_deque_efswc_elem_ptr_%out_ok = ptr_add __vec_deque_efswc_src_ptr_%out_ok, __vec_deque_efswc_off_%out_ok
+    __vec_deque_efswc_value_%out_ok = load __vec_deque_efswc_elem_ptr_%out_ok+0 as u64
+    call @sa_vec_deque_push_back(&%deque_reg, __vec_deque_efswc_value_%out_ok)
+    __vec_deque_efswc_next_%out_ok = add __vec_deque_efswc_idx_%out_ok, 1
+    store __vec_deque_efswc_idx_slot_%out_ok+0, __vec_deque_efswc_next_%out_ok as u64
+    !__vec_deque_efswc_next_%out_ok
+    !__vec_deque_efswc_value_%out_ok
+    !__vec_deque_efswc_elem_ptr_%out_ok
+    !__vec_deque_efswc_off_%out_ok
+    !__vec_deque_efswc_src_ptr_%out_ok
+    !__vec_deque_efswc_done_%out_ok
+    !__vec_deque_efswc_idx_%out_ok
+    jmp L_VEC_DEQUE_EFSWC_HEAD_%out_ok
+L_VEC_DEQUE_EFSWC_DONE_%out_ok:
+    !__vec_deque_efswc_done_%out_ok
+    !__vec_deque_efswc_idx_%out_ok
+    !__vec_deque_efswc_total_%out_ok
+    !__vec_deque_efswc_room_ok_%out_ok
+    !__vec_deque_efswc_cap_%out_ok
+    !__vec_deque_efswc_len_%out_ok
+    !__vec_deque_efswc_src_len_%out_ok
+    %out_ok = 1
+    jmp L_VEC_DEQUE_EFSWC_END_%out_ok
+L_VEC_DEQUE_EFSWC_MISS_ROOM_%out_ok:
+    !__vec_deque_efswc_room_ok_%out_ok
+    !__vec_deque_efswc_total_%out_ok
+    !__vec_deque_efswc_cap_%out_ok
+    !__vec_deque_efswc_len_%out_ok
+    !__vec_deque_efswc_src_len_%out_ok
+    %out_ok = 0
+    jmp L_VEC_DEQUE_EFSWC_END_%out_ok
+L_VEC_DEQUE_EFSWC_END_%out_ok:
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_TRY_EXTEND_FROM_SLICE_U64.
+[MACRO] VEC_DEQUE_TRY_EXTEND_FROM_SLICE %out_ok, %deque_reg, %src_slice
+    EXPAND VEC_DEQUE_TRY_EXTEND_FROM_SLICE_U64 %out_ok, %deque_reg, %src_slice
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_EXTEND_FROM_SLICE_U64 %out_ok, %deque_reg, %src_slice
+    EXPAND VEC_DEQUE_TRY_EXTEND_FROM_SLICE_U64 %out_ok, %deque_reg, %src_slice
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_EXTEND_FROM_SLICE %out_ok, %deque_reg, %src_slice
+    EXPAND VEC_DEQUE_TRY_EXTEND_FROM_SLICE_U64 %out_ok, %deque_reg, %src_slice
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_TRY_EXTEND_CHARS_U64 %out_ok, %deque_reg, %src_slice
+    EXPAND VEC_DEQUE_TRY_EXTEND_FROM_SLICE_U64 %out_ok, %deque_reg, %src_slice
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_TRY_EXTEND_CHARS_U64.
+[MACRO] VEC_DEQUE_TRY_EXTEND_CHARS %out_ok, %deque_reg, %src_slice
+    EXPAND VEC_DEQUE_TRY_EXTEND_CHARS_U64 %out_ok, %deque_reg, %src_slice
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_EXTEND_CHARS_U64 %out_ok, %deque_reg, %src_slice
+    EXPAND VEC_DEQUE_TRY_EXTEND_CHARS_U64 %out_ok, %deque_reg, %src_slice
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_EXTEND_CHARS_U64.
+[MACRO] VEC_DEQUE_EXTEND_CHARS %out_ok, %deque_reg, %src_slice
+    EXPAND VEC_DEQUE_EXTEND_CHARS_U64 %out_ok, %deque_reg, %src_slice
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_TRY_EXTEND_FROM_SLICE_N_WITHIN_CAPACITY_U64 %out_ok, %deque_reg, %src_slice, %count
+    __vec_deque_efsnwc_src_len_%out_ok = load %src_slice+Slice_len as u64
+    __vec_deque_efsnwc_total_%out_ok = mul __vec_deque_efsnwc_src_len_%out_ok, %count
+    __vec_deque_efsnwc_len_%out_ok = load %deque_reg+VecDeque_len as u64
+    __vec_deque_efsnwc_cap_%out_ok = load %deque_reg+VecDeque_cap as u64
+    __vec_deque_efsnwc_new_len_%out_ok = add __vec_deque_efsnwc_len_%out_ok, __vec_deque_efsnwc_total_%out_ok
+    __vec_deque_efsnwc_room_ok_%out_ok = ule __vec_deque_efsnwc_new_len_%out_ok, __vec_deque_efsnwc_cap_%out_ok
+    br __vec_deque_efsnwc_room_ok_%out_ok -> L_VEC_DEQUE_EFSNWC_SETUP_%out_ok, L_VEC_DEQUE_EFSNWC_MISS_%out_ok
+L_VEC_DEQUE_EFSNWC_SETUP_%out_ok:
+    __vec_deque_efsnwc_idx_slot_%out_ok = stack_alloc 8
+    store __vec_deque_efsnwc_idx_slot_%out_ok+0, 0 as u64
+    !__vec_deque_efsnwc_room_ok_%out_ok
+    !__vec_deque_efsnwc_new_len_%out_ok
+    !__vec_deque_efsnwc_cap_%out_ok
+    !__vec_deque_efsnwc_len_%out_ok
+    !__vec_deque_efsnwc_total_%out_ok
+    !__vec_deque_efsnwc_src_len_%out_ok
+    jmp L_VEC_DEQUE_EFSNWC_HEAD_%out_ok
+L_VEC_DEQUE_EFSNWC_HEAD_%out_ok:
+    __vec_deque_efsnwc_idx_%out_ok = load __vec_deque_efsnwc_idx_slot_%out_ok+0 as u64
+    __vec_deque_efsnwc_done_%out_ok = eq __vec_deque_efsnwc_idx_%out_ok, %count
+    br __vec_deque_efsnwc_done_%out_ok -> L_VEC_DEQUE_EFSNWC_DONE_%out_ok, L_VEC_DEQUE_EFSNWC_BODY_%out_ok
+L_VEC_DEQUE_EFSNWC_BODY_%out_ok:
+    EXPAND VEC_DEQUE_TRY_EXTEND_FROM_SLICE_U64 __vec_deque_efsnwc_push_ok_%out_ok, %deque_reg, %src_slice
+    br __vec_deque_efsnwc_push_ok_%out_ok -> L_VEC_DEQUE_EFSNWC_NEXT_%out_ok, L_VEC_DEQUE_EFSNWC_FAIL_%out_ok
+L_VEC_DEQUE_EFSNWC_NEXT_%out_ok:
+    __vec_deque_efsnwc_next_%out_ok = add __vec_deque_efsnwc_idx_%out_ok, 1
+    store __vec_deque_efsnwc_idx_slot_%out_ok+0, __vec_deque_efsnwc_next_%out_ok as u64
+    !__vec_deque_efsnwc_next_%out_ok
+    !__vec_deque_efsnwc_push_ok_%out_ok
+    !__vec_deque_efsnwc_done_%out_ok
+    !__vec_deque_efsnwc_idx_%out_ok
+    jmp L_VEC_DEQUE_EFSNWC_HEAD_%out_ok
+L_VEC_DEQUE_EFSNWC_FAIL_%out_ok:
+    %out_ok = add 0, 0
+    !__vec_deque_efsnwc_push_ok_%out_ok
+    !__vec_deque_efsnwc_done_%out_ok
+    !__vec_deque_efsnwc_idx_%out_ok
+    jmp L_VEC_DEQUE_EFSNWC_END_%out_ok
+L_VEC_DEQUE_EFSNWC_DONE_%out_ok:
+    %out_ok = add 0, 1
+    !__vec_deque_efsnwc_done_%out_ok
+    !__vec_deque_efsnwc_idx_%out_ok
+    jmp L_VEC_DEQUE_EFSNWC_END_%out_ok
+L_VEC_DEQUE_EFSNWC_MISS_%out_ok:
+    %out_ok = add 0, 0
+    !__vec_deque_efsnwc_room_ok_%out_ok
+    !__vec_deque_efsnwc_new_len_%out_ok
+    !__vec_deque_efsnwc_cap_%out_ok
+    !__vec_deque_efsnwc_len_%out_ok
+    !__vec_deque_efsnwc_total_%out_ok
+    !__vec_deque_efsnwc_src_len_%out_ok
+L_VEC_DEQUE_EFSNWC_END_%out_ok:
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_TRY_EXTEND_FROM_SLICE_N_WITHIN_CAPACITY_U64.
+[MACRO] VEC_DEQUE_TRY_EXTEND_FROM_SLICE_N_WITHIN_CAPACITY %out_ok, %deque_reg, %src_slice, %count
+    EXPAND VEC_DEQUE_TRY_EXTEND_FROM_SLICE_N_WITHIN_CAPACITY_U64 %out_ok, %deque_reg, %src_slice, %count
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_EXTEND_FROM_SLICE_N_WITHIN_CAPACITY_U64 %out_ok, %deque_reg, %src_slice, %count
+    EXPAND VEC_DEQUE_TRY_EXTEND_FROM_SLICE_N_WITHIN_CAPACITY_U64 %out_ok, %deque_reg, %src_slice, %count
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_EXTEND_FROM_SLICE_N_WITHIN_CAPACITY_U64.
+[MACRO] VEC_DEQUE_EXTEND_FROM_SLICE_N_WITHIN_CAPACITY %out_ok, %deque_reg, %src_slice, %count
+    EXPAND VEC_DEQUE_EXTEND_FROM_SLICE_N_WITHIN_CAPACITY_U64 %out_ok, %deque_reg, %src_slice, %count
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_TRY_PUSH_BACK_N_WITHIN_CAPACITY_U64 %out_ok, %deque_reg, %value, %count
+    __vec_deque_pbnwc_len_%out_ok = load %deque_reg+VecDeque_len as u64
+    __vec_deque_pbnwc_cap_%out_ok = load %deque_reg+VecDeque_cap as u64
+    __vec_deque_pbnwc_new_len_%out_ok = add __vec_deque_pbnwc_len_%out_ok, %count
+    __vec_deque_pbnwc_room_ok_%out_ok = ule __vec_deque_pbnwc_new_len_%out_ok, __vec_deque_pbnwc_cap_%out_ok
+    br __vec_deque_pbnwc_room_ok_%out_ok -> L_VEC_DEQUE_PBNWC_SETUP_%out_ok, L_VEC_DEQUE_PBNWC_MISS_%out_ok
+L_VEC_DEQUE_PBNWC_SETUP_%out_ok:
+    __vec_deque_pbnwc_idx_slot_%out_ok = stack_alloc 8
+    store __vec_deque_pbnwc_idx_slot_%out_ok+0, 0 as u64
+    !__vec_deque_pbnwc_room_ok_%out_ok
+    !__vec_deque_pbnwc_new_len_%out_ok
+    !__vec_deque_pbnwc_cap_%out_ok
+    !__vec_deque_pbnwc_len_%out_ok
+    jmp L_VEC_DEQUE_PBNWC_HEAD_%out_ok
+L_VEC_DEQUE_PBNWC_HEAD_%out_ok:
+    __vec_deque_pbnwc_idx_%out_ok = load __vec_deque_pbnwc_idx_slot_%out_ok+0 as u64
+    __vec_deque_pbnwc_done_%out_ok = eq __vec_deque_pbnwc_idx_%out_ok, %count
+    br __vec_deque_pbnwc_done_%out_ok -> L_VEC_DEQUE_PBNWC_DONE_%out_ok, L_VEC_DEQUE_PBNWC_BODY_%out_ok
+L_VEC_DEQUE_PBNWC_BODY_%out_ok:
+    call @sa_vec_deque_push_back(&%deque_reg, %value)
+    __vec_deque_pbnwc_next_%out_ok = add __vec_deque_pbnwc_idx_%out_ok, 1
+    store __vec_deque_pbnwc_idx_slot_%out_ok+0, __vec_deque_pbnwc_next_%out_ok as u64
+    !__vec_deque_pbnwc_next_%out_ok
+    !__vec_deque_pbnwc_done_%out_ok
+    !__vec_deque_pbnwc_idx_%out_ok
+    jmp L_VEC_DEQUE_PBNWC_HEAD_%out_ok
+L_VEC_DEQUE_PBNWC_DONE_%out_ok:
+    %out_ok = add 0, 1
+    !__vec_deque_pbnwc_done_%out_ok
+    !__vec_deque_pbnwc_idx_%out_ok
+    jmp L_VEC_DEQUE_PBNWC_END_%out_ok
+L_VEC_DEQUE_PBNWC_MISS_%out_ok:
+    %out_ok = add 0, 0
+    !__vec_deque_pbnwc_room_ok_%out_ok
+    !__vec_deque_pbnwc_new_len_%out_ok
+    !__vec_deque_pbnwc_cap_%out_ok
+    !__vec_deque_pbnwc_len_%out_ok
+L_VEC_DEQUE_PBNWC_END_%out_ok:
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_TRY_PUSH_BACK_N_WITHIN_CAPACITY_U64.
+[MACRO] VEC_DEQUE_TRY_PUSH_BACK_N_WITHIN_CAPACITY %out_ok, %deque_reg, %value, %count
+    EXPAND VEC_DEQUE_TRY_PUSH_BACK_N_WITHIN_CAPACITY_U64 %out_ok, %deque_reg, %value, %count
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_PUSH_BACK_N_WITHIN_CAPACITY_U64 %out_ok, %deque_reg, %value, %count
+    EXPAND VEC_DEQUE_TRY_PUSH_BACK_N_WITHIN_CAPACITY_U64 %out_ok, %deque_reg, %value, %count
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_PUSH_BACK_N_WITHIN_CAPACITY_U64.
+[MACRO] VEC_DEQUE_PUSH_BACK_N_WITHIN_CAPACITY %out_ok, %deque_reg, %value, %count
+    EXPAND VEC_DEQUE_PUSH_BACK_N_WITHIN_CAPACITY_U64 %out_ok, %deque_reg, %value, %count
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_TRY_PUSH_FRONT_N_WITHIN_CAPACITY_U64 %out_ok, %deque_reg, %value, %count
+    __vec_deque_pfnwc_len_%out_ok = load %deque_reg+VecDeque_len as u64
+    __vec_deque_pfnwc_cap_%out_ok = load %deque_reg+VecDeque_cap as u64
+    __vec_deque_pfnwc_new_len_%out_ok = add __vec_deque_pfnwc_len_%out_ok, %count
+    __vec_deque_pfnwc_room_ok_%out_ok = ule __vec_deque_pfnwc_new_len_%out_ok, __vec_deque_pfnwc_cap_%out_ok
+    br __vec_deque_pfnwc_room_ok_%out_ok -> L_VEC_DEQUE_PFNWC_SETUP_%out_ok, L_VEC_DEQUE_PFNWC_MISS_%out_ok
+L_VEC_DEQUE_PFNWC_SETUP_%out_ok:
+    __vec_deque_pfnwc_idx_slot_%out_ok = stack_alloc 8
+    store __vec_deque_pfnwc_idx_slot_%out_ok+0, 0 as u64
+    !__vec_deque_pfnwc_room_ok_%out_ok
+    !__vec_deque_pfnwc_new_len_%out_ok
+    !__vec_deque_pfnwc_cap_%out_ok
+    !__vec_deque_pfnwc_len_%out_ok
+    jmp L_VEC_DEQUE_PFNWC_HEAD_%out_ok
+L_VEC_DEQUE_PFNWC_HEAD_%out_ok:
+    __vec_deque_pfnwc_idx_%out_ok = load __vec_deque_pfnwc_idx_slot_%out_ok+0 as u64
+    __vec_deque_pfnwc_done_%out_ok = eq __vec_deque_pfnwc_idx_%out_ok, %count
+    br __vec_deque_pfnwc_done_%out_ok -> L_VEC_DEQUE_PFNWC_DONE_%out_ok, L_VEC_DEQUE_PFNWC_BODY_%out_ok
+L_VEC_DEQUE_PFNWC_BODY_%out_ok:
+    call @sa_vec_deque_push_front(&%deque_reg, %value)
+    __vec_deque_pfnwc_next_%out_ok = add __vec_deque_pfnwc_idx_%out_ok, 1
+    store __vec_deque_pfnwc_idx_slot_%out_ok+0, __vec_deque_pfnwc_next_%out_ok as u64
+    !__vec_deque_pfnwc_next_%out_ok
+    !__vec_deque_pfnwc_done_%out_ok
+    !__vec_deque_pfnwc_idx_%out_ok
+    jmp L_VEC_DEQUE_PFNWC_HEAD_%out_ok
+L_VEC_DEQUE_PFNWC_DONE_%out_ok:
+    %out_ok = add 0, 1
+    !__vec_deque_pfnwc_done_%out_ok
+    !__vec_deque_pfnwc_idx_%out_ok
+    jmp L_VEC_DEQUE_PFNWC_END_%out_ok
+L_VEC_DEQUE_PFNWC_MISS_%out_ok:
+    %out_ok = add 0, 0
+    !__vec_deque_pfnwc_room_ok_%out_ok
+    !__vec_deque_pfnwc_new_len_%out_ok
+    !__vec_deque_pfnwc_cap_%out_ok
+    !__vec_deque_pfnwc_len_%out_ok
+L_VEC_DEQUE_PFNWC_END_%out_ok:
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_TRY_PUSH_FRONT_N_WITHIN_CAPACITY_U64.
+[MACRO] VEC_DEQUE_TRY_PUSH_FRONT_N_WITHIN_CAPACITY %out_ok, %deque_reg, %value, %count
+    EXPAND VEC_DEQUE_TRY_PUSH_FRONT_N_WITHIN_CAPACITY_U64 %out_ok, %deque_reg, %value, %count
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_PUSH_FRONT_N_WITHIN_CAPACITY_U64 %out_ok, %deque_reg, %value, %count
+    EXPAND VEC_DEQUE_TRY_PUSH_FRONT_N_WITHIN_CAPACITY_U64 %out_ok, %deque_reg, %value, %count
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_PUSH_FRONT_N_WITHIN_CAPACITY_U64.
+[MACRO] VEC_DEQUE_PUSH_FRONT_N_WITHIN_CAPACITY %out_ok, %deque_reg, %value, %count
+    EXPAND VEC_DEQUE_PUSH_FRONT_N_WITHIN_CAPACITY_U64 %out_ok, %deque_reg, %value, %count
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_TRY_INSERT_WITHIN_CAPACITY %out_ok, %deque_reg, %index, %value
+    __vec_deque_iwc_len_%out_ok = load %deque_reg+VecDeque_len as u64
+    __vec_deque_iwc_cap_%out_ok = load %deque_reg+VecDeque_cap as u64
+    __vec_deque_iwc_in_bounds_%out_ok = ule %index, __vec_deque_iwc_len_%out_ok
+    __vec_deque_iwc_new_len_%out_ok = add __vec_deque_iwc_len_%out_ok, 1
+    __vec_deque_iwc_has_room_%out_ok = ule __vec_deque_iwc_new_len_%out_ok, __vec_deque_iwc_cap_%out_ok
+    __vec_deque_iwc_ok_all_%out_ok = and __vec_deque_iwc_in_bounds_%out_ok, __vec_deque_iwc_has_room_%out_ok
+    br __vec_deque_iwc_ok_all_%out_ok -> L_VEC_DEQUE_IWC_OK_%out_ok, L_VEC_DEQUE_IWC_MISS_%out_ok
+L_VEC_DEQUE_IWC_OK_%out_ok:
+    __vec_deque_iwc_abi_ok_%out_ok = call @sa_vec_deque_try_insert(&%deque_reg, %index, %value)
+    %out_ok = __vec_deque_iwc_abi_ok_%out_ok
+    !__vec_deque_iwc_ok_all_%out_ok
+    !__vec_deque_iwc_in_bounds_%out_ok
+    !__vec_deque_iwc_new_len_%out_ok
+    !__vec_deque_iwc_has_room_%out_ok
+    !__vec_deque_iwc_cap_%out_ok
+    !__vec_deque_iwc_len_%out_ok
+    jmp L_VEC_DEQUE_IWC_END_%out_ok
+L_VEC_DEQUE_IWC_MISS_%out_ok:
+    %out_ok = add 0, 0
+    !__vec_deque_iwc_ok_all_%out_ok
+    !__vec_deque_iwc_in_bounds_%out_ok
+    !__vec_deque_iwc_new_len_%out_ok
+    !__vec_deque_iwc_has_room_%out_ok
+    !__vec_deque_iwc_cap_%out_ok
+    !__vec_deque_iwc_len_%out_ok
+    jmp L_VEC_DEQUE_IWC_END_%out_ok
+L_VEC_DEQUE_IWC_END_%out_ok:
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_TRY_INSERT_WITHIN_CAPACITY_U64 %out_ok, %deque_reg, %index, %value
+    EXPAND VEC_DEQUE_TRY_INSERT_WITHIN_CAPACITY %out_ok, %deque_reg, %index, %value
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INSERT_WITHIN_CAPACITY %out_ok, %deque_reg, %index, %value
+    EXPAND VEC_DEQUE_TRY_INSERT_WITHIN_CAPACITY %out_ok, %deque_reg, %index, %value
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INSERT_WITHIN_CAPACITY_U64 %out_ok, %deque_reg, %index, %value
+    EXPAND VEC_DEQUE_TRY_INSERT_WITHIN_CAPACITY %out_ok, %deque_reg, %index, %value
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_TRY_INSERT_N_WITHIN_CAPACITY %out_ok, %deque_reg, %index, %value, %count
+    __vec_deque_inwc_len_%out_ok = load %deque_reg+VecDeque_len as u64
+    __vec_deque_inwc_in_bounds_%out_ok = ule %index, __vec_deque_inwc_len_%out_ok
+    br __vec_deque_inwc_in_bounds_%out_ok -> L_VEC_DEQUE_INWC_ROOM_%out_ok, L_VEC_DEQUE_INWC_MISS_%out_ok
+L_VEC_DEQUE_INWC_ROOM_%out_ok:
+    __vec_deque_inwc_new_len_%out_ok = add __vec_deque_inwc_len_%out_ok, %count
+    __vec_deque_inwc_cap_%out_ok = load %deque_reg+VecDeque_cap as u64
+    __vec_deque_inwc_room_ok_%out_ok = ule __vec_deque_inwc_new_len_%out_ok, __vec_deque_inwc_cap_%out_ok
+    br __vec_deque_inwc_room_ok_%out_ok -> L_VEC_DEQUE_INWC_SETUP_%out_ok, L_VEC_DEQUE_INWC_NO_ROOM_%out_ok
+L_VEC_DEQUE_INWC_SETUP_%out_ok:
+    __vec_deque_inwc_idx_slot_%out_ok = stack_alloc 8
+    store __vec_deque_inwc_idx_slot_%out_ok+0, 0 as u64
+    !__vec_deque_inwc_room_ok_%out_ok
+    !__vec_deque_inwc_new_len_%out_ok
+    !__vec_deque_inwc_cap_%out_ok
+    !__vec_deque_inwc_in_bounds_%out_ok
+    !__vec_deque_inwc_len_%out_ok
+    jmp L_VEC_DEQUE_INWC_HEAD_%out_ok
+L_VEC_DEQUE_INWC_HEAD_%out_ok:
+    __vec_deque_inwc_idx_%out_ok = load __vec_deque_inwc_idx_slot_%out_ok+0 as u64
+    __vec_deque_inwc_done_%out_ok = eq __vec_deque_inwc_idx_%out_ok, %count
+    br __vec_deque_inwc_done_%out_ok -> L_VEC_DEQUE_INWC_DONE_%out_ok, L_VEC_DEQUE_INWC_BODY_%out_ok
+L_VEC_DEQUE_INWC_BODY_%out_ok:
+    __vec_deque_inwc_pos_%out_ok = add %index, __vec_deque_inwc_idx_%out_ok
+    EXPAND VEC_DEQUE_TRY_INSERT_WITHIN_CAPACITY __vec_deque_inwc_push_ok_%out_ok, %deque_reg, __vec_deque_inwc_pos_%out_ok, %value
+    br __vec_deque_inwc_push_ok_%out_ok -> L_VEC_DEQUE_INWC_NEXT_%out_ok, L_VEC_DEQUE_INWC_FAIL_%out_ok
+L_VEC_DEQUE_INWC_NEXT_%out_ok:
+    __vec_deque_inwc_next_%out_ok = add __vec_deque_inwc_idx_%out_ok, 1
+    store __vec_deque_inwc_idx_slot_%out_ok+0, __vec_deque_inwc_next_%out_ok as u64
+    !__vec_deque_inwc_next_%out_ok
+    !__vec_deque_inwc_push_ok_%out_ok
+    !__vec_deque_inwc_pos_%out_ok
+    !__vec_deque_inwc_done_%out_ok
+    !__vec_deque_inwc_idx_%out_ok
+    jmp L_VEC_DEQUE_INWC_HEAD_%out_ok
+L_VEC_DEQUE_INWC_FAIL_%out_ok:
+    %out_ok = add 0, 0
+    !__vec_deque_inwc_push_ok_%out_ok
+    !__vec_deque_inwc_pos_%out_ok
+    !__vec_deque_inwc_done_%out_ok
+    !__vec_deque_inwc_idx_%out_ok
+    jmp L_VEC_DEQUE_INWC_END_%out_ok
+L_VEC_DEQUE_INWC_DONE_%out_ok:
+    %out_ok = add 0, 1
+    !__vec_deque_inwc_done_%out_ok
+    !__vec_deque_inwc_idx_%out_ok
+    jmp L_VEC_DEQUE_INWC_END_%out_ok
+L_VEC_DEQUE_INWC_NO_ROOM_%out_ok:
+    %out_ok = add 0, 0
+    !__vec_deque_inwc_room_ok_%out_ok
+    !__vec_deque_inwc_new_len_%out_ok
+    !__vec_deque_inwc_cap_%out_ok
+    !__vec_deque_inwc_in_bounds_%out_ok
+    !__vec_deque_inwc_len_%out_ok
+    jmp L_VEC_DEQUE_INWC_END_%out_ok
+L_VEC_DEQUE_INWC_MISS_%out_ok:
+    %out_ok = add 0, 0
+    !__vec_deque_inwc_in_bounds_%out_ok
+    !__vec_deque_inwc_len_%out_ok
+L_VEC_DEQUE_INWC_END_%out_ok:
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_TRY_INSERT_N_WITHIN_CAPACITY_U64 %out_ok, %deque_reg, %index, %value, %count
+    EXPAND VEC_DEQUE_TRY_INSERT_N_WITHIN_CAPACITY %out_ok, %deque_reg, %index, %value, %count
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INSERT_N_WITHIN_CAPACITY %out_ok, %deque_reg, %index, %value, %count
+    EXPAND VEC_DEQUE_TRY_INSERT_N_WITHIN_CAPACITY %out_ok, %deque_reg, %index, %value, %count
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INSERT_N_WITHIN_CAPACITY_U64 %out_ok, %deque_reg, %index, %value, %count
+    EXPAND VEC_DEQUE_TRY_INSERT_N_WITHIN_CAPACITY %out_ok, %deque_reg, %index, %value, %count
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_TRY_INSERT_FROM_SLICE_WITHIN_CAPACITY %out_ok, %deque_reg, %index, %src_slice
+    __vec_deque_ifswc_src_len_%out_ok = load %src_slice+Slice_len as u64
+    __vec_deque_ifswc_len_%out_ok = load %deque_reg+VecDeque_len as u64
+    __vec_deque_ifswc_in_bounds_%out_ok = ule %index, __vec_deque_ifswc_len_%out_ok
+    br __vec_deque_ifswc_in_bounds_%out_ok -> L_VEC_DEQUE_IFSWC_ROOM_%out_ok, L_VEC_DEQUE_IFSWC_MISS_%out_ok
+L_VEC_DEQUE_IFSWC_ROOM_%out_ok:
+    __vec_deque_ifswc_new_len_%out_ok = add __vec_deque_ifswc_len_%out_ok, __vec_deque_ifswc_src_len_%out_ok
+    __vec_deque_ifswc_cap_%out_ok = load %deque_reg+VecDeque_cap as u64
+    __vec_deque_ifswc_room_ok_%out_ok = ule __vec_deque_ifswc_new_len_%out_ok, __vec_deque_ifswc_cap_%out_ok
+    br __vec_deque_ifswc_room_ok_%out_ok -> L_VEC_DEQUE_IFSWC_EMPTY_%out_ok, L_VEC_DEQUE_IFSWC_NO_ROOM_%out_ok
+L_VEC_DEQUE_IFSWC_EMPTY_%out_ok:
+    __vec_deque_ifswc_empty_%out_ok = eq __vec_deque_ifswc_src_len_%out_ok, 0
+    br __vec_deque_ifswc_empty_%out_ok -> L_VEC_DEQUE_IFSWC_EMPTY_HIT_%out_ok, L_VEC_DEQUE_IFSWC_SETUP_%out_ok
+L_VEC_DEQUE_IFSWC_EMPTY_HIT_%out_ok:
+    %out_ok = add 0, 1
+    !__vec_deque_ifswc_empty_%out_ok
+    !__vec_deque_ifswc_room_ok_%out_ok
+    !__vec_deque_ifswc_new_len_%out_ok
+    !__vec_deque_ifswc_in_bounds_%out_ok
+    !__vec_deque_ifswc_cap_%out_ok
+    !__vec_deque_ifswc_len_%out_ok
+    !__vec_deque_ifswc_src_len_%out_ok
+    jmp L_VEC_DEQUE_IFSWC_END_%out_ok
+L_VEC_DEQUE_IFSWC_SETUP_%out_ok:
+    __vec_deque_ifswc_idx_slot_%out_ok = stack_alloc 8
+    store __vec_deque_ifswc_idx_slot_%out_ok+0, 0 as u64
+    !__vec_deque_ifswc_empty_%out_ok
+    !__vec_deque_ifswc_room_ok_%out_ok
+    !__vec_deque_ifswc_new_len_%out_ok
+    !__vec_deque_ifswc_cap_%out_ok
+    !__vec_deque_ifswc_in_bounds_%out_ok
+    !__vec_deque_ifswc_len_%out_ok
+    jmp L_VEC_DEQUE_IFSWC_HEAD_%out_ok
+L_VEC_DEQUE_IFSWC_HEAD_%out_ok:
+    __vec_deque_ifswc_idx_%out_ok = load __vec_deque_ifswc_idx_slot_%out_ok+0 as u64
+    __vec_deque_ifswc_done_%out_ok = eq __vec_deque_ifswc_idx_%out_ok, __vec_deque_ifswc_src_len_%out_ok
+    br __vec_deque_ifswc_done_%out_ok -> L_VEC_DEQUE_IFSWC_DONE_%out_ok, L_VEC_DEQUE_IFSWC_BODY_%out_ok
+L_VEC_DEQUE_IFSWC_BODY_%out_ok:
+    __vec_deque_ifswc_src_ptr_%out_ok = load %src_slice+Slice_ptr as ptr
+    __vec_deque_ifswc_off_%out_ok = mul __vec_deque_ifswc_idx_%out_ok, 8
+    __vec_deque_ifswc_elem_ptr_%out_ok = ptr_add __vec_deque_ifswc_src_ptr_%out_ok, __vec_deque_ifswc_off_%out_ok
+    __vec_deque_ifswc_value_%out_ok = load __vec_deque_ifswc_elem_ptr_%out_ok+0 as u64
+    __vec_deque_ifswc_pos_%out_ok = add %index, __vec_deque_ifswc_idx_%out_ok
+    EXPAND VEC_DEQUE_TRY_INSERT_WITHIN_CAPACITY __vec_deque_ifswc_push_ok_%out_ok, %deque_reg, __vec_deque_ifswc_pos_%out_ok, __vec_deque_ifswc_value_%out_ok
+    br __vec_deque_ifswc_push_ok_%out_ok -> L_VEC_DEQUE_IFSWC_NEXT_%out_ok, L_VEC_DEQUE_IFSWC_FAIL_%out_ok
+L_VEC_DEQUE_IFSWC_NEXT_%out_ok:
+    __vec_deque_ifswc_next_%out_ok = add __vec_deque_ifswc_idx_%out_ok, 1
+    store __vec_deque_ifswc_idx_slot_%out_ok+0, __vec_deque_ifswc_next_%out_ok as u64
+    !__vec_deque_ifswc_next_%out_ok
+    !__vec_deque_ifswc_push_ok_%out_ok
+    !__vec_deque_ifswc_pos_%out_ok
+    !__vec_deque_ifswc_value_%out_ok
+    !__vec_deque_ifswc_elem_ptr_%out_ok
+    !__vec_deque_ifswc_off_%out_ok
+    !__vec_deque_ifswc_src_ptr_%out_ok
+    !__vec_deque_ifswc_done_%out_ok
+    !__vec_deque_ifswc_idx_%out_ok
+    jmp L_VEC_DEQUE_IFSWC_HEAD_%out_ok
+L_VEC_DEQUE_IFSWC_FAIL_%out_ok:
+    %out_ok = add 0, 0
+    !__vec_deque_ifswc_push_ok_%out_ok
+    !__vec_deque_ifswc_pos_%out_ok
+    !__vec_deque_ifswc_value_%out_ok
+    !__vec_deque_ifswc_elem_ptr_%out_ok
+    !__vec_deque_ifswc_off_%out_ok
+    !__vec_deque_ifswc_src_ptr_%out_ok
+    !__vec_deque_ifswc_done_%out_ok
+    !__vec_deque_ifswc_idx_%out_ok
+    !__vec_deque_ifswc_src_len_%out_ok
+    jmp L_VEC_DEQUE_IFSWC_END_%out_ok
+L_VEC_DEQUE_IFSWC_DONE_%out_ok:
+    %out_ok = add 0, 1
+    !__vec_deque_ifswc_done_%out_ok
+    !__vec_deque_ifswc_idx_%out_ok
+    !__vec_deque_ifswc_src_len_%out_ok
+    jmp L_VEC_DEQUE_IFSWC_END_%out_ok
+L_VEC_DEQUE_IFSWC_NO_ROOM_%out_ok:
+    %out_ok = add 0, 0
+    !__vec_deque_ifswc_room_ok_%out_ok
+    !__vec_deque_ifswc_new_len_%out_ok
+    !__vec_deque_ifswc_in_bounds_%out_ok
+    !__vec_deque_ifswc_cap_%out_ok
+    !__vec_deque_ifswc_len_%out_ok
+    !__vec_deque_ifswc_src_len_%out_ok
+    jmp L_VEC_DEQUE_IFSWC_END_%out_ok
+L_VEC_DEQUE_IFSWC_MISS_%out_ok:
+    %out_ok = add 0, 0
+    !__vec_deque_ifswc_in_bounds_%out_ok
+    !__vec_deque_ifswc_len_%out_ok
+    !__vec_deque_ifswc_src_len_%out_ok
+L_VEC_DEQUE_IFSWC_END_%out_ok:
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_TRY_INSERT_FROM_SLICE_WITHIN_CAPACITY_U64 %out_ok, %deque_reg, %index, %src_slice
+    EXPAND VEC_DEQUE_TRY_INSERT_FROM_SLICE_WITHIN_CAPACITY %out_ok, %deque_reg, %index, %src_slice
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INSERT_FROM_SLICE_WITHIN_CAPACITY %out_ok, %deque_reg, %index, %src_slice
+    EXPAND VEC_DEQUE_TRY_INSERT_FROM_SLICE_WITHIN_CAPACITY %out_ok, %deque_reg, %index, %src_slice
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INSERT_FROM_SLICE_WITHIN_CAPACITY_U64 %out_ok, %deque_reg, %index, %src_slice
+    EXPAND VEC_DEQUE_TRY_INSERT_FROM_SLICE_WITHIN_CAPACITY %out_ok, %deque_reg, %index, %src_slice
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_TRY_INSERT_FROM_SLICE_N_WITHIN_CAPACITY %out_ok, %deque_reg, %index, %src_slice, %count
+    __vec_deque_ifsnwc_src_len_%out_ok = load %src_slice+Slice_len as u64
+    __vec_deque_ifsnwc_total_%out_ok = mul __vec_deque_ifsnwc_src_len_%out_ok, %count
+    __vec_deque_ifsnwc_len_%out_ok = load %deque_reg+VecDeque_len as u64
+    __vec_deque_ifsnwc_in_bounds_%out_ok = ule %index, __vec_deque_ifsnwc_len_%out_ok
+    br __vec_deque_ifsnwc_in_bounds_%out_ok -> L_VEC_DEQUE_IFSNWC_ROOM_%out_ok, L_VEC_DEQUE_IFSNWC_MISS_%out_ok
+L_VEC_DEQUE_IFSNWC_ROOM_%out_ok:
+    __vec_deque_ifsnwc_new_len_%out_ok = add __vec_deque_ifsnwc_len_%out_ok, __vec_deque_ifsnwc_total_%out_ok
+    __vec_deque_ifsnwc_cap_%out_ok = load %deque_reg+VecDeque_cap as u64
+    __vec_deque_ifsnwc_room_ok_%out_ok = ule __vec_deque_ifsnwc_new_len_%out_ok, __vec_deque_ifsnwc_cap_%out_ok
+    br __vec_deque_ifsnwc_room_ok_%out_ok -> L_VEC_DEQUE_IFSNWC_SETUP_%out_ok, L_VEC_DEQUE_IFSNWC_NO_ROOM_%out_ok
+L_VEC_DEQUE_IFSNWC_SETUP_%out_ok:
+    __vec_deque_ifsnwc_idx_slot_%out_ok = stack_alloc 8
+    store __vec_deque_ifsnwc_idx_slot_%out_ok+0, 0 as u64
+    !__vec_deque_ifsnwc_in_bounds_%out_ok
+    !__vec_deque_ifsnwc_room_ok_%out_ok
+    !__vec_deque_ifsnwc_new_len_%out_ok
+    !__vec_deque_ifsnwc_cap_%out_ok
+    !__vec_deque_ifsnwc_len_%out_ok
+    !__vec_deque_ifsnwc_total_%out_ok
+    !__vec_deque_ifsnwc_src_len_%out_ok
+    jmp L_VEC_DEQUE_IFSNWC_HEAD_%out_ok
+L_VEC_DEQUE_IFSNWC_HEAD_%out_ok:
+    __vec_deque_ifsnwc_idx_%out_ok = load __vec_deque_ifsnwc_idx_slot_%out_ok+0 as u64
+    __vec_deque_ifsnwc_done_%out_ok = eq __vec_deque_ifsnwc_idx_%out_ok, %count
+    br __vec_deque_ifsnwc_done_%out_ok -> L_VEC_DEQUE_IFSNWC_DONE_%out_ok, L_VEC_DEQUE_IFSNWC_BODY_%out_ok
+L_VEC_DEQUE_IFSNWC_BODY_%out_ok:
+    __vec_deque_ifsnwc_src_len2_%out_ok = load %src_slice+Slice_len as u64
+    __vec_deque_ifsnwc_block_off_%out_ok = mul __vec_deque_ifsnwc_idx_%out_ok, __vec_deque_ifsnwc_src_len2_%out_ok
+    __vec_deque_ifsnwc_pos_%out_ok = add %index, __vec_deque_ifsnwc_block_off_%out_ok
+    EXPAND VEC_DEQUE_TRY_INSERT_FROM_SLICE_WITHIN_CAPACITY __vec_deque_ifsnwc_block_ok_%out_ok, %deque_reg, __vec_deque_ifsnwc_pos_%out_ok, %src_slice
+    br __vec_deque_ifsnwc_block_ok_%out_ok -> L_VEC_DEQUE_IFSNWC_NEXT_%out_ok, L_VEC_DEQUE_IFSNWC_FAIL_%out_ok
+L_VEC_DEQUE_IFSNWC_NEXT_%out_ok:
+    __vec_deque_ifsnwc_next_%out_ok = add __vec_deque_ifsnwc_idx_%out_ok, 1
+    store __vec_deque_ifsnwc_idx_slot_%out_ok+0, __vec_deque_ifsnwc_next_%out_ok as u64
+    !__vec_deque_ifsnwc_next_%out_ok
+    !__vec_deque_ifsnwc_block_ok_%out_ok
+    !__vec_deque_ifsnwc_pos_%out_ok
+    !__vec_deque_ifsnwc_block_off_%out_ok
+    !__vec_deque_ifsnwc_src_len2_%out_ok
+    !__vec_deque_ifsnwc_done_%out_ok
+    !__vec_deque_ifsnwc_idx_%out_ok
+    jmp L_VEC_DEQUE_IFSNWC_HEAD_%out_ok
+L_VEC_DEQUE_IFSNWC_FAIL_%out_ok:
+    %out_ok = add 0, 0
+    !__vec_deque_ifsnwc_block_ok_%out_ok
+    !__vec_deque_ifsnwc_pos_%out_ok
+    !__vec_deque_ifsnwc_block_off_%out_ok
+    !__vec_deque_ifsnwc_src_len2_%out_ok
+    !__vec_deque_ifsnwc_done_%out_ok
+    !__vec_deque_ifsnwc_idx_%out_ok
+    jmp L_VEC_DEQUE_IFSNWC_END_%out_ok
+L_VEC_DEQUE_IFSNWC_DONE_%out_ok:
+    %out_ok = add 0, 1
+    !__vec_deque_ifsnwc_done_%out_ok
+    !__vec_deque_ifsnwc_idx_%out_ok
+    jmp L_VEC_DEQUE_IFSNWC_END_%out_ok
+L_VEC_DEQUE_IFSNWC_NO_ROOM_%out_ok:
+    %out_ok = add 0, 0
+    !__vec_deque_ifsnwc_room_ok_%out_ok
+    !__vec_deque_ifsnwc_new_len_%out_ok
+    !__vec_deque_ifsnwc_in_bounds_%out_ok
+    !__vec_deque_ifsnwc_cap_%out_ok
+    !__vec_deque_ifsnwc_len_%out_ok
+    !__vec_deque_ifsnwc_total_%out_ok
+    !__vec_deque_ifsnwc_src_len_%out_ok
+    jmp L_VEC_DEQUE_IFSNWC_END_%out_ok
+L_VEC_DEQUE_IFSNWC_MISS_%out_ok:
+    %out_ok = add 0, 0
+    !__vec_deque_ifsnwc_in_bounds_%out_ok
+    !__vec_deque_ifsnwc_len_%out_ok
+    !__vec_deque_ifsnwc_total_%out_ok
+    !__vec_deque_ifsnwc_src_len_%out_ok
+L_VEC_DEQUE_IFSNWC_END_%out_ok:
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_TRY_INSERT_FROM_SLICE_N_WITHIN_CAPACITY_U64 %out_ok, %deque_reg, %index, %src_slice, %count
+    EXPAND VEC_DEQUE_TRY_INSERT_FROM_SLICE_N_WITHIN_CAPACITY %out_ok, %deque_reg, %index, %src_slice, %count
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INSERT_FROM_SLICE_N_WITHIN_CAPACITY %out_ok, %deque_reg, %index, %src_slice, %count
+    EXPAND VEC_DEQUE_TRY_INSERT_FROM_SLICE_N_WITHIN_CAPACITY %out_ok, %deque_reg, %index, %src_slice, %count
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_INSERT_FROM_SLICE_N_WITHIN_CAPACITY_U64 %out_ok, %deque_reg, %index, %src_slice, %count
+    EXPAND VEC_DEQUE_TRY_INSERT_FROM_SLICE_N_WITHIN_CAPACITY %out_ok, %deque_reg, %index, %src_slice, %count
+[END_MACRO]
+
+
+[MACRO] VEC_DEQUE_APPEND %deque_reg, %other_deque_reg
+    call @sa_vec_deque_append(&%deque_reg, &%other_deque_reg)
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_TRY_SPLIT_OFF %out_ok, %out_deque, %deque_reg, %index
+    __vec_deque_split_slot_%out_ok = stack_alloc 8
+    __vec_deque_split_ok_%out_ok = call @sa_vec_deque_try_split_off(&%deque_reg, %index, &__vec_deque_split_slot_%out_ok)
+    %out_deque = load __vec_deque_split_slot_%out_ok+0 as ptr
+    %out_ok = __vec_deque_split_ok_%out_ok
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_SPLIT_OFF %out_ok, %out_deque, %deque_reg, %index
+    EXPAND VEC_DEQUE_TRY_SPLIT_OFF %out_ok, %out_deque, %deque_reg, %index
+[END_MACRO]
+
+// Fixed-arity / from-collection constructors over the concrete u64 VecDeque.
+
+[MACRO] VEC_DEQUE_LIT1 %out_deque, %value1
+    EXPAND VEC_DEQUE_NEW %out_deque
+    EXPAND VEC_DEQUE_PUSH_BACK %out_deque, %value1
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_LIT2 %out_deque, %value1, %value2
+    EXPAND VEC_DEQUE_NEW %out_deque
+    EXPAND VEC_DEQUE_PUSH_BACK %out_deque, %value1
+    EXPAND VEC_DEQUE_PUSH_BACK %out_deque, %value2
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_LIT3 %out_deque, %value1, %value2, %value3
+    EXPAND VEC_DEQUE_NEW %out_deque
+    EXPAND VEC_DEQUE_PUSH_BACK %out_deque, %value1
+    EXPAND VEC_DEQUE_PUSH_BACK %out_deque, %value2
+    EXPAND VEC_DEQUE_PUSH_BACK %out_deque, %value3
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_FROM_SLICE_U64 %out_deque, %slice_reg
+    EXPAND VEC_DEQUE_NEW %out_deque
+    __vd_from_len_%out_deque = load %slice_reg+Slice_len as u64
+    __vd_from_idx_slot_%out_deque = stack_alloc 8
+    store __vd_from_idx_slot_%out_deque+0, 0 as u64
+    jmp L_VEC_DEQUE_FROM_SLICE_HEAD_%out_deque
+L_VEC_DEQUE_FROM_SLICE_HEAD_%out_deque:
+    __vd_from_idx_%out_deque = load __vd_from_idx_slot_%out_deque+0 as u64
+    __vd_from_done_%out_deque = eq __vd_from_idx_%out_deque, __vd_from_len_%out_deque
+    br __vd_from_done_%out_deque -> L_VEC_DEQUE_FROM_SLICE_DONE_%out_deque, L_VEC_DEQUE_FROM_SLICE_BODY_%out_deque
+L_VEC_DEQUE_FROM_SLICE_BODY_%out_deque:
+    EXPAND SLICE_GET_U64 __vd_from_val_%out_deque, %slice_reg, __vd_from_idx_%out_deque
+    EXPAND VEC_DEQUE_PUSH_BACK %out_deque, __vd_from_val_%out_deque
+    __vd_from_next_%out_deque = add __vd_from_idx_%out_deque, 1
+    store __vd_from_idx_slot_%out_deque+0, __vd_from_next_%out_deque as u64
+    !__vd_from_next_%out_deque
+    !__vd_from_val_%out_deque
+    !__vd_from_done_%out_deque
+    !__vd_from_idx_%out_deque
+    jmp L_VEC_DEQUE_FROM_SLICE_HEAD_%out_deque
+L_VEC_DEQUE_FROM_SLICE_DONE_%out_deque:
+    !__vd_from_done_%out_deque
+    !__vd_from_idx_%out_deque
+    !__vd_from_len_%out_deque
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_FROM_SLICE_U64.
+[MACRO] VEC_DEQUE_FROM_SLICE %out_deque, %slice_reg
+    EXPAND VEC_DEQUE_FROM_SLICE_U64 %out_deque, %slice_reg
+[END_MACRO]
+
+[MACRO] VEC_DEQUE_FROM_VEC_U64 %out_deque, %vec_reg
+    EXPAND VEC_AS_SLICE __vec_deque_from_vec_slice_%out_deque, %vec_reg
+    EXPAND VEC_DEQUE_FROM_SLICE_U64 %out_deque, __vec_deque_from_vec_slice_%out_deque
+    !__vec_deque_from_vec_slice_%out_deque
+[END_MACRO]
+
+// Rust method-name alias over VEC_DEQUE_FROM_VEC_U64.
+[MACRO] VEC_DEQUE_FROM_VEC %out_deque, %vec_reg
+    EXPAND VEC_DEQUE_FROM_VEC_U64 %out_deque, %vec_reg
+[END_MACRO]
+
+// Rust Default-style empty VecDeque constructor alias.
+
+[MACRO] VEC_DEQUE_DEFAULT %out_deque
+    EXPAND VEC_DEQUE_NEW %out_deque
+[END_MACRO]