@salang/sa 0.1.3 → 0.1.4

package/sa_std/btree_map.sa

@@ -0,0 +1,2210 @@
+// Concrete ordered map backed by a sorted entry array.
+@import "core/mem.sa"
+@import "core/slice.sal"
+@import "alloc/vec.sa"
+@import "num.sa"
+@import "btree_map.sal"
+@import "hash.sa"
+
+@btree_map_entry_cmp(&lhs: ptr, &rhs: ptr) -> i32:
+L_ENTRY:
+    cmp = call @btree_map_entry_cmp_at(&lhs, &rhs, 0)
+    return cmp
+
+@btree_map_entry_cmp_at(&lhs: ptr, &rhs: ptr, idx: u64) -> i32:
+L_ENTRY:
+    lhs_len = load lhs+Slice_len as u64
+    rhs_len = load rhs+Slice_len as u64
+    lhs_done = eq idx, lhs_len
+    br lhs_done -> L_LHS_DONE, L_BODY
+
+L_BODY:
+    rhs_done = eq idx, rhs_len
+    br rhs_done -> L_RHS_DONE, L_COMPARE
+
+L_COMPARE:
+    lhs_ptr = load lhs+Slice_ptr as ptr
+    rhs_ptr = load rhs+Slice_ptr as ptr
+    lhs_ip = ptr_add lhs_ptr, idx
+    rhs_ip = ptr_add rhs_ptr, idx
+    lhs_byte = load lhs_ip+0 as u8
+    rhs_byte = load rhs_ip+0 as u8
+    lhs_lt = ult lhs_byte, rhs_byte
+    br lhs_lt -> L_LESS, L_GT_CHECK
+
+L_GT_CHECK:
+    lhs_gt = ugt lhs_byte, rhs_byte
+    br lhs_gt -> L_GREATER, L_RECURSE
+
+L_RECURSE:
+    next_idx = add idx, 1
+    cmp = call @btree_map_entry_cmp_at(&lhs, &rhs, next_idx)
+    !next_idx
+    !lhs_lt
+    !rhs_byte
+    !lhs_byte
+    !rhs_ip
+    !lhs_ip
+    !rhs_done
+    !lhs_done
+    !idx
+    !rhs_len
+    !lhs_len
+    !rhs
+    !lhs
+    return cmp
+
+L_LESS:
+    cmp_result = sub 0, 1
+    !lhs_lt
+    !rhs_byte
+    !lhs_byte
+    !rhs_ip
+    !lhs_ip
+    !rhs_done
+    !lhs_done
+    !idx
+    !rhs_len
+    !lhs_len
+    !rhs
+    !lhs
+    return cmp_result
+
+L_GREATER:
+    cmp_result = add 0, 1
+    !lhs_lt
+    !rhs_byte
+    !lhs_byte
+    !rhs_ip
+    !lhs_ip
+    !rhs_done
+    !lhs_done
+    !idx
+    !rhs_len
+    !lhs_len
+    !rhs
+    !lhs
+    return cmp_result
+
+L_LHS_DONE:
+    rhs_done2 = eq idx, rhs_len
+    br rhs_done2 -> L_EQUAL, L_LHS_SHORTER
+
+L_RHS_DONE:
+    cmp_result = add 0, 1
+    !rhs_done
+    !lhs_done
+    !idx
+    !rhs_len
+    !lhs_len
+    !rhs
+    !lhs
+    return cmp_result
+
+L_LHS_SHORTER:
+    cmp_result = sub 0, 1
+    !rhs_done2
+    !lhs_done
+    !idx
+    !rhs_len
+    !lhs_len
+    !rhs
+    !lhs
+    return cmp_result
+
+L_EQUAL:
+    !rhs_done2
+    !lhs_done
+    !idx
+    !rhs_len
+    !lhs_len
+    !rhs
+    !lhs
+    return 0
+
+@btree_map_find(&entries: ptr, len: u64, &key: ptr, &out_index: ptr, &out_found: ptr) -> void:
+L_ENTRY:
+    store out_index+0, 0 as u64
+    store out_found+0, 0 as u64
+    call @btree_map_find_at(&entries, len, &key, 0, &out_index, &out_found)
+    !out_found
+    !out_index
+    !key
+    !len
+    !entries
+    return
+
+@btree_map_find_at(&entries: ptr, len: u64, &key: ptr, idx: u64, &out_index: ptr, &out_found: ptr) -> void:
+L_ENTRY:
+    done = eq idx, len
+    br done -> L_FIND_DONE, L_FIND_BODY
+
+L_FIND_BODY:
+    entry_off = mul idx, BTreeMapEntry_SIZE
+    entry = ptr_add entries, entry_off
+    cmp = call @btree_map_entry_cmp(&entry, &key)
+    is_equal = eq cmp, 0
+    br is_equal -> L_FIND_FOUND, L_FIND_GT_CHECK
+
+L_FIND_GT_CHECK:
+    is_greater = sgt cmp, 0
+    br is_greater -> L_FIND_INSERT_POS, L_FIND_RECURSE
+
+L_FIND_RECURSE:
+    next_idx = add idx, 1
+    call @btree_map_find_at(&entries, len, &key, next_idx, &out_index, &out_found)
+    !next_idx
+    !is_equal
+    !cmp
+    !entry
+    !entry_off
+    !idx
+    !done
+    !len
+    !key
+    !out_index
+    !out_found
+    !entries
+    return
+
+L_FIND_FOUND:
+    store out_index+0, idx as u64
+    store out_found+0, 1 as u64
+    !is_equal
+    !cmp
+    !entry
+    !entry_off
+    !idx
+    !done
+    !len
+    !key
+    !out_index
+    !out_found
+    !entries
+    return
+
+L_FIND_INSERT_POS:
+    store out_index+0, idx as u64
+    !is_equal
+    !cmp
+    !entry
+    !entry_off
+    !idx
+    !done
+    !len
+    !key
+    !out_index
+    !out_found
+    !entries
+    return
+
+L_FIND_DONE:
+    store out_index+0, len as u64
+    !done
+    !len
+    !key
+    !out_index
+    !out_found
+    !entries
+    return
+
+@btree_map_hash_entries_str_u64(&hasher: ptr, entries: ptr, len: u64, idx: u64) -> void:
+L_ENTRY:
+    done = eq idx, len
+    br done -> L_BTREE_MAP_HASH_DONE, L_BTREE_MAP_HASH_BODY
+
+L_BTREE_MAP_HASH_BODY:
+    entry_off = mul idx, BTreeMapEntry_SIZE
+    entry = ptr_add entries, entry_off
+    value = load entry+BTreeMapEntry_value as u64
+    EXPAND DEFAULT_HASHER_WRITE_STR hasher, entry
+    EXPAND DEFAULT_HASHER_WRITE_U64 hasher, value
+    next_idx = add idx, 1
+    call @btree_map_hash_entries_str_u64(&hasher, entries, len, next_idx)
+    !next_idx
+    !value
+    !entry
+    !entry_off
+    !done
+    !idx
+    !len
+    !entries
+    !hasher
+    return
+
+L_BTREE_MAP_HASH_DONE:
+    !done
+    !idx
+    !len
+    !entries
+    !hasher
+    return
+
+@btree_map_write_hash_str_u64(&hasher: ptr, &map: ptr) -> void:
+L_ENTRY:
+    len = load map+BTreeMap_len as u64
+    entries = load map+BTreeMap_entries as ptr
+    EXPAND DEFAULT_HASHER_WRITE_LENGTH_PREFIX hasher, len
+    call @btree_map_hash_entries_str_u64(&hasher, entries, len, 0)
+    !entries
+    !len
+    !map
+    !hasher
+    return
+
+@btree_map_grow(&map: ptr) -> void:
+L_ENTRY:
+    old_entries = take map+BTreeMap_entries
+    old_cap = load map+BTreeMap_cap as u64
+    old_len = load map+BTreeMap_len as u64
+    EXPAND NUM_U64_CHECKED_ADD next_cap_ok, next_cap, old_cap, old_cap
+    br next_cap_ok -> L_GROW_CAP_OK, L_GROW_CAP_OVERFLOW
+
+L_GROW_CAP_OVERFLOW:
+    panic(2001)
+
+L_GROW_CAP_OK:
+    EXPAND NUM_U64_CHECKED_MUL copy_bytes_ok, copy_bytes, old_len, BTreeMapEntry_SIZE
+    br copy_bytes_ok -> L_GROW_COPY_BYTES_OK, L_GROW_COPY_BYTES_OVERFLOW
+
+L_GROW_COPY_BYTES_OVERFLOW:
+    panic(2002)
+
+L_GROW_COPY_BYTES_OK:
+    EXPAND NUM_U64_CHECKED_MUL new_bytes_ok, new_bytes, next_cap, BTreeMapEntry_SIZE
+    br new_bytes_ok -> L_GROW_ALLOC_BYTES_OK, L_GROW_ALLOC_BYTES_OVERFLOW
+
+L_GROW_ALLOC_BYTES_OVERFLOW:
+    panic(2003)
+
+L_GROW_ALLOC_BYTES_OK:
+    new_entries = alloc new_bytes
+    call @sa_mem_copy(&new_entries, &old_entries, copy_bytes)
+    store map+BTreeMap_entries, new_entries as ptr
+    store map+BTreeMap_cap, next_cap as u64
+    !new_bytes_ok
+    !copy_bytes_ok
+    !next_cap_ok
+    !copy_bytes
+    !new_bytes
+    !old_len
+    !old_cap
+    !old_entries
+    ^new_entries
+    !next_cap
+    !map
+    return
+
+@export sa_btree_map_new() -> ^ptr:
+L_ENTRY:
+    map = alloc BTreeMap_SIZE
+    initial_bytes = mul BTreeMap_INITIAL_CAP, BTreeMapEntry_SIZE
+    entries = alloc initial_bytes
+    call @sa_mem_set(&entries, 0, initial_bytes)
+    store map+BTreeMap_entries, entries as ptr
+    store map+BTreeMap_cap, BTreeMap_INITIAL_CAP as u64
+    store map+BTreeMap_len, 0 as u64
+    !initial_bytes
+    ^entries
+    return map
+
+@export sa_btree_map_free(^map: ptr) -> void:
+L_ENTRY:
+    entries = take map+BTreeMap_entries
+    !entries
+    !map
+    return
+
+@export sa_btree_map_len(&map: ptr) -> u64:
+L_ENTRY:
+    len = load map+BTreeMap_len as u64
+    !map
+    return len
+
+@export sa_btree_map_is_empty(&map: ptr) -> i32:
+L_ENTRY:
+    len = load map+BTreeMap_len as u64
+    empty = eq len, 0
+    result = empty as i32
+    !len
+    !map
+    return result
+
+@export sa_btree_map_contains_key(&map: ptr, &key: ptr) -> i32:
+L_ENTRY:
+    find_index_slot = stack_alloc 8
+    find_found_slot = stack_alloc 8
+    entries = load map+BTreeMap_entries as ptr
+    len = load map+BTreeMap_len as u64
+    call @btree_map_find(&entries, len, &key, &find_index_slot, &find_found_slot)
+    found = load find_found_slot+0 as u64
+    present = ne found, 0
+    result = present as i32
+    !found
+    !len
+    !key
+    !entries
+    !map
+    return result
+
+@export sa_btree_map_clear(&map: ptr) -> void:
+L_ENTRY:
+    entries = load map+BTreeMap_entries as ptr
+    cap = load map+BTreeMap_cap as u64
+    EXPAND NUM_U64_CHECKED_MUL clear_bytes_ok, bytes, cap, BTreeMapEntry_SIZE
+    br clear_bytes_ok -> L_CLEAR_BYTES_OK, L_CLEAR_BYTES_OVERFLOW
+
+L_CLEAR_BYTES_OVERFLOW:
+    panic(2004)
+
+L_CLEAR_BYTES_OK:
+    has_entries = ne entries, 0
+    br has_entries -> L_CLEAR_ENTRIES, L_CLEAR_DONE
+
+L_CLEAR_ENTRIES:
+    call @sa_mem_set(&entries, 0, bytes)
+    jmp L_CLEAR_DONE
+
+L_CLEAR_DONE:
+    store map+BTreeMap_len, 0 as u64
+    !clear_bytes_ok
+    !bytes
+    !has_entries
+    !cap
+    !entries
+    !map
+    return
+
+@export sa_btree_map_remove(&map: ptr, &key: ptr) -> u64:
+L_ENTRY:
+    find_index_slot = stack_alloc 8
+    find_found_slot = stack_alloc 8
+    entries = load map+BTreeMap_entries as ptr
+    len = load map+BTreeMap_len as u64
+    call @btree_map_find(&entries, len, &key, &find_index_slot, &find_found_slot)
+    find_index = load find_index_slot+0 as u64
+    found = load find_found_slot+0 as u64
+    is_found = ne found, 0
+    br is_found -> L_REMOVE_HIT, L_REMOVE_MISS
+
+L_REMOVE_HIT:
+    remove_off = mul find_index, BTreeMapEntry_SIZE
+    remove_entry = ptr_add entries, remove_off
+    removed_value = load remove_entry+BTreeMapEntry_value as u64
+    removed_value_slot = stack_alloc 8
+    store removed_value_slot+0, removed_value as u64
+    last_index = sub len, 1
+    shift_slot = stack_alloc 8
+    store shift_slot+0, find_index as u64
+    jmp L_REMOVE_SHIFT_LOOP
+
+L_REMOVE_SHIFT_LOOP:
+    shift_idx = load shift_slot+0 as u64
+    needs_shift = ult shift_idx, last_index
+    br needs_shift -> L_REMOVE_SHIFT_BODY, L_REMOVE_DONE
+
+L_REMOVE_SHIFT_BODY:
+    next_idx = add shift_idx, 1
+    src_off = mul next_idx, BTreeMapEntry_SIZE
+    dst_off = mul shift_idx, BTreeMapEntry_SIZE
+    src_entry = ptr_add entries, src_off
+    dst_entry = ptr_add entries, dst_off
+    src_key_ptr = load src_entry+BTreeMapEntry_key_ptr as ptr
+    src_key_len = load src_entry+BTreeMapEntry_key_len as u64
+    src_value = load src_entry+BTreeMapEntry_value as u64
+    store dst_entry+BTreeMapEntry_key_ptr, src_key_ptr as ptr
+    store dst_entry+BTreeMapEntry_key_len, src_key_len as u64
+    store dst_entry+BTreeMapEntry_value, src_value as u64
+    next_shift = add shift_idx, 1
+    store shift_slot+0, next_shift as u64
+    !src_value
+    !src_key_len
+    !src_key_ptr
+    !dst_entry
+    !src_entry
+    !dst_off
+    !src_off
+    !next_idx
+    !next_shift
+    !shift_idx
+    !needs_shift
+    jmp L_REMOVE_SHIFT_LOOP
+
+L_REMOVE_DONE:
+    last_off = mul last_index, BTreeMapEntry_SIZE
+    last_entry = ptr_add entries, last_off
+    store last_entry+BTreeMapEntry_key_ptr, 0 as ptr
+    store last_entry+BTreeMapEntry_key_len, 0 as u64
+    store last_entry+BTreeMapEntry_value, 0 as u64
+    next_len = sub len, 1
+    store map+BTreeMap_len, next_len as u64
+    !last_entry
+    !last_off
+    !next_len
+    !last_index
+    !remove_entry
+    !remove_off
+    !is_found
+    !found
+    !find_index
+    !len
+    !entries
+    !key
+    !map
+    removed_value2 = load removed_value_slot+0 as u64
+    return removed_value2
+
+L_REMOVE_MISS:
+    !is_found
+    !found
+    !find_index
+    !len
+    !entries
+    !key
+    !map
+    return 0
+
+@export sa_btree_map_get(&map: ptr, &key: ptr) -> u64:
+L_ENTRY:
+    find_index_slot = stack_alloc 8
+    find_found_slot = stack_alloc 8
+    value_off = add 0, 0
+    value_entry = 0 as ptr
+    entries = load map+BTreeMap_entries as ptr
+    len = load map+BTreeMap_len as u64
+    call @btree_map_find(&entries, len, &key, &find_index_slot, &find_found_slot)
+    find_index = load find_index_slot+0 as u64
+    found = load find_found_slot+0 as u64
+    is_found = ne found, 0
+    br is_found -> L_GET_HIT, L_GET_MISS
+
+L_GET_HIT:
+    value_off = mul find_index, BTreeMapEntry_SIZE
+    value_entry = ptr_add entries, value_off
+    value = load value_entry+BTreeMapEntry_value as u64
+    !value_entry
+    !value_off
+    !is_found
+    !found
+    !find_index
+    !len
+    !key
+    !entries
+    !map
+    return value
+
+L_GET_MISS:
+    !value_entry
+    !value_off
+    !is_found
+    !found
+    !find_index
+    !len
+    !key
+    !entries
+    !map
+    return 0
+
+@export sa_btree_map_try_get(&map: ptr, &key: ptr, &out_value_slot: ptr) -> i32:
+L_ENTRY:
+    find_index_slot = stack_alloc 8
+    find_found_slot = stack_alloc 8
+    entries = load map+BTreeMap_entries as ptr
+    len = load map+BTreeMap_len as u64
+    call @btree_map_find(&entries, len, &key, &find_index_slot, &find_found_slot)
+    find_index = load find_index_slot+0 as u64
+    found = load find_found_slot+0 as u64
+    is_found = ne found, 0
+    br is_found -> L_TRY_GET_HIT, L_TRY_GET_MISS
+
+L_TRY_GET_HIT:
+    value_off = mul find_index, BTreeMapEntry_SIZE
+    value_entry = ptr_add entries, value_off
+    value = load value_entry+BTreeMapEntry_value as u64
+    store out_value_slot+0, value as u64
+    !value
+    !value_entry
+    !value_off
+    !is_found
+    !found
+    !find_index
+    !len
+    !entries
+    !out_value_slot
+    !key
+    !map
+    return 1
+
+L_TRY_GET_MISS:
+    store out_value_slot+0, 0 as u64
+    !is_found
+    !found
+    !find_index
+    !len
+    !entries
+    !out_value_slot
+    !key
+    !map
+    return 0
+
+@export sa_btree_map_try_get_key_value(&map: ptr, &key: ptr, &out_key: ptr, &out_value_slot: ptr) -> i32:
+L_ENTRY:
+    find_index_slot = stack_alloc 8
+    find_found_slot = stack_alloc 8
+    entries = load map+BTreeMap_entries as ptr
+    len = load map+BTreeMap_len as u64
+    call @btree_map_find(&entries, len, &key, &find_index_slot, &find_found_slot)
+    find_index = load find_index_slot+0 as u64
+    found = load find_found_slot+0 as u64
+    is_found = ne found, 0
+    br is_found -> L_GET_KEY_VALUE_HIT, L_GET_KEY_VALUE_MISS
+
+L_GET_KEY_VALUE_HIT:
+    entry_off = mul find_index, BTreeMapEntry_SIZE
+    entry = ptr_add entries, entry_off
+    key_ptr = load entry+BTreeMapEntry_key_ptr as ptr
+    key_len = load entry+BTreeMapEntry_key_len as u64
+    value = load entry+BTreeMapEntry_value as u64
+    store out_key+Slice_ptr, key_ptr as ptr
+    store out_key+Slice_len, key_len as u64
+    store out_value_slot+0, value as u64
+    !value
+    !key_len
+    !key_ptr
+    !entry
+    !entry_off
+    !is_found
+    !found
+    !find_index
+    !len
+    !entries
+    !out_value_slot
+    !out_key
+    !key
+    !map
+    return 1
+
+L_GET_KEY_VALUE_MISS:
+    store out_key+Slice_ptr, 0 as ptr
+    store out_key+Slice_len, 0 as u64
+    store out_value_slot+0, 0 as u64
+    !is_found
+    !found
+    !find_index
+    !len
+    !entries
+    !out_value_slot
+    !out_key
+    !key
+    !map
+    return 0
+
+@export sa_btree_map_get_mut_ptr(&map: ptr, &key: ptr, &out_ptr_slot: ptr) -> i32:
+L_ENTRY:
+    find_index_slot = stack_alloc 8
+    find_found_slot = stack_alloc 8
+    entries = load map+BTreeMap_entries as ptr
+    len = load map+BTreeMap_len as u64
+    call @btree_map_find(&entries, len, &key, &find_index_slot, &find_found_slot)
+    find_index = load find_index_slot+0 as u64
+    found = load find_found_slot+0 as u64
+    is_found = ne found, 0
+    br is_found -> L_GET_MUT_HIT, L_GET_MUT_MISS
+
+L_GET_MUT_HIT:
+    value_off = mul find_index, BTreeMapEntry_SIZE
+    value_entry = ptr_add entries, value_off
+    value_ptr = ptr_add value_entry, BTreeMapEntry_value
+    store out_ptr_slot+0, value_ptr as ptr
+    !value_ptr
+    !value_entry
+    !value_off
+    !is_found
+    !found
+    !find_index
+    !len
+    !entries
+    !out_ptr_slot
+    !key
+    !map
+    return 1
+
+L_GET_MUT_MISS:
+    store out_ptr_slot+0, 0 as ptr
+    !is_found
+    !found
+    !find_index
+    !len
+    !entries
+    !out_ptr_slot
+    !key
+    !map
+    return 0
+
+@export sa_btree_map_first_entry_mut_ptr(&map: ptr, &out_key: ptr, &out_ptr_slot: ptr) -> i32:
+L_ENTRY:
+    len = load map+BTreeMap_len as u64
+    empty = eq len, 0
+    br empty -> L_FIRST_ENTRY_MUT_MISS, L_FIRST_ENTRY_MUT_HIT
+
+L_FIRST_ENTRY_MUT_HIT:
+    entries = load map+BTreeMap_entries as ptr
+    entry = ptr_add entries, 0
+    key_ptr = load entry+BTreeMapEntry_key_ptr as ptr
+    key_len = load entry+BTreeMapEntry_key_len as u64
+    value_ptr = ptr_add entry, BTreeMapEntry_value
+    store out_key+Slice_ptr, key_ptr as ptr
+    store out_key+Slice_len, key_len as u64
+    store out_ptr_slot+0, value_ptr as ptr
+    !value_ptr
+    !key_len
+    !key_ptr
+    !entry
+    !entries
+    !empty
+    !len
+    !out_ptr_slot
+    !out_key
+    !map
+    return 1
+
+L_FIRST_ENTRY_MUT_MISS:
+    store out_key+Slice_ptr, 0 as ptr
+    store out_key+Slice_len, 0 as u64
+    store out_ptr_slot+0, 0 as ptr
+    !empty
+    !len
+    !out_ptr_slot
+    !out_key
+    !map
+    return 0
+
+@export sa_btree_map_last_entry_mut_ptr(&map: ptr, &out_key: ptr, &out_ptr_slot: ptr) -> i32:
+L_ENTRY:
+    len = load map+BTreeMap_len as u64
+    empty = eq len, 0
+    br empty -> L_LAST_ENTRY_MUT_MISS, L_LAST_ENTRY_MUT_HIT
+
+L_LAST_ENTRY_MUT_HIT:
+    entries = load map+BTreeMap_entries as ptr
+    last_index = sub len, 1
+    entry_off = mul last_index, BTreeMapEntry_SIZE
+    entry = ptr_add entries, entry_off
+    key_ptr = load entry+BTreeMapEntry_key_ptr as ptr
+    key_len = load entry+BTreeMapEntry_key_len as u64
+    value_ptr = ptr_add entry, BTreeMapEntry_value
+    store out_key+Slice_ptr, key_ptr as ptr
+    store out_key+Slice_len, key_len as u64
+    store out_ptr_slot+0, value_ptr as ptr
+    !value_ptr
+    !key_len
+    !key_ptr
+    !entry
+    !entry_off
+    !last_index
+    !entries
+    !empty
+    !len
+    !out_ptr_slot
+    !out_key
+    !map
+    return 1
+
+L_LAST_ENTRY_MUT_MISS:
+    store out_key+Slice_ptr, 0 as ptr
+    store out_key+Slice_len, 0 as u64
+    store out_ptr_slot+0, 0 as ptr
+    !empty
+    !len
+    !out_ptr_slot
+    !out_key
+    !map
+    return 0
+
+@export sa_btree_map_try_get_disjoint_mut_ptrs(&map: ptr, &key_a: ptr, &key_b: ptr, &out_ptr_a_slot: ptr, &out_ptr_b_slot: ptr) -> i32:
+L_ENTRY:
+    key_cmp = call @btree_map_entry_cmp(&key_a, &key_b)
+    same_key = eq key_cmp, 0
+    br same_key -> L_BTREE_DISJOINT_MUT_SAME, L_BTREE_DISJOINT_MUT_LOOKUP_A
+
+L_BTREE_DISJOINT_MUT_LOOKUP_A:
+    found_a = call @sa_btree_map_get_mut_ptr(&map, &key_a, &out_ptr_a_slot)
+    has_a = ne found_a, 0
+    br has_a -> L_BTREE_DISJOINT_MUT_LOOKUP_B, L_BTREE_DISJOINT_MUT_MISS_A
+
+L_BTREE_DISJOINT_MUT_LOOKUP_B:
+    found_b = call @sa_btree_map_get_mut_ptr(&map, &key_b, &out_ptr_b_slot)
+    has_b = ne found_b, 0
+    br has_b -> L_BTREE_DISJOINT_MUT_HIT, L_BTREE_DISJOINT_MUT_MISS_B
+
+L_BTREE_DISJOINT_MUT_HIT:
+    !has_b
+    !found_b
+    !has_a
+    !found_a
+    !same_key
+    !key_cmp
+    !out_ptr_b_slot
+    !out_ptr_a_slot
+    !key_b
+    !key_a
+    !map
+    return 1
+
+L_BTREE_DISJOINT_MUT_MISS_B:
+    store out_ptr_a_slot+0, 0 as ptr
+    store out_ptr_b_slot+0, 0 as ptr
+    !has_b
+    !found_b
+    !has_a
+    !found_a
+    !same_key
+    !key_cmp
+    !out_ptr_b_slot
+    !out_ptr_a_slot
+    !key_b
+    !key_a
+    !map
+    return 0
+
+L_BTREE_DISJOINT_MUT_MISS_A:
+    store out_ptr_a_slot+0, 0 as ptr
+    store out_ptr_b_slot+0, 0 as ptr
+    !has_a
+    !found_a
+    !same_key
+    !key_cmp
+    !out_ptr_b_slot
+    !out_ptr_a_slot
+    !key_b
+    !key_a
+    !map
+    return 0
+
+L_BTREE_DISJOINT_MUT_SAME:
+    store out_ptr_a_slot+0, 0 as ptr
+    store out_ptr_b_slot+0, 0 as ptr
+    !same_key
+    !key_cmp
+    !out_ptr_b_slot
+    !out_ptr_a_slot
+    !key_b
+    !key_a
+    !map
+    return 0
+
+@export sa_btree_map_first_key_value(&map: ptr, &out_key: ptr, &out_value_slot: ptr) -> i32:
+L_ENTRY:
+    len = load map+BTreeMap_len as u64
+    empty = eq len, 0
+    br empty -> L_FIRST_MISS, L_FIRST_HIT
+
+L_FIRST_HIT:
+    entries = load map+BTreeMap_entries as ptr
+    entry_off = add 0, 0
+    entry = ptr_add entries, entry_off
+    key_ptr = load entry+BTreeMapEntry_key_ptr as ptr
+    key_len = load entry+BTreeMapEntry_key_len as u64
+    value = load entry+BTreeMapEntry_value as u64
+    store out_key+Slice_ptr, key_ptr as ptr
+    store out_key+Slice_len, key_len as u64
+    store out_value_slot+0, value as u64
+    !value
+    !key_len
+    !key_ptr
+    !entry
+    !entry_off
+    !entries
+    !empty
+    !len
+    !out_value_slot
+    !out_key
+    !map
+    return 1
+
+L_FIRST_MISS:
+    store out_key+Slice_ptr, 0 as ptr
+    store out_key+Slice_len, 0 as u64
+    store out_value_slot+0, 0 as u64
+    !empty
+    !len
+    !out_value_slot
+    !out_key
+    !map
+    return 0
+
+@export sa_btree_map_last_key_value(&map: ptr, &out_key: ptr, &out_value_slot: ptr) -> i32:
+L_ENTRY:
+    len = load map+BTreeMap_len as u64
+    empty = eq len, 0
+    br empty -> L_LAST_MISS, L_LAST_HIT
+
+L_LAST_HIT:
+    entries = load map+BTreeMap_entries as ptr
+    last_index = sub len, 1
+    entry_off = mul last_index, BTreeMapEntry_SIZE
+    entry = ptr_add entries, entry_off
+    key_ptr = load entry+BTreeMapEntry_key_ptr as ptr
+    key_len = load entry+BTreeMapEntry_key_len as u64
+    value = load entry+BTreeMapEntry_value as u64
+    store out_key+Slice_ptr, key_ptr as ptr
+    store out_key+Slice_len, key_len as u64
+    store out_value_slot+0, value as u64
+    !value
+    !key_len
+    !key_ptr
+    !entry
+    !entry_off
+    !last_index
+    !entries
+    !empty
+    !len
+    !out_value_slot
+    !out_key
+    !map
+    return 1
+
+L_LAST_MISS:
+    store out_key+Slice_ptr, 0 as ptr
+    store out_key+Slice_len, 0 as u64
+    store out_value_slot+0, 0 as u64
+    !empty
+    !len
+    !out_value_slot
+    !out_key
+    !map
+    return 0
+
+@export sa_btree_map_insert(&map: ptr, &key: ptr, value: u64) -> void:
+L_ENTRY:
+    find_index_slot = stack_alloc 8
+    find_found_slot = stack_alloc 8
+    entries = load map+BTreeMap_entries as ptr
+    cap = load map+BTreeMap_cap as u64
+    len = load map+BTreeMap_len as u64
+    call @btree_map_find(&entries, len, &key, &find_index_slot, &find_found_slot)
+    find_index = load find_index_slot+0 as u64
+    found = load find_found_slot+0 as u64
+    br found -> L_INSERT_UPDATE, L_INSERT_NEED_GROW
+
+L_INSERT_UPDATE:
+    update_off = mul find_index, BTreeMapEntry_SIZE
+    update_entry = ptr_add entries, update_off
+    store update_entry+BTreeMapEntry_value, value as u64
+    !update_entry
+    !update_off
+    !find_index
+    !len
+    !cap
+    !value
+    !key
+    !entries
+    !map
+    return
+
+L_INSERT_NEED_GROW:
+    len_is_cap = eq len, cap
+    br len_is_cap -> L_INSERT_GROW, L_INSERT_RELEASE
+
+L_INSERT_GROW:
+    !entries
+    !len
+    !cap
+    call @btree_map_grow(&map)
+    jmp L_INSERT_READY
+
+L_INSERT_RELEASE:
+    !entries
+    !len
+    !cap
+    jmp L_INSERT_READY
+
+L_INSERT_READY:
+    entries2 = load map+BTreeMap_entries as ptr
+    len2 = load map+BTreeMap_len as u64
+    shift_slot = stack_alloc 8
+    store shift_slot+0, len2 as u64
+    jmp L_INSERT_SHIFT_LOOP
+
+L_INSERT_SHIFT_LOOP:
+    shift_idx = load shift_slot+0 as u64
+    done = eq shift_idx, find_index
+    br done -> L_INSERT_WRITE, L_INSERT_SHIFT_BODY
+
+L_INSERT_SHIFT_BODY:
+    prev_idx = sub shift_idx, 1
+    prev_off = mul prev_idx, BTreeMapEntry_SIZE
+    dst_off = mul shift_idx, BTreeMapEntry_SIZE
+    prev_entry = ptr_add entries2, prev_off
+    dst_entry = ptr_add entries2, dst_off
+    prev_key_ptr = load prev_entry+BTreeMapEntry_key_ptr as ptr
+    prev_key_len = load prev_entry+BTreeMapEntry_key_len as u64
+    prev_value = load prev_entry+BTreeMapEntry_value as u64
+    store dst_entry+BTreeMapEntry_key_ptr, prev_key_ptr as ptr
+    store dst_entry+BTreeMapEntry_key_len, prev_key_len as u64
+    store dst_entry+BTreeMapEntry_value, prev_value as u64
+    next_shift = sub shift_idx, 1
+    store shift_slot+0, next_shift as u64
+    !prev_idx
+    !next_shift
+    !prev_value
+    !prev_key_len
+    !prev_key_ptr
+    !dst_entry
+    !prev_entry
+    !dst_off
+    !prev_off
+    !shift_idx
+    !done
+    jmp L_INSERT_SHIFT_LOOP
+
+L_INSERT_WRITE:
+    insert_off = mul find_index, BTreeMapEntry_SIZE
+    insert_entry = ptr_add entries2, insert_off
+    key_ptr = load key+Slice_ptr as ptr
+    key_len = load key+Slice_len as u64
+    store insert_entry+BTreeMapEntry_key_ptr, key_ptr as ptr
+    store insert_entry+BTreeMapEntry_key_len, key_len as u64
+    store insert_entry+BTreeMapEntry_value, value as u64
+    next_len = add len2, 1
+    store map+BTreeMap_len, next_len as u64
+    !key_len
+    !key_ptr
+    !insert_entry
+    !insert_off
+    !entries2
+    !len2
+    !value
+    !key
+    !find_index
+    !map
+    return
+
+@export sa_btree_map_insert_old(&map: ptr, &key: ptr, value: u64, &out_old_value_slot: ptr) -> i32:
+L_ENTRY:
+    replaced = call @sa_btree_map_try_get(&map, &key, &out_old_value_slot)
+    call @sa_btree_map_insert(&map, &key, value)
+    !out_old_value_slot
+    !value
+    !key
+    !map
+    return replaced
+
+@export sa_btree_map_try_insert(&map: ptr, &key: ptr, value: u64, &out_value_ptr_slot: ptr) -> i32:
+L_ENTRY:
+    existing_ptr_slot = stack_alloc 8
+    found = call @sa_btree_map_get_mut_ptr(&map, &key, &existing_ptr_slot)
+    exists = ne found, 0
+    br exists -> L_BTREE_TRY_INSERT_EXISTS, L_BTREE_TRY_INSERT_NEW
+
+L_BTREE_TRY_INSERT_EXISTS:
+    existing_ptr = load existing_ptr_slot+0 as ptr
+    store out_value_ptr_slot+0, existing_ptr as ptr
+    !existing_ptr
+    !exists
+    !found
+    !out_value_ptr_slot
+    !value
+    !key
+    !map
+    return 0
+
+L_BTREE_TRY_INSERT_NEW:
+    call @sa_btree_map_insert(&map, &key, value)
+    inserted_found = call @sa_btree_map_get_mut_ptr(&map, &key, &existing_ptr_slot)
+    inserted_ptr = load existing_ptr_slot+0 as ptr
+    store out_value_ptr_slot+0, inserted_ptr as ptr
+    !inserted_ptr
+    !inserted_found
+    !exists
+    !found
+    !out_value_ptr_slot
+    !value
+    !key
+    !map
+    return 1
+
+@export sa_btree_map_keys_set(&map: ptr) -> ^ptr:
+L_ENTRY:
+    out_set = call @sa_btree_map_new()
+    entries = load map+BTreeMap_entries as ptr
+    len = load map+BTreeMap_len as u64
+    idx_slot = stack_alloc 8
+    store idx_slot+0, 0 as u64
+    jmp L_BTREE_KEYS_HEAD
+
+L_BTREE_KEYS_HEAD:
+    idx = load idx_slot+0 as u64
+    done = eq idx, len
+    br done -> L_BTREE_KEYS_DONE, L_BTREE_KEYS_BODY
+
+L_BTREE_KEYS_BODY:
+    entry_off = mul idx, BTreeMapEntry_SIZE
+    entry = ptr_add entries, entry_off
+    call @sa_btree_map_insert(&out_set, &entry, 1)
+    next_idx = add idx, 1
+    store idx_slot+0, next_idx as u64
+    !next_idx
+    !entry
+    !entry_off
+    !done
+    !idx
+    jmp L_BTREE_KEYS_HEAD
+
+L_BTREE_KEYS_DONE:
+    !done
+    !idx
+    !len
+    !entries
+    !map
+    return out_set
+
+@export sa_btree_map_values_vec(&map: ptr) -> ^ptr:
+L_ENTRY:
+    len = load map+BTreeMap_len as u64
+    out_vec = call @sa_vec_with_capacity(len, 8)
+    entries = load map+BTreeMap_entries as ptr
+    idx_slot = stack_alloc 8
+    store idx_slot+0, 0 as u64
+    jmp L_BTREE_VALUES_HEAD
+
+L_BTREE_VALUES_HEAD:
+    idx = load idx_slot+0 as u64
+    done = eq idx, len
+    br done -> L_BTREE_VALUES_DONE, L_BTREE_VALUES_BODY
+
+L_BTREE_VALUES_BODY:
+    entry_off = mul idx, BTreeMapEntry_SIZE
+    entry = ptr_add entries, entry_off
+    value = load entry+BTreeMapEntry_value as u64
+    out_vec = call @sa_vec_push(^out_vec, value, 8)
+    next_idx = add idx, 1
+    store idx_slot+0, next_idx as u64
+    !next_idx
+    !value
+    !entry
+    !entry_off
+    !done
+    !idx
+    jmp L_BTREE_VALUES_HEAD
+
+L_BTREE_VALUES_DONE:
+    !done
+    !idx
+    !entries
+    !len
+    !map
+    return out_vec
+
+@export sa_btree_map_value_mut_ptrs_vec(&map: ptr) -> ^ptr:
+L_ENTRY:
+    len = load map+BTreeMap_len as u64
+    out_vec = call @sa_vec_with_capacity(len, 8)
+    entries = load map+BTreeMap_entries as ptr
+    idx_slot = stack_alloc 8
+    store idx_slot+0, 0 as u64
+    jmp L_BTREE_VALUE_PTRS_HEAD
+
+L_BTREE_VALUE_PTRS_HEAD:
+    idx = load idx_slot+0 as u64
+    done = eq idx, len
+    br done -> L_BTREE_VALUE_PTRS_DONE, L_BTREE_VALUE_PTRS_BODY
+
+L_BTREE_VALUE_PTRS_BODY:
+    entry_off = mul idx, BTreeMapEntry_SIZE
+    entry = ptr_add entries, entry_off
+    value_ptr = ptr_add entry, BTreeMapEntry_value
+    value_ptr_bits = bitcast value_ptr as u64
+    out_vec = call @sa_vec_push(^out_vec, value_ptr_bits, 8)
+    next_idx = add idx, 1
+    store idx_slot+0, next_idx as u64
+    !next_idx
+    !value_ptr_bits
+    !value_ptr
+    !entry
+    !entry_off
+    !done
+    !idx
+    jmp L_BTREE_VALUE_PTRS_HEAD
+
+L_BTREE_VALUE_PTRS_DONE:
+    !done
+    !idx
+    !entries
+    !len
+    !map
+    return out_vec
+
+@export sa_btree_map_iter_vec(&map: ptr) -> ^ptr:
+L_ENTRY:
+    len = load map+BTreeMap_len as u64
+    EXPAND NUM_U64_CHECKED_MUL btree_iter_cap_ok, btree_iter_cap, len, 3
+    br btree_iter_cap_ok -> L_BTREE_ITER_CAP_OK, L_BTREE_ITER_CAP_OVERFLOW
+
+L_BTREE_ITER_CAP_OVERFLOW:
+    panic(2204)
+
+L_BTREE_ITER_CAP_OK:
+    out_vec = call @sa_vec_with_capacity(btree_iter_cap, 8)
+    entries = load map+BTreeMap_entries as ptr
+    idx_slot = stack_alloc 8
+    store idx_slot+0, 0 as u64
+    jmp L_BTREE_ITER_HEAD
+
+L_BTREE_ITER_HEAD:
+    idx = load idx_slot+0 as u64
+    done = eq idx, len
+    br done -> L_BTREE_ITER_DONE, L_BTREE_ITER_BODY
+
+L_BTREE_ITER_BODY:
+    entry_off = mul idx, BTreeMapEntry_SIZE
+    entry = ptr_add entries, entry_off
+    key_ptr = load entry+BTreeMapEntry_key_ptr as ptr
+    key_len = load entry+BTreeMapEntry_key_len as u64
+    value = load entry+BTreeMapEntry_value as u64
+    key_ptr_bits = bitcast key_ptr as u64
+    out_vec = call @sa_vec_push(^out_vec, key_ptr_bits, 8)
+    out_vec = call @sa_vec_push(^out_vec, key_len, 8)
+    out_vec = call @sa_vec_push(^out_vec, value, 8)
+    next_idx = add idx, 1
+    store idx_slot+0, next_idx as u64
+    !next_idx
+    !key_ptr_bits
+    !value
+    !key_len
+    !key_ptr
+    !entry
+    !entry_off
+    !done
+    !idx
+    jmp L_BTREE_ITER_HEAD
+
+L_BTREE_ITER_DONE:
+    !done
+    !idx
+    !entries
+    !btree_iter_cap_ok
+    !btree_iter_cap
+    !len
+    !map
+    return out_vec
+
+@export sa_btree_map_iter_mut_ptrs_vec(&map: ptr) -> ^ptr:
+L_ENTRY:
+    len = load map+BTreeMap_len as u64
+    EXPAND NUM_U64_CHECKED_MUL btree_iter_mut_cap_ok, btree_iter_mut_cap, len, 3
+    br btree_iter_mut_cap_ok -> L_BTREE_ITER_MUT_CAP_OK, L_BTREE_ITER_MUT_CAP_OVERFLOW
+
+L_BTREE_ITER_MUT_CAP_OVERFLOW:
+    panic(2205)
+
+L_BTREE_ITER_MUT_CAP_OK:
+    out_vec = call @sa_vec_with_capacity(btree_iter_mut_cap, 8)
+    entries = load map+BTreeMap_entries as ptr
+    idx_slot = stack_alloc 8
+    store idx_slot+0, 0 as u64
+    jmp L_BTREE_ITER_MUT_HEAD
+
+L_BTREE_ITER_MUT_HEAD:
+    idx = load idx_slot+0 as u64
+    done = eq idx, len
+    br done -> L_BTREE_ITER_MUT_DONE, L_BTREE_ITER_MUT_BODY
+
+L_BTREE_ITER_MUT_BODY:
+    entry_off = mul idx, BTreeMapEntry_SIZE
+    entry = ptr_add entries, entry_off
+    key_ptr = load entry+BTreeMapEntry_key_ptr as ptr
+    key_len = load entry+BTreeMapEntry_key_len as u64
+    value_ptr = ptr_add entry, BTreeMapEntry_value
+    key_ptr_bits = bitcast key_ptr as u64
+    value_ptr_bits = bitcast value_ptr as u64
+    out_vec = call @sa_vec_push(^out_vec, key_ptr_bits, 8)
+    out_vec = call @sa_vec_push(^out_vec, key_len, 8)
+    out_vec = call @sa_vec_push(^out_vec, value_ptr_bits, 8)
+    next_idx = add idx, 1
+    store idx_slot+0, next_idx as u64
+    !next_idx
+    !value_ptr_bits
+    !key_ptr_bits
+    !value_ptr
+    !key_len
+    !key_ptr
+    !entry
+    !entry_off
+    !done
+    !idx
+    jmp L_BTREE_ITER_MUT_HEAD
+
+L_BTREE_ITER_MUT_DONE:
+    !done
+    !idx
+    !entries
+    !btree_iter_mut_cap_ok
+    !btree_iter_mut_cap
+    !len
+    !map
+    return out_vec
+
+@export sa_btree_map_range_mut_ptrs_vec(&map: ptr, &start_key: ptr, &end_key: ptr) -> ^ptr:
+L_ENTRY:
+    len = load map+BTreeMap_len as u64
+    EXPAND NUM_U64_CHECKED_MUL btree_range_mut_cap_ok, btree_range_mut_cap, len, 3
+    br btree_range_mut_cap_ok -> L_BTREE_RANGE_MUT_CAP_OK, L_BTREE_RANGE_MUT_CAP_OVERFLOW
+
+L_BTREE_RANGE_MUT_CAP_OVERFLOW:
+    panic(2205)
+
+L_BTREE_RANGE_MUT_CAP_OK:
+    out_vec = call @sa_vec_with_capacity(btree_range_mut_cap, 8)
+    entries = load map+BTreeMap_entries as ptr
+    idx_slot = stack_alloc 8
+    store idx_slot+0, 0 as u64
+    jmp L_BTREE_RANGE_MUT_HEAD
+
+L_BTREE_RANGE_MUT_HEAD:
+    idx = load idx_slot+0 as u64
+    done = eq idx, len
+    br done -> L_BTREE_RANGE_MUT_DONE, L_BTREE_RANGE_MUT_BODY
+
+L_BTREE_RANGE_MUT_BODY:
+    entry_off = mul idx, BTreeMapEntry_SIZE
+    entry = ptr_add entries, entry_off
+    cmp_start = call @btree_map_entry_cmp(&entry, &start_key)
+    in_lower = sge cmp_start, 0
+    br in_lower -> L_BTREE_RANGE_MUT_CHECK_END, L_BTREE_RANGE_MUT_NEXT_SKIP
+
+L_BTREE_RANGE_MUT_CHECK_END:
+    cmp_end = call @btree_map_entry_cmp(&entry, &end_key)
+    before_end = slt cmp_end, 0
+    br before_end -> L_BTREE_RANGE_MUT_KEEP, L_BTREE_RANGE_MUT_SKIP_END
+
+L_BTREE_RANGE_MUT_KEEP:
+    key_ptr = load entry+BTreeMapEntry_key_ptr as ptr
+    key_len = load entry+BTreeMapEntry_key_len as u64
+    value_ptr = ptr_add entry, BTreeMapEntry_value
+    key_ptr_bits = bitcast key_ptr as u64
+    value_ptr_bits = bitcast value_ptr as u64
+    out_vec = call @sa_vec_push(^out_vec, key_ptr_bits, 8)
+    out_vec = call @sa_vec_push(^out_vec, key_len, 8)
+    out_vec = call @sa_vec_push(^out_vec, value_ptr_bits, 8)
+    !value_ptr_bits
+    !key_ptr_bits
+    !value_ptr
+    !key_len
+    !key_ptr
+    !before_end
+    !cmp_end
+    !in_lower
+    !cmp_start
+    jmp L_BTREE_RANGE_MUT_NEXT
+
+L_BTREE_RANGE_MUT_SKIP_END:
+    !before_end
+    !cmp_end
+    !in_lower
+    !cmp_start
+    jmp L_BTREE_RANGE_MUT_NEXT
+
+L_BTREE_RANGE_MUT_NEXT_SKIP:
+    !in_lower
+    !cmp_start
+    jmp L_BTREE_RANGE_MUT_NEXT
+
+L_BTREE_RANGE_MUT_NEXT:
+    next_idx = add idx, 1
+    store idx_slot+0, next_idx as u64
+    !next_idx
+    !entry
+    !entry_off
+    !done
+    !idx
+    jmp L_BTREE_RANGE_MUT_HEAD
+
+L_BTREE_RANGE_MUT_DONE:
+    !done
+    !idx
+    !entries
+    !btree_range_mut_cap_ok
+    !btree_range_mut_cap
+    !len
+    !end_key
+    !start_key
+    !map
+    return out_vec
+
+@export sa_btree_map_remove_entry(&map: ptr, &key: ptr, &out_key: ptr, &out_value_slot: ptr) -> i32:
+L_ENTRY:
+    found = call @sa_btree_map_try_get_key_value(&map, &key, &out_key, &out_value_slot)
+    found_nonzero = ne found, 0
+    br found_nonzero -> L_REMOVE_ENTRY_HIT, L_REMOVE_ENTRY_MISS
+
+L_REMOVE_ENTRY_HIT:
+    removed = call @sa_btree_map_remove(&map, &key)
+    !removed
+    !found_nonzero
+    !found
+    !out_value_slot
+    !out_key
+    !key
+    !map
+    return 1
+
+L_REMOVE_ENTRY_MISS:
+    !found_nonzero
+    !found
+    !out_value_slot
+    !out_key
+    !key
+    !map
+    return 0
+
+@export sa_btree_map_pop_first(&map: ptr, &out_key: ptr, &out_value_slot: ptr) -> i32:
+L_ENTRY:
+    found = call @sa_btree_map_first_key_value(&map, &out_key, &out_value_slot)
+    found_nonzero = ne found, 0
+    br found_nonzero -> L_POP_FIRST_HIT, L_POP_FIRST_MISS
+
+L_POP_FIRST_HIT:
+    removed = call @sa_btree_map_remove(&map, &out_key)
+    !removed
+    !found_nonzero
+    !found
+    !out_value_slot
+    !out_key
+    !map
+    return 1
+
+L_POP_FIRST_MISS:
+    !found_nonzero
+    !found
+    !out_value_slot
+    !out_key
+    !map
+    return 0
+
+@export sa_btree_map_pop_last(&map: ptr, &out_key: ptr, &out_value_slot: ptr) -> i32:
+L_ENTRY:
+    found = call @sa_btree_map_last_key_value(&map, &out_key, &out_value_slot)
+    found_nonzero = ne found, 0
+    br found_nonzero -> L_POP_LAST_HIT, L_POP_LAST_MISS
+
+L_POP_LAST_HIT:
+    removed = call @sa_btree_map_remove(&map, &out_key)
+    !removed
+    !found_nonzero
+    !found
+    !out_value_slot
+    !out_key
+    !map
+    return 1
+
+L_POP_LAST_MISS:
+    !found_nonzero
+    !found
+    !out_value_slot
+    !out_key
+    !map
+    return 0
+
+@export sa_btree_map_append(&map: ptr, &other: ptr) -> void:
+L_ENTRY:
+    entries = load other+BTreeMap_entries as ptr
+    len = load other+BTreeMap_len as u64
+    idx_slot = stack_alloc 8
+    store idx_slot+0, 0 as u64
+    jmp L_APPEND_HEAD
+
+L_APPEND_HEAD:
+    idx = load idx_slot+0 as u64
+    done = eq idx, len
+    br done -> L_APPEND_DONE, L_APPEND_BODY
+
+L_APPEND_BODY:
+    entry_off = mul idx, BTreeMapEntry_SIZE
+    entry = ptr_add entries, entry_off
+    value = load entry+BTreeMapEntry_value as u64
+    call @sa_btree_map_insert(&map, &entry, value)
+    next_idx = add idx, 1
+    store idx_slot+0, next_idx as u64
+    !next_idx
+    !value
+    !entry
+    !entry_off
+    !done
+    !idx
+    jmp L_APPEND_HEAD
+
+L_APPEND_DONE:
+    call @sa_btree_map_clear(&other)
+    !done
+    !idx
+    !len
+    !entries
+    !other
+    !map
+    return
+
+@export sa_btree_map_split_off(&map: ptr, &key: ptr) -> ^ptr:
+L_ENTRY:
+    out_map = call @sa_btree_map_new()
+    find_index_slot = stack_alloc 8
+    find_found_slot = stack_alloc 8
+    entries = load map+BTreeMap_entries as ptr
+    len = load map+BTreeMap_len as u64
+    call @btree_map_find(&entries, len, &key, &find_index_slot, &find_found_slot)
+    split_index = load find_index_slot+0 as u64
+    idx_slot = stack_alloc 8
+    store idx_slot+0, split_index as u64
+    jmp L_SPLIT_HEAD
+
+L_SPLIT_HEAD:
+    idx = load idx_slot+0 as u64
+    done = eq idx, len
+    br done -> L_SPLIT_DONE, L_SPLIT_BODY
+
+L_SPLIT_BODY:
+    entry_off = mul idx, BTreeMapEntry_SIZE
+    entry = ptr_add entries, entry_off
+    value = load entry+BTreeMapEntry_value as u64
+    call @sa_btree_map_insert(&out_map, &entry, value)
+    store entry+BTreeMapEntry_key_ptr, 0 as ptr
+    store entry+BTreeMapEntry_key_len, 0 as u64
+    store entry+BTreeMapEntry_value, 0 as u64
+    next_idx = add idx, 1
+    store idx_slot+0, next_idx as u64
+    !next_idx
+    !value
+    !entry
+    !entry_off
+    !done
+    !idx
+    jmp L_SPLIT_HEAD
+
+L_SPLIT_DONE:
+    store map+BTreeMap_len, split_index as u64
+    !done
+    !idx
+    !split_index
+    !len
+    !entries
+    !key
+    !map
+    return out_map
+
+@export sa_btree_map_range(&map: ptr, &start_key: ptr, &end_key: ptr) -> ^ptr:
+L_ENTRY:
+    out_map = call @sa_btree_map_new()
+    entries = load map+BTreeMap_entries as ptr
+    len = load map+BTreeMap_len as u64
+    idx_slot = stack_alloc 8
+    store idx_slot+0, 0 as u64
+    jmp L_BTREE_RANGE_HEAD
+
+L_BTREE_RANGE_HEAD:
+    idx = load idx_slot+0 as u64
+    done = eq idx, len
+    br done -> L_BTREE_RANGE_DONE, L_BTREE_RANGE_BODY
+
+L_BTREE_RANGE_BODY:
+    entry_off = mul idx, BTreeMapEntry_SIZE
+    entry = ptr_add entries, entry_off
+    cmp_start = call @btree_map_entry_cmp(&entry, &start_key)
+    in_lower = sge cmp_start, 0
+    br in_lower -> L_BTREE_RANGE_CHECK_END, L_BTREE_RANGE_NEXT_SKIP
+
+L_BTREE_RANGE_CHECK_END:
+    cmp_end = call @btree_map_entry_cmp(&entry, &end_key)
+    before_end = slt cmp_end, 0
+    br before_end -> L_BTREE_RANGE_KEEP, L_BTREE_RANGE_SKIP_END
+
+L_BTREE_RANGE_KEEP:
+    value = load entry+BTreeMapEntry_value as u64
+    call @sa_btree_map_insert(&out_map, &entry, value)
+    !value
+    !before_end
+    !cmp_end
+    !in_lower
+    !cmp_start
+    jmp L_BTREE_RANGE_NEXT
+
+L_BTREE_RANGE_SKIP_END:
+    !before_end
+    !cmp_end
+    !in_lower
+    !cmp_start
+    jmp L_BTREE_RANGE_NEXT
+
+L_BTREE_RANGE_NEXT_SKIP:
+    !in_lower
+    !cmp_start
+    jmp L_BTREE_RANGE_NEXT
+
+L_BTREE_RANGE_NEXT:
+    next_idx = add idx, 1
+    store idx_slot+0, next_idx as u64
+    !next_idx
+    !entry
+    !entry_off
+    !done
+    !idx
+    jmp L_BTREE_RANGE_HEAD
+
+L_BTREE_RANGE_DONE:
+    !done
+    !idx
+    !len
+    !entries
+    !end_key
+    !start_key
+    !map
+    return out_map
+
+[MACRO] BTREE_MAP_NEW %out_map
+    %out_map = call @sa_btree_map_new()
+[END_MACRO]
+
+[MACRO] BTREE_MAP_FREE %map_reg
+    call @sa_btree_map_free(^%map_reg)
+[END_MACRO]
+
+[MACRO] BTREE_MAP_LEN %out_len, %map_reg
+    %out_len = call @sa_btree_map_len(&%map_reg)
+[END_MACRO]
+
+[MACRO] BTREE_MAP_IS_EMPTY %out_flag, %map_reg
+    %out_flag = call @sa_btree_map_is_empty(&%map_reg)
+[END_MACRO]
+
+[MACRO] BTREE_MAP_GET %out_value, %map_reg, %key_reg
+    %out_value = call @sa_btree_map_get(&%map_reg, &%key_reg)
+[END_MACRO]
+
+[MACRO] BTREE_MAP_TRY_GET %out_ok, %out_value, %map_reg, %key_reg
+    __btree_map_try_get_slot_%out_ok = stack_alloc 8
+    %out_ok = call @sa_btree_map_try_get(&%map_reg, &%key_reg, &__btree_map_try_get_slot_%out_ok)
+    %out_value = load __btree_map_try_get_slot_%out_ok+0 as u64
+[END_MACRO]
+
+[MACRO] BTREE_MAP_GET_KEY_VALUE %out_ok, %out_key, %out_value, %map_reg, %key_reg
+    %out_key = alloc Slice_SIZE
+    __btree_map_kv_value_slot_%out_ok = stack_alloc 8
+    %out_ok = call @sa_btree_map_try_get_key_value(&%map_reg, &%key_reg, &%out_key, &__btree_map_kv_value_slot_%out_ok)
+    %out_value = load __btree_map_kv_value_slot_%out_ok+0 as u64
+[END_MACRO]
+
+[MACRO] BTREE_MAP_GET_MUT_PTR %out_ok, %out_ptr, %map_reg, %key_reg
+    __btree_map_mut_slot_%out_ok = stack_alloc 8
+    %out_ok = call @sa_btree_map_get_mut_ptr(&%map_reg, &%key_reg, &__btree_map_mut_slot_%out_ok)
+    %out_ptr = load __btree_map_mut_slot_%out_ok+0 as ptr
+[END_MACRO]
+
+[MACRO] BTREE_MAP_FIRST_ENTRY_MUT_PTR %out_ok, %out_key, %out_ptr, %map_reg
+    %out_key = alloc Slice_SIZE
+    __btree_map_first_entry_mut_slot_%out_ok = stack_alloc 8
+    %out_ok = call @sa_btree_map_first_entry_mut_ptr(&%map_reg, &%out_key, &__btree_map_first_entry_mut_slot_%out_ok)
+    %out_ptr = load __btree_map_first_entry_mut_slot_%out_ok+0 as ptr
+[END_MACRO]
+
+// Rust method-name alias: BTreeMap::first_entry -> mutable value slot + key slice.
+[MACRO] BTREE_MAP_FIRST_ENTRY_MUT %out_ok, %out_key, %out_ptr, %map_reg
+    EXPAND BTREE_MAP_FIRST_ENTRY_MUT_PTR %out_ok, %out_key, %out_ptr, %map_reg
+[END_MACRO]
+
+[MACRO] BTREE_MAP_FIRST_ENTRY %out_ok, %out_key, %out_ptr, %map_reg
+    EXPAND BTREE_MAP_FIRST_ENTRY_MUT_PTR %out_ok, %out_key, %out_ptr, %map_reg
+[END_MACRO]
+
+[MACRO] BTREE_MAP_LAST_ENTRY_MUT_PTR %out_ok, %out_key, %out_ptr, %map_reg
+    %out_key = alloc Slice_SIZE
+    __btree_map_last_entry_mut_slot_%out_ok = stack_alloc 8
+    %out_ok = call @sa_btree_map_last_entry_mut_ptr(&%map_reg, &%out_key, &__btree_map_last_entry_mut_slot_%out_ok)
+    %out_ptr = load __btree_map_last_entry_mut_slot_%out_ok+0 as ptr
+[END_MACRO]
+
+// Rust method-name alias: BTreeMap::last_entry -> mutable value slot + key slice.
+[MACRO] BTREE_MAP_LAST_ENTRY_MUT %out_ok, %out_key, %out_ptr, %map_reg
+    EXPAND BTREE_MAP_LAST_ENTRY_MUT_PTR %out_ok, %out_key, %out_ptr, %map_reg
+[END_MACRO]
+
+[MACRO] BTREE_MAP_LAST_ENTRY %out_ok, %out_key, %out_ptr, %map_reg
+    EXPAND BTREE_MAP_LAST_ENTRY_MUT_PTR %out_ok, %out_key, %out_ptr, %map_reg
+[END_MACRO]
+
+[MACRO] BTREE_MAP_TRY_GET_DISJOINT_MUT_PTRS %out_ok, %out_ptr_a, %out_ptr_b, %map_reg, %key_a, %key_b
+    __btree_map_disjoint_a_slot_%out_ok = stack_alloc 8
+    __btree_map_disjoint_b_slot_%out_ok = stack_alloc 8
+    %out_ok = call @sa_btree_map_try_get_disjoint_mut_ptrs(&%map_reg, &%key_a, &%key_b, &__btree_map_disjoint_a_slot_%out_ok, &__btree_map_disjoint_b_slot_%out_ok)
+    %out_ptr_a = load __btree_map_disjoint_a_slot_%out_ok+0 as ptr
+    %out_ptr_b = load __btree_map_disjoint_b_slot_%out_ok+0 as ptr
+[END_MACRO]
+
+// Rust method-name alias: BTreeMap::get_disjoint_mut (pair form).
+[MACRO] BTREE_MAP_GET_DISJOINT_MUT_PTRS %out_ok, %out_ptr_a, %out_ptr_b, %map_reg, %key_a, %key_b
+    EXPAND BTREE_MAP_TRY_GET_DISJOINT_MUT_PTRS %out_ok, %out_ptr_a, %out_ptr_b, %map_reg, %key_a, %key_b
+[END_MACRO]
+
+[MACRO] BTREE_MAP_GET_DISJOINT_MUT %out_ok, %out_ptr_a, %out_ptr_b, %map_reg, %key_a, %key_b
+    EXPAND BTREE_MAP_TRY_GET_DISJOINT_MUT_PTRS %out_ok, %out_ptr_a, %out_ptr_b, %map_reg, %key_a, %key_b
+[END_MACRO]
+
+[MACRO] BTREE_MAP_FIRST_KEY_VALUE %out_ok, %out_key, %out_value, %map_reg
+    %out_key = alloc Slice_SIZE
+    __btree_map_first_value_slot_%out_ok = stack_alloc 8
+    %out_ok = call @sa_btree_map_first_key_value(&%map_reg, &%out_key, &__btree_map_first_value_slot_%out_ok)
+    %out_value = load __btree_map_first_value_slot_%out_ok+0 as u64
+[END_MACRO]
+
+[MACRO] BTREE_MAP_LAST_KEY_VALUE %out_ok, %out_key, %out_value, %map_reg
+    %out_key = alloc Slice_SIZE
+    __btree_map_last_value_slot_%out_ok = stack_alloc 8
+    %out_ok = call @sa_btree_map_last_key_value(&%map_reg, &%out_key, &__btree_map_last_value_slot_%out_ok)
+    %out_value = load __btree_map_last_value_slot_%out_ok+0 as u64
+[END_MACRO]
+
+[MACRO] BTREE_MAP_CONTAINS_KEY %out_flag, %map_reg, %key_reg
+    %out_flag = call @sa_btree_map_contains_key(&%map_reg, &%key_reg)
+[END_MACRO]
+
+[MACRO] BTREE_MAP_CLEAR %map_reg
+    call @sa_btree_map_clear(&%map_reg)
+[END_MACRO]
+
+[MACRO] DEFAULT_HASHER_WRITE_BTREE_MAP_STR_U64 %hasher, %map_reg
+    call @btree_map_write_hash_str_u64(&%hasher, &%map_reg)
+[END_MACRO]
+
+// Rust method-name alias over DEFAULT_HASHER_WRITE_BTREE_MAP_STR_U64.
+[MACRO] DEFAULT_HASHER_WRITE_BTREE_MAP_STR %hasher, %map_reg
+    EXPAND DEFAULT_HASHER_WRITE_BTREE_MAP_STR_U64 %hasher, %map_reg
+[END_MACRO]
+
+[MACRO] BTREE_MAP_HASH_STR_U64 %out_hash, %map_reg
+    __btree_map_hash_hasher_%out_hash = stack_alloc DefaultHasher_SIZE
+    EXPAND DEFAULT_HASHER_NEW __btree_map_hash_hasher_%out_hash
+    EXPAND DEFAULT_HASHER_WRITE_BTREE_MAP_STR_U64 __btree_map_hash_hasher_%out_hash, %map_reg
+    EXPAND DEFAULT_HASHER_FINISH %out_hash, __btree_map_hash_hasher_%out_hash
+[END_MACRO]
+
+// Rust method-name alias over BTREE_MAP_HASH_STR_U64.
+[MACRO] BTREE_MAP_HASH_STR %out_hash, %map_reg
+    EXPAND BTREE_MAP_HASH_STR_U64 %out_hash, %map_reg
+[END_MACRO]
+
+// Rust method-name bare alias over the concrete str-key/u64-value hash helper.
+[MACRO] BTREE_MAP_HASH %out_hash, %map_reg
+    EXPAND BTREE_MAP_HASH_STR_U64 %out_hash, %map_reg
+[END_MACRO]
+
+[MACRO] BUILD_HASHER_DEFAULT_HASH_ONE_BTREE_MAP_STR_U64 %out_hash, %builder, %map_reg
+    __build_hash_one_btree_map_hasher_%out_hash = stack_alloc DefaultHasher_SIZE
+    EXPAND BUILD_HASHER_DEFAULT_BUILD __build_hash_one_btree_map_hasher_%out_hash, %builder
+    EXPAND DEFAULT_HASHER_WRITE_BTREE_MAP_STR_U64 __build_hash_one_btree_map_hasher_%out_hash, %map_reg
+    EXPAND DEFAULT_HASHER_FINISH %out_hash, __build_hash_one_btree_map_hasher_%out_hash
+[END_MACRO]
+
+// Rust method-name alias over BUILD_HASHER_DEFAULT_HASH_ONE_BTREE_MAP_STR_U64.
+[MACRO] BUILD_HASHER_DEFAULT_HASH_ONE_BTREE_MAP_STR %out_hash, %builder, %map_reg
+    EXPAND BUILD_HASHER_DEFAULT_HASH_ONE_BTREE_MAP_STR_U64 %out_hash, %builder, %map_reg
+[END_MACRO]
+
+// Rust method-name bare alias over BUILD_HASHER_DEFAULT_HASH_ONE_BTREE_MAP_STR_U64.
+[MACRO] BUILD_HASHER_DEFAULT_HASH_ONE_BTREE_MAP %out_hash, %builder, %map_reg
+    EXPAND BUILD_HASHER_DEFAULT_HASH_ONE_BTREE_MAP_STR_U64 %out_hash, %builder, %map_reg
+[END_MACRO]
+
+[MACRO] RANDOM_STATE_HASH_ONE_BTREE_MAP_STR_U64 %out_hash, %state, %map_reg
+    __random_state_hash_one_btree_map_hasher_%out_hash = stack_alloc DefaultHasher_SIZE
+    EXPAND RANDOM_STATE_BUILD __random_state_hash_one_btree_map_hasher_%out_hash, %state
+    EXPAND DEFAULT_HASHER_WRITE_BTREE_MAP_STR_U64 __random_state_hash_one_btree_map_hasher_%out_hash, %map_reg
+    EXPAND DEFAULT_HASHER_FINISH %out_hash, __random_state_hash_one_btree_map_hasher_%out_hash
+[END_MACRO]
+
+// Rust method-name alias over RANDOM_STATE_HASH_ONE_BTREE_MAP_STR_U64.
+[MACRO] RANDOM_STATE_HASH_ONE_BTREE_MAP_STR %out_hash, %state, %map_reg
+    EXPAND RANDOM_STATE_HASH_ONE_BTREE_MAP_STR_U64 %out_hash, %state, %map_reg
+[END_MACRO]
+
+// Rust method-name bare alias over RANDOM_STATE_HASH_ONE_BTREE_MAP_STR_U64.
+[MACRO] RANDOM_STATE_HASH_ONE_BTREE_MAP %out_hash, %state, %map_reg
+    EXPAND RANDOM_STATE_HASH_ONE_BTREE_MAP_STR_U64 %out_hash, %state, %map_reg
+[END_MACRO]
+
+[MACRO] BTREE_MAP_RETAIN %out_len, %map_reg, %pred_fn
+    __btree_map_retain_entries_%out_len = load %map_reg+BTreeMap_entries as ptr
+    __btree_map_retain_len_%out_len = load %map_reg+BTreeMap_len as u64
+    __btree_map_retain_read_slot_%out_len = stack_alloc 8
+    __btree_map_retain_write_slot_%out_len = stack_alloc 8
+    store __btree_map_retain_read_slot_%out_len+0, 0 as u64
+    store __btree_map_retain_write_slot_%out_len+0, 0 as u64
+    jmp L_BTREE_MAP_RETAIN_HEAD_%out_len
+
+L_BTREE_MAP_RETAIN_HEAD_%out_len:
+    __btree_map_retain_read_%out_len = load __btree_map_retain_read_slot_%out_len+0 as u64
+    __btree_map_retain_done_%out_len = eq __btree_map_retain_read_%out_len, __btree_map_retain_len_%out_len
+    br __btree_map_retain_done_%out_len -> L_BTREE_MAP_RETAIN_CLEAR_HEAD_%out_len, L_BTREE_MAP_RETAIN_BODY_%out_len
+
+L_BTREE_MAP_RETAIN_BODY_%out_len:
+    __btree_map_retain_read_off_%out_len = mul __btree_map_retain_read_%out_len, BTreeMapEntry_SIZE
+    __btree_map_retain_read_entry_%out_len = ptr_add __btree_map_retain_entries_%out_len, __btree_map_retain_read_off_%out_len
+    __btree_map_retain_value_%out_len = load __btree_map_retain_read_entry_%out_len+BTreeMapEntry_value as u64
+    __btree_map_retain_pred_%out_len = call %pred_fn(&__btree_map_retain_read_entry_%out_len, __btree_map_retain_value_%out_len)
+    __btree_map_retain_keep_%out_len = ne __btree_map_retain_pred_%out_len, 0
+    br __btree_map_retain_keep_%out_len -> L_BTREE_MAP_RETAIN_KEEP_%out_len, L_BTREE_MAP_RETAIN_SKIP_%out_len
+
+L_BTREE_MAP_RETAIN_KEEP_%out_len:
+    __btree_map_retain_write_%out_len = load __btree_map_retain_write_slot_%out_len+0 as u64
+    __btree_map_retain_same_slot_%out_len = eq __btree_map_retain_write_%out_len, __btree_map_retain_read_%out_len
+    br __btree_map_retain_same_slot_%out_len -> L_BTREE_MAP_RETAIN_KEEP_ADVANCE_%out_len, L_BTREE_MAP_RETAIN_COPY_%out_len
+
+L_BTREE_MAP_RETAIN_COPY_%out_len:
+    __btree_map_retain_write_off_%out_len = mul __btree_map_retain_write_%out_len, BTreeMapEntry_SIZE
+    __btree_map_retain_write_entry_%out_len = ptr_add __btree_map_retain_entries_%out_len, __btree_map_retain_write_off_%out_len
+    __btree_map_retain_key_ptr_%out_len = load __btree_map_retain_read_entry_%out_len+BTreeMapEntry_key_ptr as ptr
+    __btree_map_retain_key_len_%out_len = load __btree_map_retain_read_entry_%out_len+BTreeMapEntry_key_len as u64
+    store __btree_map_retain_write_entry_%out_len+BTreeMapEntry_key_ptr, __btree_map_retain_key_ptr_%out_len as ptr
+    store __btree_map_retain_write_entry_%out_len+BTreeMapEntry_key_len, __btree_map_retain_key_len_%out_len as u64
+    store __btree_map_retain_write_entry_%out_len+BTreeMapEntry_value, __btree_map_retain_value_%out_len as u64
+    !__btree_map_retain_key_len_%out_len
+    !__btree_map_retain_key_ptr_%out_len
+    !__btree_map_retain_write_entry_%out_len
+    !__btree_map_retain_write_off_%out_len
+    jmp L_BTREE_MAP_RETAIN_KEEP_ADVANCE_%out_len
+
+L_BTREE_MAP_RETAIN_KEEP_ADVANCE_%out_len:
+    __btree_map_retain_next_write_%out_len = add __btree_map_retain_write_%out_len, 1
+    store __btree_map_retain_write_slot_%out_len+0, __btree_map_retain_next_write_%out_len as u64
+    !__btree_map_retain_next_write_%out_len
+    !__btree_map_retain_same_slot_%out_len
+    !__btree_map_retain_write_%out_len
+    jmp L_BTREE_MAP_RETAIN_NEXT_%out_len
+
+L_BTREE_MAP_RETAIN_SKIP_%out_len:
+    jmp L_BTREE_MAP_RETAIN_NEXT_%out_len
+
+L_BTREE_MAP_RETAIN_NEXT_%out_len:
+    __btree_map_retain_next_read_%out_len = add __btree_map_retain_read_%out_len, 1
+    store __btree_map_retain_read_slot_%out_len+0, __btree_map_retain_next_read_%out_len as u64
+    !__btree_map_retain_next_read_%out_len
+    !__btree_map_retain_keep_%out_len
+    !__btree_map_retain_pred_%out_len
+    !__btree_map_retain_value_%out_len
+    !__btree_map_retain_read_entry_%out_len
+    !__btree_map_retain_read_off_%out_len
+    !__btree_map_retain_done_%out_len
+    !__btree_map_retain_read_%out_len
+    jmp L_BTREE_MAP_RETAIN_HEAD_%out_len
+
+L_BTREE_MAP_RETAIN_CLEAR_HEAD_%out_len:
+    __btree_map_retain_clear_slot_%out_len = stack_alloc 8
+    __btree_map_retain_kept_len_%out_len = load __btree_map_retain_write_slot_%out_len+0 as u64
+    store __btree_map_retain_clear_slot_%out_len+0, __btree_map_retain_kept_len_%out_len as u64
+    jmp L_BTREE_MAP_RETAIN_CLEAR_LOOP_%out_len
+
+L_BTREE_MAP_RETAIN_CLEAR_LOOP_%out_len:
+    __btree_map_retain_clear_idx_%out_len = load __btree_map_retain_clear_slot_%out_len+0 as u64
+    __btree_map_retain_clear_done_%out_len = eq __btree_map_retain_clear_idx_%out_len, __btree_map_retain_len_%out_len
+    br __btree_map_retain_clear_done_%out_len -> L_BTREE_MAP_RETAIN_DONE_%out_len, L_BTREE_MAP_RETAIN_CLEAR_BODY_%out_len
+
+L_BTREE_MAP_RETAIN_CLEAR_BODY_%out_len:
+    __btree_map_retain_clear_off_%out_len = mul __btree_map_retain_clear_idx_%out_len, BTreeMapEntry_SIZE
+    __btree_map_retain_clear_entry_%out_len = ptr_add __btree_map_retain_entries_%out_len, __btree_map_retain_clear_off_%out_len
+    store __btree_map_retain_clear_entry_%out_len+BTreeMapEntry_key_ptr, 0 as ptr
+    store __btree_map_retain_clear_entry_%out_len+BTreeMapEntry_key_len, 0 as u64
+    store __btree_map_retain_clear_entry_%out_len+BTreeMapEntry_value, 0 as u64
+    __btree_map_retain_next_clear_%out_len = add __btree_map_retain_clear_idx_%out_len, 1
+    store __btree_map_retain_clear_slot_%out_len+0, __btree_map_retain_next_clear_%out_len as u64
+    !__btree_map_retain_next_clear_%out_len
+    !__btree_map_retain_clear_entry_%out_len
+    !__btree_map_retain_clear_off_%out_len
+    !__btree_map_retain_clear_done_%out_len
+    !__btree_map_retain_clear_idx_%out_len
+    jmp L_BTREE_MAP_RETAIN_CLEAR_LOOP_%out_len
+
+L_BTREE_MAP_RETAIN_DONE_%out_len:
+    %out_len = load __btree_map_retain_write_slot_%out_len+0 as u64
+    store %map_reg+BTreeMap_len, %out_len as u64
+    !__btree_map_retain_clear_done_%out_len
+    !__btree_map_retain_clear_idx_%out_len
+    !__btree_map_retain_kept_len_%out_len
+    !__btree_map_retain_done_%out_len
+    !__btree_map_retain_read_%out_len
+    !__btree_map_retain_len_%out_len
+    !__btree_map_retain_entries_%out_len
+[END_MACRO]
+
+[MACRO] BTREE_MAP_EXTRACT_IF %out_len, %out_map, %map_reg, %pred_fn
+    EXPAND BTREE_MAP_NEW %out_map
+    __btree_map_extract_entries_%out_len = load %map_reg+BTreeMap_entries as ptr
+    __btree_map_extract_len_%out_len = load %map_reg+BTreeMap_len as u64
+    __btree_map_extract_read_slot_%out_len = stack_alloc 8
+    __btree_map_extract_write_slot_%out_len = stack_alloc 8
+    store __btree_map_extract_read_slot_%out_len+0, 0 as u64
+    store __btree_map_extract_write_slot_%out_len+0, 0 as u64
+    jmp L_BTREE_MAP_EXTRACT_HEAD_%out_len
+
+L_BTREE_MAP_EXTRACT_HEAD_%out_len:
+    __btree_map_extract_read_%out_len = load __btree_map_extract_read_slot_%out_len+0 as u64
+    __btree_map_extract_done_%out_len = eq __btree_map_extract_read_%out_len, __btree_map_extract_len_%out_len
+    br __btree_map_extract_done_%out_len -> L_BTREE_MAP_EXTRACT_CLEAR_HEAD_%out_len, L_BTREE_MAP_EXTRACT_BODY_%out_len
+
+L_BTREE_MAP_EXTRACT_BODY_%out_len:
+    __btree_map_extract_read_off_%out_len = mul __btree_map_extract_read_%out_len, BTreeMapEntry_SIZE
+    __btree_map_extract_read_entry_%out_len = ptr_add __btree_map_extract_entries_%out_len, __btree_map_extract_read_off_%out_len
+    __btree_map_extract_value_ptr_%out_len = ptr_add __btree_map_extract_read_entry_%out_len, BTreeMapEntry_value
+    __btree_map_extract_pred_%out_len = call %pred_fn(&__btree_map_extract_read_entry_%out_len, __btree_map_extract_value_ptr_%out_len)
+    __btree_map_extract_value_%out_len = load __btree_map_extract_read_entry_%out_len+BTreeMapEntry_value as u64
+    __btree_map_extract_take_%out_len = ne __btree_map_extract_pred_%out_len, 0
+    br __btree_map_extract_take_%out_len -> L_BTREE_MAP_EXTRACT_TAKE_%out_len, L_BTREE_MAP_EXTRACT_KEEP_%out_len
+
+L_BTREE_MAP_EXTRACT_TAKE_%out_len:
+    call @sa_btree_map_insert(&%out_map, &__btree_map_extract_read_entry_%out_len, __btree_map_extract_value_%out_len)
+    jmp L_BTREE_MAP_EXTRACT_NEXT_%out_len
+
+L_BTREE_MAP_EXTRACT_KEEP_%out_len:
+    __btree_map_extract_write_%out_len = load __btree_map_extract_write_slot_%out_len+0 as u64
+    __btree_map_extract_same_slot_%out_len = eq __btree_map_extract_write_%out_len, __btree_map_extract_read_%out_len
+    br __btree_map_extract_same_slot_%out_len -> L_BTREE_MAP_EXTRACT_KEEP_ADVANCE_%out_len, L_BTREE_MAP_EXTRACT_COPY_%out_len
+
+L_BTREE_MAP_EXTRACT_COPY_%out_len:
+    __btree_map_extract_write_off_%out_len = mul __btree_map_extract_write_%out_len, BTreeMapEntry_SIZE
+    __btree_map_extract_write_entry_%out_len = ptr_add __btree_map_extract_entries_%out_len, __btree_map_extract_write_off_%out_len
+    __btree_map_extract_key_ptr_%out_len = load __btree_map_extract_read_entry_%out_len+BTreeMapEntry_key_ptr as ptr
+    __btree_map_extract_key_len_%out_len = load __btree_map_extract_read_entry_%out_len+BTreeMapEntry_key_len as u64
+    store __btree_map_extract_write_entry_%out_len+BTreeMapEntry_key_ptr, __btree_map_extract_key_ptr_%out_len as ptr
+    store __btree_map_extract_write_entry_%out_len+BTreeMapEntry_key_len, __btree_map_extract_key_len_%out_len as u64
+    store __btree_map_extract_write_entry_%out_len+BTreeMapEntry_value, __btree_map_extract_value_%out_len as u64
+    !__btree_map_extract_key_len_%out_len
+    !__btree_map_extract_key_ptr_%out_len
+    !__btree_map_extract_write_entry_%out_len
+    !__btree_map_extract_write_off_%out_len
+    jmp L_BTREE_MAP_EXTRACT_KEEP_ADVANCE_%out_len
+
+L_BTREE_MAP_EXTRACT_KEEP_ADVANCE_%out_len:
+    __btree_map_extract_next_write_%out_len = add __btree_map_extract_write_%out_len, 1
+    store __btree_map_extract_write_slot_%out_len+0, __btree_map_extract_next_write_%out_len as u64
+    !__btree_map_extract_next_write_%out_len
+    !__btree_map_extract_same_slot_%out_len
+    !__btree_map_extract_write_%out_len
+    jmp L_BTREE_MAP_EXTRACT_NEXT_%out_len
+
+L_BTREE_MAP_EXTRACT_NEXT_%out_len:
+    __btree_map_extract_next_read_%out_len = add __btree_map_extract_read_%out_len, 1
+    store __btree_map_extract_read_slot_%out_len+0, __btree_map_extract_next_read_%out_len as u64
+    !__btree_map_extract_next_read_%out_len
+    !__btree_map_extract_take_%out_len
+    !__btree_map_extract_value_%out_len
+    !__btree_map_extract_pred_%out_len
+    !__btree_map_extract_value_ptr_%out_len
+    !__btree_map_extract_read_entry_%out_len
+    !__btree_map_extract_read_off_%out_len
+    !__btree_map_extract_done_%out_len
+    !__btree_map_extract_read_%out_len
+    jmp L_BTREE_MAP_EXTRACT_HEAD_%out_len
+
+L_BTREE_MAP_EXTRACT_CLEAR_HEAD_%out_len:
+    __btree_map_extract_clear_slot_%out_len = stack_alloc 8
+    __btree_map_extract_kept_len_%out_len = load __btree_map_extract_write_slot_%out_len+0 as u64
+    store __btree_map_extract_clear_slot_%out_len+0, __btree_map_extract_kept_len_%out_len as u64
+    jmp L_BTREE_MAP_EXTRACT_CLEAR_LOOP_%out_len
+
+L_BTREE_MAP_EXTRACT_CLEAR_LOOP_%out_len:
+    __btree_map_extract_clear_idx_%out_len = load __btree_map_extract_clear_slot_%out_len+0 as u64
+    __btree_map_extract_clear_done_%out_len = eq __btree_map_extract_clear_idx_%out_len, __btree_map_extract_len_%out_len
+    br __btree_map_extract_clear_done_%out_len -> L_BTREE_MAP_EXTRACT_DONE_%out_len, L_BTREE_MAP_EXTRACT_CLEAR_BODY_%out_len
+
+L_BTREE_MAP_EXTRACT_CLEAR_BODY_%out_len:
+    __btree_map_extract_clear_off_%out_len = mul __btree_map_extract_clear_idx_%out_len, BTreeMapEntry_SIZE
+    __btree_map_extract_clear_entry_%out_len = ptr_add __btree_map_extract_entries_%out_len, __btree_map_extract_clear_off_%out_len
+    store __btree_map_extract_clear_entry_%out_len+BTreeMapEntry_key_ptr, 0 as ptr
+    store __btree_map_extract_clear_entry_%out_len+BTreeMapEntry_key_len, 0 as u64
+    store __btree_map_extract_clear_entry_%out_len+BTreeMapEntry_value, 0 as u64
+    __btree_map_extract_next_clear_%out_len = add __btree_map_extract_clear_idx_%out_len, 1
+    store __btree_map_extract_clear_slot_%out_len+0, __btree_map_extract_next_clear_%out_len as u64
+    !__btree_map_extract_next_clear_%out_len
+    !__btree_map_extract_clear_entry_%out_len
+    !__btree_map_extract_clear_off_%out_len
+    !__btree_map_extract_clear_done_%out_len
+    !__btree_map_extract_clear_idx_%out_len
+    jmp L_BTREE_MAP_EXTRACT_CLEAR_LOOP_%out_len
+
+L_BTREE_MAP_EXTRACT_DONE_%out_len:
+    %out_len = load __btree_map_extract_write_slot_%out_len+0 as u64
+    store %map_reg+BTreeMap_len, %out_len as u64
+    !__btree_map_extract_clear_done_%out_len
+    !__btree_map_extract_clear_idx_%out_len
+    !__btree_map_extract_kept_len_%out_len
+    !__btree_map_extract_done_%out_len
+    !__btree_map_extract_read_%out_len
+    !__btree_map_extract_len_%out_len
+    !__btree_map_extract_entries_%out_len
+[END_MACRO]
+
+[MACRO] BTREE_MAP_EXTRACT_IF_RANGE %out_len, %out_map, %map_reg, %start_key, %end_key, %pred_fn
+    EXPAND BTREE_MAP_NEW %out_map
+    EXPAND BTREE_MAP_RANGE_MUT_PTRS __btree_map_extract_range_vec_%out_len, %map_reg, %start_key, %end_key
+    __btree_map_extract_range_len_%out_len = call @sa_vec_len(&__btree_map_extract_range_vec_%out_len)
+    __btree_map_extract_range_ptr_%out_len = load __btree_map_extract_range_vec_%out_len+Vec_ptr as ptr
+    __btree_map_extract_range_key_%out_len = stack_alloc Slice_SIZE
+    __btree_map_extract_range_idx_slot_%out_len = stack_alloc 8
+    store __btree_map_extract_range_idx_slot_%out_len+0, 0 as u64
+    jmp L_BTREE_MAP_EXTRACT_RANGE_HEAD_%out_len
+
+L_BTREE_MAP_EXTRACT_RANGE_HEAD_%out_len:
+    __btree_map_extract_range_idx_%out_len = load __btree_map_extract_range_idx_slot_%out_len+0 as u64
+    __btree_map_extract_range_done_%out_len = eq __btree_map_extract_range_idx_%out_len, __btree_map_extract_range_len_%out_len
+    br __btree_map_extract_range_done_%out_len -> L_BTREE_MAP_EXTRACT_RANGE_REMOVE_INIT_%out_len, L_BTREE_MAP_EXTRACT_RANGE_BODY_%out_len
+
+L_BTREE_MAP_EXTRACT_RANGE_BODY_%out_len:
+    __btree_map_extract_range_key_idx_%out_len = mul __btree_map_extract_range_idx_%out_len, 8
+    __btree_map_extract_range_key_lane_%out_len = ptr_add __btree_map_extract_range_ptr_%out_len, __btree_map_extract_range_key_idx_%out_len
+    __btree_map_extract_range_key_bits_%out_len = load __btree_map_extract_range_key_lane_%out_len+0 as u64
+    __btree_map_extract_range_key_len_lane_%out_len = ptr_add __btree_map_extract_range_key_lane_%out_len, 8
+    __btree_map_extract_range_key_len_%out_len = load __btree_map_extract_range_key_len_lane_%out_len+0 as u64
+    __btree_map_extract_range_value_lane_%out_len = ptr_add __btree_map_extract_range_key_lane_%out_len, 16
+    __btree_map_extract_range_value_bits_%out_len = load __btree_map_extract_range_value_lane_%out_len+0 as u64
+    __btree_map_extract_range_key_ptr_%out_len = bitcast __btree_map_extract_range_key_bits_%out_len as ptr
+    __btree_map_extract_range_value_ptr_%out_len = bitcast __btree_map_extract_range_value_bits_%out_len as ptr
+    store __btree_map_extract_range_key_%out_len+Slice_ptr, __btree_map_extract_range_key_ptr_%out_len as ptr
+    store __btree_map_extract_range_key_%out_len+Slice_len, __btree_map_extract_range_key_len_%out_len as u64
+    __btree_map_extract_range_pred_%out_len = call %pred_fn(&__btree_map_extract_range_key_%out_len, __btree_map_extract_range_value_ptr_%out_len)
+    __btree_map_extract_range_take_%out_len = ne __btree_map_extract_range_pred_%out_len, 0
+    br __btree_map_extract_range_take_%out_len -> L_BTREE_MAP_EXTRACT_RANGE_TAKE_%out_len, L_BTREE_MAP_EXTRACT_RANGE_NEXT_%out_len
+
+L_BTREE_MAP_EXTRACT_RANGE_TAKE_%out_len:
+    __btree_map_extract_range_value_%out_len = load __btree_map_extract_range_value_ptr_%out_len+0 as u64
+    call @sa_btree_map_insert(&%out_map, &__btree_map_extract_range_key_%out_len, __btree_map_extract_range_value_%out_len)
+    !__btree_map_extract_range_value_%out_len
+    jmp L_BTREE_MAP_EXTRACT_RANGE_NEXT_%out_len
+
+L_BTREE_MAP_EXTRACT_RANGE_NEXT_%out_len:
+    __btree_map_extract_range_next_idx_%out_len = add __btree_map_extract_range_idx_%out_len, 3
+    store __btree_map_extract_range_idx_slot_%out_len+0, __btree_map_extract_range_next_idx_%out_len as u64
+    !__btree_map_extract_range_next_idx_%out_len
+    !__btree_map_extract_range_take_%out_len
+    !__btree_map_extract_range_pred_%out_len
+    !__btree_map_extract_range_value_ptr_%out_len
+    !__btree_map_extract_range_key_ptr_%out_len
+    !__btree_map_extract_range_value_bits_%out_len
+    !__btree_map_extract_range_value_lane_%out_len
+    !__btree_map_extract_range_key_len_%out_len
+    !__btree_map_extract_range_key_len_lane_%out_len
+    !__btree_map_extract_range_key_bits_%out_len
+    !__btree_map_extract_range_key_lane_%out_len
+    !__btree_map_extract_range_key_idx_%out_len
+    !__btree_map_extract_range_done_%out_len
+    !__btree_map_extract_range_idx_%out_len
+    jmp L_BTREE_MAP_EXTRACT_RANGE_HEAD_%out_len
+
+L_BTREE_MAP_EXTRACT_RANGE_REMOVE_INIT_%out_len:
+    call @sa_vec_free(^__btree_map_extract_range_vec_%out_len)
+    __btree_map_extract_range_remove_entries_%out_len = load %out_map+BTreeMap_entries as ptr
+    __btree_map_extract_range_remove_len_%out_len = load %out_map+BTreeMap_len as u64
+    __btree_map_extract_range_remove_slot_%out_len = stack_alloc 8
+    store __btree_map_extract_range_remove_slot_%out_len+0, 0 as u64
+    jmp L_BTREE_MAP_EXTRACT_RANGE_REMOVE_HEAD_%out_len
+
+L_BTREE_MAP_EXTRACT_RANGE_REMOVE_HEAD_%out_len:
+    __btree_map_extract_range_remove_idx_%out_len = load __btree_map_extract_range_remove_slot_%out_len+0 as u64
+    __btree_map_extract_range_remove_done_%out_len = eq __btree_map_extract_range_remove_idx_%out_len, __btree_map_extract_range_remove_len_%out_len
+    br __btree_map_extract_range_remove_done_%out_len -> L_BTREE_MAP_EXTRACT_RANGE_DONE_%out_len, L_BTREE_MAP_EXTRACT_RANGE_REMOVE_BODY_%out_len
+
+L_BTREE_MAP_EXTRACT_RANGE_REMOVE_BODY_%out_len:
+    __btree_map_extract_range_remove_off_%out_len = mul __btree_map_extract_range_remove_idx_%out_len, BTreeMapEntry_SIZE
+    __btree_map_extract_range_remove_entry_%out_len = ptr_add __btree_map_extract_range_remove_entries_%out_len, __btree_map_extract_range_remove_off_%out_len
+    __btree_map_extract_range_removed_value_%out_len = call @sa_btree_map_remove(&%map_reg, &__btree_map_extract_range_remove_entry_%out_len)
+    __btree_map_extract_range_remove_next_%out_len = add __btree_map_extract_range_remove_idx_%out_len, 1
+    store __btree_map_extract_range_remove_slot_%out_len+0, __btree_map_extract_range_remove_next_%out_len as u64
+    !__btree_map_extract_range_remove_next_%out_len
+    !__btree_map_extract_range_removed_value_%out_len
+    !__btree_map_extract_range_remove_entry_%out_len
+    !__btree_map_extract_range_remove_off_%out_len
+    !__btree_map_extract_range_remove_done_%out_len
+    !__btree_map_extract_range_remove_idx_%out_len
+    jmp L_BTREE_MAP_EXTRACT_RANGE_REMOVE_HEAD_%out_len
+
+L_BTREE_MAP_EXTRACT_RANGE_DONE_%out_len:
+    %out_len = load %map_reg+BTreeMap_len as u64
+    !__btree_map_extract_range_remove_done_%out_len
+    !__btree_map_extract_range_remove_idx_%out_len
+    !__btree_map_extract_range_remove_len_%out_len
+    !__btree_map_extract_range_remove_entries_%out_len
+    !__btree_map_extract_range_done_%out_len
+    !__btree_map_extract_range_idx_%out_len
+    !__btree_map_extract_range_ptr_%out_len
+    !__btree_map_extract_range_len_%out_len
+[END_MACRO]
+
+[MACRO] BTREE_MAP_REMOVE %out_value, %map_reg, %key_reg
+    %out_value = call @sa_btree_map_remove(&%map_reg, &%key_reg)
+[END_MACRO]
+
+[MACRO] BTREE_MAP_REMOVE_ENTRY %out_ok, %out_key, %out_value, %map_reg, %key_reg
+    %out_key = alloc Slice_SIZE
+    __btree_map_remove_value_slot_%out_ok = stack_alloc 8
+    %out_ok = call @sa_btree_map_remove_entry(&%map_reg, &%key_reg, &%out_key, &__btree_map_remove_value_slot_%out_ok)
+    %out_value = load __btree_map_remove_value_slot_%out_ok+0 as u64
+[END_MACRO]
+
+[MACRO] BTREE_MAP_INSERT %map_reg, %key_reg, %value
+    call @sa_btree_map_insert(&%map_reg, &%key_reg, %value)
+[END_MACRO]
+
+[MACRO] BTREE_MAP_INSERT_OLD %out_replaced, %out_old_value, %map_reg, %key_reg, %value
+    __btree_map_insert_old_slot_%out_replaced = stack_alloc 8
+    %out_replaced = call @sa_btree_map_insert_old(&%map_reg, &%key_reg, %value, &__btree_map_insert_old_slot_%out_replaced)
+    %out_old_value = load __btree_map_insert_old_slot_%out_replaced+0 as u64
+[END_MACRO]
+
+[MACRO] BTREE_MAP_TRY_INSERT %out_inserted, %out_value_ptr, %map_reg, %key_reg, %value
+    __btree_map_try_insert_ptr_slot_%out_inserted = stack_alloc 8
+    %out_inserted = call @sa_btree_map_try_insert(&%map_reg, &%key_reg, %value, &__btree_map_try_insert_ptr_slot_%out_inserted)
+    %out_value_ptr = load __btree_map_try_insert_ptr_slot_%out_inserted+0 as ptr
+[END_MACRO]
+
+[MACRO] BTREE_MAP_ENTRY_OR_INSERT %out_inserted, %out_value_ptr, %map_reg, %key_reg, %value
+    EXPAND BTREE_MAP_TRY_INSERT %out_inserted, %out_value_ptr, %map_reg, %key_reg, %value
+[END_MACRO]
+
+// Rust method-name bare alias for the common entry path (or_insert).
+[MACRO] BTREE_MAP_ENTRY %out_inserted, %out_value_ptr, %map_reg, %key_reg, %value
+    EXPAND BTREE_MAP_ENTRY_OR_INSERT %out_inserted, %out_value_ptr, %map_reg, %key_reg, %value
+[END_MACRO]
+
+[MACRO] BTREE_MAP_OR_INSERT %out_inserted, %out_value_ptr, %map_reg, %key_reg, %value
+    EXPAND BTREE_MAP_ENTRY_OR_INSERT %out_inserted, %out_value_ptr, %map_reg, %key_reg, %value
+[END_MACRO]
+
+// Concrete entry-style helpers. Default inserted value is 0 for the u64 map.
+
+[MACRO] BTREE_MAP_ENTRY_OR_DEFAULT %out_inserted, %out_value_ptr, %map_reg, %key_reg
+    EXPAND BTREE_MAP_ENTRY_OR_INSERT %out_inserted, %out_value_ptr, %map_reg, %key_reg, 0
+[END_MACRO]
+
+[MACRO] BTREE_MAP_ENTRY_AND_MODIFY %out_ok, %map_reg, %key_reg, %value
+    __btree_and_mod_ptr_slot_%out_ok = stack_alloc 8
+    %out_ok = call @sa_btree_map_get_mut_ptr(&%map_reg, &%key_reg, &__btree_and_mod_ptr_slot_%out_ok)
+    __btree_and_mod_ptr_%out_ok = load __btree_and_mod_ptr_slot_%out_ok+0 as ptr
+    __btree_and_mod_has_%out_ok = eq %out_ok, 1
+    br __btree_and_mod_has_%out_ok -> L_BTREE_MAP_ENTRY_AND_MODIFY_SET_%out_ok, L_BTREE_MAP_ENTRY_AND_MODIFY_SKIP_%out_ok
+L_BTREE_MAP_ENTRY_AND_MODIFY_SET_%out_ok:
+    store __btree_and_mod_ptr_%out_ok+0, %value as u64
+    !__btree_and_mod_has_%out_ok
+    !__btree_and_mod_ptr_%out_ok
+    jmp L_BTREE_MAP_ENTRY_AND_MODIFY_END_%out_ok
+L_BTREE_MAP_ENTRY_AND_MODIFY_SKIP_%out_ok:
+    !__btree_and_mod_has_%out_ok
+    !__btree_and_mod_ptr_%out_ok
+    jmp L_BTREE_MAP_ENTRY_AND_MODIFY_END_%out_ok
+L_BTREE_MAP_ENTRY_AND_MODIFY_END_%out_ok:
+[END_MACRO]
+
+[MACRO] BTREE_MAP_KEYS %out_set, %map_reg
+    %out_set = call @sa_btree_map_keys_set(&%map_reg)
+[END_MACRO]
+
+[MACRO] BTREE_MAP_VALUES %out_vec, %map_reg
+    %out_vec = call @sa_btree_map_values_vec(&%map_reg)
+[END_MACRO]
+
+[MACRO] BTREE_MAP_INTO_KEYS %out_set, %map_reg
+    EXPAND BTREE_MAP_KEYS %out_set, %map_reg
+    EXPAND BTREE_MAP_CLEAR %map_reg
+[END_MACRO]
+
+[MACRO] BTREE_MAP_INTO_VALUES %out_vec, %map_reg
+    EXPAND BTREE_MAP_VALUES %out_vec, %map_reg
+    EXPAND BTREE_MAP_CLEAR %map_reg
+[END_MACRO]
+
+[MACRO] BTREE_MAP_VALUES_MUT_PTRS %out_vec, %map_reg
+    %out_vec = call @sa_btree_map_value_mut_ptrs_vec(&%map_reg)
+[END_MACRO]
+
+[MACRO] BTREE_MAP_VALUES_MUT %out_vec, %map_reg
+    EXPAND BTREE_MAP_VALUES_MUT_PTRS %out_vec, %map_reg
+[END_MACRO]
+
+[MACRO] BTREE_MAP_ITER %out_vec, %map_reg
+    %out_vec = call @sa_btree_map_iter_vec(&%map_reg)
+[END_MACRO]
+
+[MACRO] BTREE_MAP_ITER_MUT_PTRS %out_vec, %map_reg
+    %out_vec = call @sa_btree_map_iter_mut_ptrs_vec(&%map_reg)
+[END_MACRO]
+
+// Rust method-name alias: BTreeMap::iter_mut (eager raw value-slot pointer materialization).
+[MACRO] BTREE_MAP_ITER_MUT %out_vec, %map_reg
+    EXPAND BTREE_MAP_ITER_MUT_PTRS %out_vec, %map_reg
+[END_MACRO]
+
+[MACRO] BTREE_MAP_REF_INTO_ITER %out_vec, %map_reg
+    EXPAND BTREE_MAP_ITER %out_vec, %map_reg
+[END_MACRO]
+
+[MACRO] BTREE_MAP_MUT_REF_INTO_ITER %out_vec, %map_reg
+    EXPAND BTREE_MAP_ITER_MUT_PTRS %out_vec, %map_reg
+[END_MACRO]
+
+[MACRO] BTREE_MAP_INTO_ITER %out_vec, %map_reg
+    EXPAND BTREE_MAP_ITER %out_vec, %map_reg
+    EXPAND BTREE_MAP_CLEAR %map_reg
+[END_MACRO]
+
+[MACRO] BTREE_MAP_POP_FIRST %out_ok, %out_key, %out_value, %map_reg
+    %out_key = alloc Slice_SIZE
+    __btree_map_pop_first_value_slot_%out_ok = stack_alloc 8
+    %out_ok = call @sa_btree_map_pop_first(&%map_reg, &%out_key, &__btree_map_pop_first_value_slot_%out_ok)
+    %out_value = load __btree_map_pop_first_value_slot_%out_ok+0 as u64
+[END_MACRO]
+
+[MACRO] BTREE_MAP_POP_LAST %out_ok, %out_key, %out_value, %map_reg
+    %out_key = alloc Slice_SIZE
+    __btree_map_pop_last_value_slot_%out_ok = stack_alloc 8
+    %out_ok = call @sa_btree_map_pop_last(&%map_reg, &%out_key, &__btree_map_pop_last_value_slot_%out_ok)
+    %out_value = load __btree_map_pop_last_value_slot_%out_ok+0 as u64
+[END_MACRO]
+
+[MACRO] BTREE_MAP_APPEND %map_reg, %other_map
+    call @sa_btree_map_append(&%map_reg, &%other_map)
+[END_MACRO]
+
+[MACRO] BTREE_MAP_SPLIT_OFF %out_map, %map_reg, %key_reg
+    %out_map = call @sa_btree_map_split_off(&%map_reg, &%key_reg)
+[END_MACRO]
+
+[MACRO] BTREE_MAP_RANGE %out_map, %map_reg, %start_key, %end_key
+    %out_map = call @sa_btree_map_range(&%map_reg, &%start_key, &%end_key)
+[END_MACRO]
+
+[MACRO] BTREE_MAP_RANGE_MUT_PTRS %out_vec, %map_reg, %start_key, %end_key
+    %out_vec = call @sa_btree_map_range_mut_ptrs_vec(&%map_reg, &%start_key, &%end_key)
+[END_MACRO]
+
+// Rust method-name alias: BTreeMap::range_mut (eager raw-pointer materialization).
+[MACRO] BTREE_MAP_RANGE_MUT %out_vec, %map_reg, %start_key, %end_key
+    EXPAND BTREE_MAP_RANGE_MUT_PTRS %out_vec, %map_reg, %start_key, %end_key
+[END_MACRO]
+
+[MACRO] BTREE_MAP_LIT1 %out_map, %key1, %value1
+    EXPAND BTREE_MAP_NEW %out_map
+    EXPAND BTREE_MAP_INSERT %out_map, %key1, %value1
+[END_MACRO]
+
+[MACRO] BTREE_MAP_LIT2 %out_map, %key1, %value1, %key2, %value2
+    EXPAND BTREE_MAP_NEW %out_map
+    EXPAND BTREE_MAP_INSERT %out_map, %key1, %value1
+    EXPAND BTREE_MAP_INSERT %out_map, %key2, %value2
+[END_MACRO]
+
+[MACRO] BTREE_MAP_LIT3 %out_map, %key1, %value1, %key2, %value2, %key3, %value3
+    EXPAND BTREE_MAP_NEW %out_map
+    EXPAND BTREE_MAP_INSERT %out_map, %key1, %value1
+    EXPAND BTREE_MAP_INSERT %out_map, %key2, %value2
+    EXPAND BTREE_MAP_INSERT %out_map, %key3, %value3
+[END_MACRO]
+
+// Rust Default-style empty BTreeMap constructor alias.
+
+[MACRO] BTREE_MAP_DEFAULT %out_map
+    EXPAND BTREE_MAP_NEW %out_map
+[END_MACRO]