@salang/sa 0.1.2 → 0.1.4

package/sa_std/hashmap.sa

@@ -0,0 +1,1962 @@
+@import "core/mem.sa"
+@import "core/slice.sal"
+@import "alloc/vec.sa"
+@import "alloc/vec.sal"
+@import "vec.sa"
+@import "num.sa"
+@import "hashmap.sal"
+
+@map_hash_ptr(&key: ptr) -> u64:
+L_ENTRY:
+    hash = call @map_hash_ptr_seed(&key, 0)
+    !key
+    return hash
+
+@map_hash_ptr_seed(&key: ptr, seed: u64) -> u64:
+L_ENTRY:
+    key_bits = bitcast key as u64
+    bits0 = xor key_bits, seed
+    shift1 = 32 as u64
+    shift2 = 16 as u64
+    shift3 = 8 as u64
+
+    bits1 = shr bits0, shift1
+    hash1 = xor bits0, bits1
+    bits2 = shr hash1, shift2
+    hash2 = xor hash1, bits2
+    bits3 = shr hash2, shift3
+    hash3 = xor hash2, bits3
+
+    !shift3
+    !shift2
+    !shift1
+    !bits3
+    !bits2
+    !bits1
+    !bits0
+    !key_bits
+    !hash2
+    !hash1
+    !seed
+    !key
+    return hash3
+
+@map_table_probe(&slots: ptr, cap: u64, hash: u64, &key: ptr, &out_index: ptr, &out_found: ptr) -> void:
+L_ENTRY:
+    index_slot = stack_alloc 8
+    remaining_slot = stack_alloc 8
+    store out_found+0, 0 as u64
+    store out_index+0, 0 as u64
+    cap_is_zero = eq cap, 0
+    br cap_is_zero -> L_PROBE_END, L_PROBE_INIT
+
+L_PROBE_INIT:
+    cap_minus_one = sub cap, 1
+    start_index = and hash, cap_minus_one
+    store index_slot+0, start_index as u64
+    store remaining_slot+0, cap as u64
+    !start_index
+    !cap_minus_one
+    jmp L_PROBE_LOOP
+
+L_PROBE_LOOP:
+    remaining = load remaining_slot+0 as u64
+    exhausted = eq remaining, 0
+    br exhausted -> L_PROBE_EXHAUSTED, L_PROBE_BODY
+
+L_PROBE_BODY:
+    !exhausted
+    index = load index_slot+0 as u64
+    slot_off = mul index, HashMapSlot_SIZE
+    slot = ptr_add slots, slot_off
+    state = load slot+HashMapSlot_state as u8
+    is_empty = eq state, HashMap_STATE_EMPTY
+    br is_empty -> L_PROBE_EMPTY, L_PROBE_NONEMPTY
+
+L_PROBE_NONEMPTY:
+    slot_hash = load slot+HashMapSlot_hash as u64
+    hash_match = eq slot_hash, hash
+    br hash_match -> L_PROBE_KEY_CHECK, L_PROBE_STEP
+
+L_PROBE_STEP:
+    next_index = add index, 1
+    wrapped = eq next_index, cap
+    next_remaining = sub remaining, 1
+    store remaining_slot+0, next_remaining as u64
+    !next_remaining
+    !slot_hash
+    !hash_match
+    !is_empty
+    !state
+    !slot
+    !slot_off
+    !index
+    !remaining
+    br wrapped -> L_PROBE_WRAP, L_PROBE_CONT
+
+L_PROBE_WRAP:
+    store index_slot+0, 0 as u64
+    !next_index
+    !wrapped
+    jmp L_PROBE_LOOP
+
+L_PROBE_CONT:
+    store index_slot+0, next_index as u64
+    !next_index
+    !wrapped
+    jmp L_PROBE_LOOP
+
+L_PROBE_KEY_CHECK:
+    slot_key = load slot+HashMapSlot_key as ptr
+    key_match = eq slot_key, key
+    br key_match -> L_PROBE_FOUND, L_PROBE_KEY_MISS
+
+L_PROBE_FOUND:
+    store out_index+0, index as u64
+    store out_found+0, 1 as u64
+    !key_match
+    !slot_key
+    !slot_hash
+    !hash_match
+    !is_empty
+    !state
+    !slot
+    !slot_off
+    !index
+    !remaining
+    jmp L_PROBE_END
+
+L_PROBE_KEY_MISS:
+    !key_match
+    !slot_key
+    jmp L_PROBE_STEP
+
+L_PROBE_EMPTY:
+    store out_index+0, index as u64
+    !is_empty
+    !state
+    !slot
+    !slot_off
+    !index
+    !remaining
+    jmp L_PROBE_END
+
+L_PROBE_EXHAUSTED:
+    current_index = load index_slot+0 as u64
+    store out_index+0, current_index as u64
+    !current_index
+    !remaining
+    !exhausted
+    jmp L_PROBE_END
+
+L_PROBE_END:
+    !cap_is_zero
+    !slots
+    !cap
+    !hash
+    !key
+    !out_index
+    !out_found
+    return
+
+@map_table_insert(&slots: ptr, cap: u64, hash: u64, &key: ptr, &value: ptr) -> void:
+L_ENTRY:
+    probe_index_slot = stack_alloc 8
+    probe_found_slot = stack_alloc 8
+    call @map_table_probe(&slots, cap, hash, &key, &probe_index_slot, &probe_found_slot)
+    probe_index = load probe_index_slot+0 as u64
+    slot_off = mul probe_index, HashMapSlot_SIZE
+    slot = ptr_add slots, slot_off
+    store slot+HashMapSlot_hash, hash as u64
+    store slot+HashMapSlot_key, key as ptr
+    store slot+HashMapSlot_value, value as ptr
+    store slot+HashMapSlot_state, HashMap_STATE_FILLED as u8
+    !slot
+    !slot_off
+    !probe_index
+    !slots
+    !cap
+    !hash
+    !key
+    !value
+    return
+
+@map_next_capacity(requested: u64) -> u64:
+L_ENTRY:
+    cap = HashMap_INITIAL_CAP
+    requested_is_zero = eq requested, 0
+    br requested_is_zero -> L_NEXT_CAP_ZERO, L_NEXT_CAP_LOOP
+
+L_NEXT_CAP_LOOP:
+    cap_ge_requested = uge cap, requested
+    br cap_ge_requested -> L_NEXT_CAP_DONE, L_NEXT_CAP_GROW
+
+L_NEXT_CAP_GROW:
+    EXPAND NUM_U64_CHECKED_ADD next_cap_ok, next_cap, cap, cap
+    br next_cap_ok -> L_NEXT_CAP_GROW_OK, L_NEXT_CAP_OVERFLOW
+
+L_NEXT_CAP_OVERFLOW:
+    panic(1301)
+
+L_NEXT_CAP_GROW_OK:
+    cap = next_cap
+    !next_cap_ok
+    !cap_ge_requested
+    jmp L_NEXT_CAP_LOOP
+
+L_NEXT_CAP_DONE:
+    !cap_ge_requested
+    !requested_is_zero
+    !requested
+    return cap
+
+L_NEXT_CAP_ZERO:
+    !requested_is_zero
+    !requested
+    return 0
+
+@map_rehash(&map: ptr, new_cap: u64) -> void:
+L_ENTRY:
+    old_slots = take map+HashMap_slots
+    old_cap = load map+HashMap_cap as u64
+    EXPAND NUM_U64_CHECKED_MUL new_bytes_ok, new_bytes, new_cap, HashMapSlot_SIZE
+    br new_bytes_ok -> L_REHASH_ALLOC, L_REHASH_OVERFLOW
+
+L_REHASH_OVERFLOW:
+    panic(1302)
+
+L_REHASH_ALLOC:
+    new_slots = alloc new_bytes
+    call @sa_mem_set(&new_slots, 0, new_bytes)
+    store map+HashMap_slots, new_slots as ptr
+    store map+HashMap_cap, new_cap as u64
+    store map+HashMap_len, 0 as u64
+    store map+HashMap_tombs, 0 as u64
+
+    old_idx_slot = stack_alloc 8
+    store old_idx_slot+0, 0 as u64
+    probe_idx_slot = stack_alloc 8
+    probe_found_slot = stack_alloc 8
+    old_cap_is_zero = eq old_cap, 0
+    br old_cap_is_zero -> L_REHASH_END_ZERO, L_REHASH_LOOP
+
+L_REHASH_LOOP:
+    old_idx = load old_idx_slot+0 as u64
+    done = eq old_idx, old_cap
+    br done -> L_REHASH_END, L_REHASH_BODY
+
+L_REHASH_BODY:
+    old_slot_off = mul old_idx, HashMapSlot_SIZE
+    old_slot = ptr_add old_slots, old_slot_off
+    state = load old_slot+HashMapSlot_state as u8
+    is_filled = eq state, HashMap_STATE_FILLED
+    br is_filled -> L_REHASH_INSERT, L_REHASH_NEXT
+
+L_REHASH_INSERT:
+    old_hash = load old_slot+HashMapSlot_hash as u64
+    old_key = load old_slot+HashMapSlot_key as ptr
+    old_value = load old_slot+HashMapSlot_value as ptr
+    call @map_table_insert(&new_slots, new_cap, old_hash, &old_key, &old_value)
+    cur_len = load map+HashMap_len as u64
+    next_len = add cur_len, 1
+    store map+HashMap_len, next_len as u64
+    !old_hash
+    !old_key
+    !old_value
+    !cur_len
+    !next_len
+    jmp L_REHASH_NEXT
+
+L_REHASH_NEXT:
+    next_old_idx = add old_idx, 1
+    store old_idx_slot+0, next_old_idx as u64
+    !old_idx
+    !done
+    !old_slot_off
+    !old_slot
+    !state
+    !is_filled
+    !next_old_idx
+    jmp L_REHASH_LOOP
+
+L_REHASH_END:
+    !old_slots
+    !old_cap
+    !new_bytes
+    !new_bytes_ok
+    !old_cap_is_zero
+    return
+
+L_REHASH_END_ZERO:
+    !old_slots
+    !old_cap
+    !new_bytes
+    !new_bytes_ok
+    !old_cap_is_zero
+    return
+
+@map_probe_existing(&map: ptr, &key: ptr, &out_slot: ptr) -> i32:
+L_ENTRY:
+    slots = load map+HashMap_slots as ptr
+    cap = load map+HashMap_cap as u64
+    cap_is_zero = eq cap, 0
+    br cap_is_zero -> L_PROBE_EXISTING_ZERO, L_PROBE_EXISTING_RUN
+
+L_PROBE_EXISTING_RUN:
+    seed = load map+HashMap_seed as u64
+    hash = call @map_hash_ptr_seed(&key, seed)
+    probe_index_slot = stack_alloc 8
+    probe_found_slot = stack_alloc 8
+    call @map_table_probe(&slots, cap, hash, &key, &probe_index_slot, &probe_found_slot)
+    probe_found = load probe_found_slot+0 as u64
+    found = ne probe_found, 0
+    br found -> L_PROBE_EXISTING_HIT, L_PROBE_EXISTING_MISS
+
+L_PROBE_EXISTING_HIT:
+    probe_index = load probe_index_slot+0 as u64
+    slot_off = mul probe_index, HashMapSlot_SIZE
+    slot = ptr_add slots, slot_off
+    store out_slot+0, slot as ptr
+    !slot
+    !slot_off
+    !probe_index
+    !found
+    !probe_found
+    !hash
+    !seed
+    !cap_is_zero
+    !cap
+    !slots
+    !out_slot
+    !key
+    !map
+    return 1
+
+L_PROBE_EXISTING_MISS:
+    store out_slot+0, 0 as ptr
+    !found
+    !probe_found
+    !hash
+    !seed
+    !cap_is_zero
+    !cap
+    !slots
+    !out_slot
+    !key
+    !map
+    return 0
+
+L_PROBE_EXISTING_ZERO:
+    store out_slot+0, 0 as ptr
+    !cap_is_zero
+    !cap
+    !slots
+    !out_slot
+    !key
+    !map
+    return 0
+
+@export sa_map_new() -> ^ptr:
+L_ENTRY:
+    map = alloc HashMap_SIZE
+    store map+HashMap_slots, 0 as ptr
+    store map+HashMap_cap, 0 as u64
+    store map+HashMap_len, 0 as u64
+    store map+HashMap_tombs, 0 as u64
+    store map+HashMap_seed, 0 as u64
+    return map
+
+@export sa_map_with_seed(seed: u64) -> ^ptr:
+L_ENTRY:
+    map = call @sa_map_new()
+    store map+HashMap_seed, seed as u64
+    !seed
+    return map
+
+@export sa_map_with_capacity(cap: u64) -> ^ptr:
+L_ENTRY:
+    map = call @sa_map_with_capacity_seed(cap, 0)
+    !cap
+    return map
+
+@export sa_map_with_capacity_seed(cap: u64, seed: u64) -> ^ptr:
+L_ENTRY:
+    map = call @sa_map_with_seed(seed)
+    cap_is_zero = eq cap, 0
+    br cap_is_zero -> L_WITH_CAP_ZERO, L_WITH_CAP_ALLOC
+
+L_WITH_CAP_ALLOC:
+    next_cap = call @map_next_capacity(cap)
+    call @map_rehash(&map, next_cap)
+    !cap_is_zero
+    !seed
+    !cap
+    return map
+
+L_WITH_CAP_ZERO:
+    !cap_is_zero
+    !seed
+    !cap
+    return map
+
+@export sa_map_try_with_capacity(cap: u64, &out_map_slot: ptr) -> i32:
+L_ENTRY:
+    map = call @sa_map_with_capacity(cap)
+    store out_map_slot+0, map as ptr
+    !map
+    !out_map_slot
+    !cap
+    return 1
+
+@export sa_map_len(&map: ptr) -> u64:
+L_ENTRY:
+    len = load map+HashMap_len as u64
+    !map
+    return len
+
+@export sa_map_capacity(&map: ptr) -> u64:
+L_ENTRY:
+    cap = load map+HashMap_cap as u64
+    !map
+    return cap
+
+@export sa_map_reserve(&map: ptr, additional: u64) -> void:
+L_ENTRY:
+    len = load map+HashMap_len as u64
+    cap = load map+HashMap_cap as u64
+    EXPAND NUM_U64_CHECKED_ADD needed_ok, needed, len, additional
+    br needed_ok -> L_RESERVE_NEEDED_OK, L_RESERVE_OVERFLOW
+
+L_RESERVE_OVERFLOW:
+    panic(1303)
+
+L_RESERVE_NEEDED_OK:
+    has_room = uge cap, needed
+    br has_room -> L_RESERVE_DONE, L_RESERVE_GROW
+
+L_RESERVE_GROW:
+    next_cap = call @map_next_capacity(needed)
+    call @map_rehash(&map, next_cap)
+    !next_cap
+    !has_room
+    !needed
+    !needed_ok
+    !cap
+    !len
+    !additional
+    !map
+    return
+
+L_RESERVE_DONE:
+    !has_room
+    !needed
+    !needed_ok
+    !cap
+    !len
+    !additional
+    !map
+    return
+
+@export sa_map_try_reserve(&map: ptr, additional: u64) -> i32:
+L_ENTRY:
+    call @sa_map_reserve(&map, additional)
+    !additional
+    !map
+    return 1
+
+@export sa_map_shrink_to(&map: ptr, min_capacity: u64) -> void:
+L_ENTRY:
+    len = load map+HashMap_len as u64
+    cap = load map+HashMap_cap as u64
+    keep_len = uge len, min_capacity
+    br keep_len -> L_SHRINK_TO_TARGET_LEN, L_SHRINK_TO_TARGET_MIN
+
+L_SHRINK_TO_TARGET_LEN:
+    requested = add len, 0
+    jmp L_SHRINK_TO_PLAN
+
+L_SHRINK_TO_TARGET_MIN:
+    requested = add min_capacity, 0
+
+L_SHRINK_TO_PLAN:
+    target_cap = call @map_next_capacity(requested)
+    target_zero = eq target_cap, 0
+    br target_zero -> L_SHRINK_TO_ZERO, L_SHRINK_TO_CHECK
+
+L_SHRINK_TO_ZERO:
+    call @sa_map_shrink_to_fit(&map)
+    !target_zero
+    !target_cap
+    !requested
+    !keep_len
+    !cap
+    !len
+    !min_capacity
+    !map
+    return
+
+L_SHRINK_TO_CHECK:
+    should_shrink = ult target_cap, cap
+    br should_shrink -> L_SHRINK_TO_REHASH, L_SHRINK_TO_DONE
+
+L_SHRINK_TO_REHASH:
+    call @map_rehash(&map, target_cap)
+    !should_shrink
+    !target_zero
+    !target_cap
+    !requested
+    !keep_len
+    !cap
+    !len
+    !min_capacity
+    !map
+    return
+
+L_SHRINK_TO_DONE:
+    !should_shrink
+    !target_zero
+    !target_cap
+    !requested
+    !keep_len
+    !cap
+    !len
+    !min_capacity
+    !map
+    return
+
+@export sa_map_shrink_to_fit(&map: ptr) -> void:
+L_ENTRY:
+    len = load map+HashMap_len as u64
+    cap = load map+HashMap_cap as u64
+    is_empty = eq len, 0
+    br is_empty -> L_SHRINK_EMPTY, L_SHRINK_NONEMPTY
+
+L_SHRINK_NONEMPTY:
+    next_cap = call @map_next_capacity(len)
+    needs_rehash = ne cap, next_cap
+    br needs_rehash -> L_SHRINK_REHASH, L_SHRINK_DONE
+
+L_SHRINK_REHASH:
+    call @map_rehash(&map, next_cap)
+    !needs_rehash
+    !next_cap
+    !is_empty
+    !cap
+    !len
+    !map
+    return
+
+L_SHRINK_DONE:
+    !needs_rehash
+    !next_cap
+    !is_empty
+    !cap
+    !len
+    !map
+    return
+
+L_SHRINK_EMPTY:
+    slots = take map+HashMap_slots
+    has_slots = ne slots, 0
+    br has_slots -> L_SHRINK_FREE, L_SHRINK_RESET
+
+L_SHRINK_FREE:
+    !slots
+    store map+HashMap_slots, 0 as ptr
+    store map+HashMap_cap, 0 as u64
+    store map+HashMap_len, 0 as u64
+    store map+HashMap_tombs, 0 as u64
+    !has_slots
+    !is_empty
+    !cap
+    !len
+    !map
+    return
+
+L_SHRINK_RESET:
+    store map+HashMap_slots, 0 as ptr
+    store map+HashMap_cap, 0 as u64
+    store map+HashMap_len, 0 as u64
+    store map+HashMap_tombs, 0 as u64
+    !has_slots
+    !slots
+    !is_empty
+    !cap
+    !len
+    !map
+    return
+
+@export sa_map_is_empty(&map: ptr) -> i32:
+L_ENTRY:
+    len = load map+HashMap_len as u64
+    empty = eq len, 0
+    result = empty as i32
+    !len
+    !map
+    return result
+
+@export sa_map_contains_key(&map: ptr, &key: ptr) -> i32:
+L_ENTRY:
+    slots = load map+HashMap_slots as ptr
+    cap = load map+HashMap_cap as u64
+    cap_is_zero = eq cap, 0
+    br cap_is_zero -> L_CONTAINS_MISS_ZERO, L_CONTAINS_PROBE
+
+L_CONTAINS_PROBE:
+    seed = load map+HashMap_seed as u64
+    hash = call @map_hash_ptr_seed(&key, seed)
+    probe_index_slot = stack_alloc 8
+    probe_found_slot = stack_alloc 8
+    call @map_table_probe(&slots, cap, hash, &key, &probe_index_slot, &probe_found_slot)
+    probe_found = load probe_found_slot+0 as u64
+    found = ne probe_found, 0
+    result = found as i32
+    !probe_found
+    !hash
+    !seed
+    !key
+    !cap
+    !cap_is_zero
+    !slots
+    return result
+
+L_CONTAINS_MISS_ZERO:
+    !cap
+    !cap_is_zero
+    !key
+    !slots
+    return 0
+
+@export sa_map_clear(&map: ptr) -> void:
+L_ENTRY:
+    slots = load map+HashMap_slots as ptr
+    cap = load map+HashMap_cap as u64
+    EXPAND NUM_U64_CHECKED_MUL clear_bytes_ok, bytes, cap, HashMapSlot_SIZE
+    br clear_bytes_ok -> L_CLEAR_BYTES_OK, L_CLEAR_BYTES_OVERFLOW
+
+L_CLEAR_BYTES_OVERFLOW:
+    panic(1305)
+
+L_CLEAR_BYTES_OK:
+    has_slots = ne slots, 0
+    br has_slots -> L_CLEAR_SLOTS, L_CLEAR_DONE
+
+L_CLEAR_SLOTS:
+    call @sa_mem_set(&slots, 0, bytes)
+    jmp L_CLEAR_DONE
+
+L_CLEAR_DONE:
+    store map+HashMap_len, 0 as u64
+    store map+HashMap_tombs, 0 as u64
+    !clear_bytes_ok
+    !bytes
+    !has_slots
+    !cap
+    !slots
+    !map
+    return
+
+@export sa_map_free(^map: ptr) -> void:
+L_ENTRY:
+    slots = take map+HashMap_slots
+    has_slots = ne slots, 0
+    br has_slots -> L_FREE_SLOTS, L_FREE_MAP
+
+L_FREE_SLOTS:
+    !slots
+
+L_FREE_MAP:
+    !has_slots
+    !map
+    return
+
+@export sa_map_put(&map: ptr, &key: ptr, &value: ptr) -> void:
+L_ENTRY:
+    slots = load map+HashMap_slots as ptr
+    cap = load map+HashMap_cap as u64
+    len = load map+HashMap_len as u64
+    tombs = load map+HashMap_tombs as u64
+    used = add len, tombs
+    used_twice = shl used, 1
+    cap_is_zero = eq cap, 0
+    pressure = uge used_twice, cap
+    grow = or cap_is_zero, pressure
+    br grow -> L_PUT_GROW, L_PUT_PROBE_DIRECT
+
+L_PUT_GROW:
+    br cap_is_zero -> L_PUT_GROW_INIT, L_PUT_GROW_DOUBLE
+
+L_PUT_GROW_INIT:
+    next_cap_raw = HashMap_INITIAL_CAP
+    next_cap = next_cap_raw
+    jmp L_PUT_GROW_REHASH
+
+L_PUT_GROW_DOUBLE:
+    EXPAND NUM_U64_CHECKED_ADD next_cap_raw_ok, next_cap_raw, cap, cap
+    br next_cap_raw_ok -> L_PUT_GROW_DOUBLE_OK, L_PUT_GROW_DOUBLE_OVERFLOW
+
+L_PUT_GROW_DOUBLE_OVERFLOW:
+    panic(1304)
+
+L_PUT_GROW_DOUBLE_OK:
+    next_cap = next_cap_raw
+    !next_cap_raw_ok
+    jmp L_PUT_GROW_REHASH
+
+L_PUT_GROW_REHASH:
+    !cap
+    !len
+    !tombs
+    !cap_is_zero
+    !slots
+    call @map_rehash(&map, next_cap)
+    slots = load map+HashMap_slots as ptr
+    cap = load map+HashMap_cap as u64
+    len = load map+HashMap_len as u64
+    tombs = load map+HashMap_tombs as u64
+    !next_cap
+    jmp L_PUT_PROBE
+
+L_PUT_PROBE_DIRECT:
+    !cap_is_zero
+    jmp L_PUT_PROBE
+
+L_PUT_PROBE:
+    seed = load map+HashMap_seed as u64
+    hash = call @map_hash_ptr_seed(&key, seed)
+    probe_index_slot = stack_alloc 8
+    probe_found_slot = stack_alloc 8
+    call @map_table_probe(&slots, cap, hash, &key, &probe_index_slot, &probe_found_slot)
+    probe_index = load probe_index_slot+0 as u64
+    probe_found = load probe_found_slot+0 as u64
+    slot_off = mul probe_index, HashMapSlot_SIZE
+    slot = ptr_add slots, slot_off
+    already_found = ne probe_found, 0
+    br already_found -> L_PUT_UPDATE, L_PUT_INSERT
+
+L_PUT_UPDATE:
+    store slot+HashMapSlot_value, value as ptr
+    jmp L_PUT_END
+
+L_PUT_INSERT:
+    slot_state = load slot+HashMapSlot_state as u8
+    tomb_slot = eq slot_state, HashMap_STATE_TOMB
+    br tomb_slot -> L_PUT_INSERT_TOMB, L_PUT_INSERT_EMPTY
+
+L_PUT_INSERT_TOMB:
+    next_tombs = sub tombs, 1
+    store map+HashMap_tombs, next_tombs as u64
+    !next_tombs
+    jmp L_PUT_INSERT_EMPTY
+
+L_PUT_INSERT_EMPTY:
+    next_len = add len, 1
+    store map+HashMap_len, next_len as u64
+    store slot+HashMapSlot_hash, hash as u64
+    store slot+HashMapSlot_key, key as ptr
+    store slot+HashMapSlot_value, value as ptr
+    store slot+HashMapSlot_state, HashMap_STATE_FILLED as u8
+    !next_len
+    !slot_state
+    !tomb_slot
+    !probe_found
+    !probe_index
+    !slot_off
+    !slot
+    !hash
+    !seed
+    !key
+    !value
+    !cap
+    !len
+    !tombs
+    !used
+    !used_twice
+    !pressure
+    !grow
+    !slots
+    return
+
+L_PUT_END:
+    !probe_found
+    !probe_index
+    !slot_off
+    !slot
+    !hash
+    !seed
+    !key
+    !value
+    !cap
+    !len
+    !tombs
+    !used
+    !used_twice
+    !pressure
+    !grow
+    !slots
+    return
+
+@export sa_map_get(&map: ptr, &key: ptr) -> &ptr:
+L_ENTRY:
+    slots = load map+HashMap_slots as ptr
+    cap = load map+HashMap_cap as u64
+    cap_is_zero = eq cap, 0
+    br cap_is_zero -> L_GET_MISS_ZERO, L_GET_PROBE
+
+L_GET_PROBE:
+    seed = load map+HashMap_seed as u64
+    hash = call @map_hash_ptr_seed(&key, seed)
+    probe_index_slot = stack_alloc 8
+    probe_found_slot = stack_alloc 8
+    call @map_table_probe(&slots, cap, hash, &key, &probe_index_slot, &probe_found_slot)
+    probe_found = load probe_found_slot+0 as u64
+    found = ne probe_found, 0
+    br found -> L_GET_HIT, L_GET_MISS_PROBE
+
+L_GET_HIT:
+    probe_index = load probe_index_slot+0 as u64
+    slot_off = mul probe_index, HashMapSlot_SIZE
+    slot = ptr_add slots, slot_off
+    value = load slot+HashMapSlot_value as ptr
+    !slot
+    !slot_off
+    !probe_index
+    !probe_found
+    !hash
+    !seed
+    !key
+    !cap
+    !cap_is_zero
+    !slots
+    return value
+
+L_GET_MISS_PROBE:
+    !probe_found
+    !hash
+    !seed
+    !key
+    !cap
+    !cap_is_zero
+    !slots
+    return 0
+
+L_GET_MISS_ZERO:
+    !cap
+    !cap_is_zero
+    !key
+    !slots
+    return 0
+
+@export sa_map_try_get(&map: ptr, &key: ptr, &out_value_slot: ptr) -> i32:
+L_ENTRY:
+    slot_slot = stack_alloc 8
+    found = call @map_probe_existing(&map, &key, &slot_slot)
+    found_nonzero = ne found, 0
+    br found_nonzero -> L_TRY_GET_HIT, L_TRY_GET_MISS
+
+L_TRY_GET_HIT:
+    slot = load slot_slot+0 as ptr
+    value = load slot+HashMapSlot_value as ptr
+    store out_value_slot+0, value as ptr
+    !value
+    !slot
+    !found_nonzero
+    !found
+    !out_value_slot
+    !key
+    !map
+    return 1
+
+L_TRY_GET_MISS:
+    store out_value_slot+0, 0 as ptr
+    !found_nonzero
+    !found
+    !out_value_slot
+    !key
+    !map
+    return 0
+
+@export sa_map_try_get_key_value(&map: ptr, &key: ptr, &out_key_slot: ptr, &out_value_slot: ptr) -> i32:
+L_ENTRY:
+    slot_slot = stack_alloc 8
+    found = call @map_probe_existing(&map, &key, &slot_slot)
+    found_nonzero = ne found, 0
+    br found_nonzero -> L_GET_KEY_VALUE_HIT, L_GET_KEY_VALUE_MISS
+
+L_GET_KEY_VALUE_HIT:
+    slot = load slot_slot+0 as ptr
+    stored_key = load slot+HashMapSlot_key as ptr
+    stored_value = load slot+HashMapSlot_value as ptr
+    store out_key_slot+0, stored_key as ptr
+    store out_value_slot+0, stored_value as ptr
+    !stored_value
+    !stored_key
+    !slot
+    !found_nonzero
+    !found
+    !out_value_slot
+    !out_key_slot
+    !key
+    !map
+    return 1
+
+L_GET_KEY_VALUE_MISS:
+    store out_key_slot+0, 0 as ptr
+    store out_value_slot+0, 0 as ptr
+    !found_nonzero
+    !found
+    !out_value_slot
+    !out_key_slot
+    !key
+    !map
+    return 0
+
+@export sa_map_get_mut_ptr(&map: ptr, &key: ptr, &out_ptr_slot: ptr) -> i32:
+L_ENTRY:
+    slot_slot = stack_alloc 8
+    found = call @map_probe_existing(&map, &key, &slot_slot)
+    found_nonzero = ne found, 0
+    br found_nonzero -> L_GET_MUT_HIT, L_GET_MUT_MISS
+
+L_GET_MUT_HIT:
+    slot = load slot_slot+0 as ptr
+    value_ptr = ptr_add slot, HashMapSlot_value
+    store out_ptr_slot+0, value_ptr as ptr
+    !value_ptr
+    !slot
+    !found_nonzero
+    !found
+    !out_ptr_slot
+    !key
+    !map
+    return 1
+
+L_GET_MUT_MISS:
+    store out_ptr_slot+0, 0 as ptr
+    !found_nonzero
+    !found
+    !out_ptr_slot
+    !key
+    !map
+    return 0
+
+@export sa_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:
+    same_key = eq key_a, key_b
+    br same_key -> L_DISJOINT_MUT_SAME, L_DISJOINT_MUT_LOOKUP_A
+
+L_DISJOINT_MUT_LOOKUP_A:
+    found_a = call @sa_map_get_mut_ptr(&map, &key_a, &out_ptr_a_slot)
+    has_a = ne found_a, 0
+    br has_a -> L_DISJOINT_MUT_LOOKUP_B, L_DISJOINT_MUT_MISS_A
+
+L_DISJOINT_MUT_LOOKUP_B:
+    found_b = call @sa_map_get_mut_ptr(&map, &key_b, &out_ptr_b_slot)
+    has_b = ne found_b, 0
+    br has_b -> L_DISJOINT_MUT_HIT, L_DISJOINT_MUT_MISS_B
+
+L_DISJOINT_MUT_HIT:
+    !has_b
+    !found_b
+    !has_a
+    !found_a
+    !same_key
+    !out_ptr_b_slot
+    !out_ptr_a_slot
+    !key_b
+    !key_a
+    !map
+    return 1
+
+L_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
+    !out_ptr_b_slot
+    !out_ptr_a_slot
+    !key_b
+    !key_a
+    !map
+    return 0
+
+L_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
+    !out_ptr_b_slot
+    !out_ptr_a_slot
+    !key_b
+    !key_a
+    !map
+    return 0
+
+L_DISJOINT_MUT_SAME:
+    store out_ptr_a_slot+0, 0 as ptr
+    store out_ptr_b_slot+0, 0 as ptr
+    !same_key
+    !out_ptr_b_slot
+    !out_ptr_a_slot
+    !key_b
+    !key_a
+    !map
+    return 0
+
+@export sa_map_insert(&map: ptr, &key: ptr, &value: ptr, &out_old_value_slot: ptr) -> i32:
+L_ENTRY:
+    replaced = call @sa_map_try_get(&map, &key, &out_old_value_slot)
+    call @sa_map_put(&map, &key, &value)
+    !out_old_value_slot
+    !value
+    !key
+    !map
+    return replaced
+
+@export sa_map_try_insert(&map: ptr, &key: ptr, &value: ptr, &out_value_ptr_slot: ptr) -> i32:
+L_ENTRY:
+    slot_slot = stack_alloc 8
+    found = call @map_probe_existing(&map, &key, &slot_slot)
+    found_nonzero = ne found, 0
+    br found_nonzero -> L_TRY_INSERT_EXISTS, L_TRY_INSERT_NEW
+
+L_TRY_INSERT_EXISTS:
+    slot = load slot_slot+0 as ptr
+    value_ptr = ptr_add slot, HashMapSlot_value
+    store out_value_ptr_slot+0, value_ptr as ptr
+    !value_ptr
+    !slot
+    !found_nonzero
+    !found
+    !out_value_ptr_slot
+    !value
+    !key
+    !map
+    return 0
+
+L_TRY_INSERT_NEW:
+    call @sa_map_put(&map, &key, &value)
+    inserted_found = call @map_probe_existing(&map, &key, &slot_slot)
+    slot = load slot_slot+0 as ptr
+    value_ptr = ptr_add slot, HashMapSlot_value
+    store out_value_ptr_slot+0, value_ptr as ptr
+    !value_ptr
+    !slot
+    !inserted_found
+    !found_nonzero
+    !found
+    !out_value_ptr_slot
+    !value
+    !key
+    !map
+    return 1
+
+@export sa_map_keys_vec(&map: ptr) -> ^ptr:
+L_ENTRY:
+    len = load map+HashMap_len as u64
+    out_vec = call @sa_vec_with_capacity(len, 8)
+    slots = load map+HashMap_slots as ptr
+    cap = load map+HashMap_cap as u64
+    idx_slot = stack_alloc 8
+    store idx_slot+0, 0 as u64
+    jmp L_MAP_KEYS_HEAD
+
+L_MAP_KEYS_HEAD:
+    idx = load idx_slot+0 as u64
+    done = eq idx, cap
+    br done -> L_MAP_KEYS_DONE, L_MAP_KEYS_BODY
+
+L_MAP_KEYS_BODY:
+    slot_off = mul idx, HashMapSlot_SIZE
+    slot = ptr_add slots, slot_off
+    state = load slot+HashMapSlot_state as u8
+    filled = eq state, HashMap_STATE_FILLED
+    br filled -> L_MAP_KEYS_PUSH, L_MAP_KEYS_NEXT
+
+L_MAP_KEYS_PUSH:
+    key = load slot+HashMapSlot_key as ptr
+    key_bits = bitcast key as u64
+    out_vec = call @sa_vec_push(^out_vec, key_bits, 8)
+    !key_bits
+    !key
+    jmp L_MAP_KEYS_NEXT
+
+L_MAP_KEYS_NEXT:
+    next_idx = add idx, 1
+    store idx_slot+0, next_idx as u64
+    !next_idx
+    !filled
+    !state
+    !slot
+    !slot_off
+    !done
+    !idx
+    jmp L_MAP_KEYS_HEAD
+
+L_MAP_KEYS_DONE:
+    !done
+    !idx
+    !cap
+    !slots
+    !len
+    !map
+    return out_vec
+
+@export sa_map_values_vec(&map: ptr) -> ^ptr:
+L_ENTRY:
+    len = load map+HashMap_len as u64
+    out_vec = call @sa_vec_with_capacity(len, 8)
+    slots = load map+HashMap_slots as ptr
+    cap = load map+HashMap_cap as u64
+    idx_slot = stack_alloc 8
+    store idx_slot+0, 0 as u64
+    jmp L_MAP_VALUES_HEAD
+
+L_MAP_VALUES_HEAD:
+    idx = load idx_slot+0 as u64
+    done = eq idx, cap
+    br done -> L_MAP_VALUES_DONE, L_MAP_VALUES_BODY
+
+L_MAP_VALUES_BODY:
+    slot_off = mul idx, HashMapSlot_SIZE
+    slot = ptr_add slots, slot_off
+    state = load slot+HashMapSlot_state as u8
+    filled = eq state, HashMap_STATE_FILLED
+    br filled -> L_MAP_VALUES_PUSH, L_MAP_VALUES_NEXT
+
+L_MAP_VALUES_PUSH:
+    value = load slot+HashMapSlot_value as ptr
+    value_bits = bitcast value as u64
+    out_vec = call @sa_vec_push(^out_vec, value_bits, 8)
+    !value_bits
+    !value
+    jmp L_MAP_VALUES_NEXT
+
+L_MAP_VALUES_NEXT:
+    next_idx = add idx, 1
+    store idx_slot+0, next_idx as u64
+    !next_idx
+    !filled
+    !state
+    !slot
+    !slot_off
+    !done
+    !idx
+    jmp L_MAP_VALUES_HEAD
+
+L_MAP_VALUES_DONE:
+    !done
+    !idx
+    !cap
+    !slots
+    !len
+    !map
+    return out_vec
+
+@export sa_map_value_mut_ptrs_vec(&map: ptr) -> ^ptr:
+L_ENTRY:
+    len = load map+HashMap_len as u64
+    out_vec = call @sa_vec_with_capacity(len, 8)
+    slots = load map+HashMap_slots as ptr
+    cap = load map+HashMap_cap as u64
+    idx_slot = stack_alloc 8
+    store idx_slot+0, 0 as u64
+    jmp L_MAP_VALUE_MUT_PTRS_HEAD
+
+L_MAP_VALUE_MUT_PTRS_HEAD:
+    idx = load idx_slot+0 as u64
+    done = eq idx, cap
+    br done -> L_MAP_VALUE_MUT_PTRS_DONE, L_MAP_VALUE_MUT_PTRS_BODY
+
+L_MAP_VALUE_MUT_PTRS_BODY:
+    slot_off = mul idx, HashMapSlot_SIZE
+    slot = ptr_add slots, slot_off
+    state = load slot+HashMapSlot_state as u8
+    filled = eq state, HashMap_STATE_FILLED
+    br filled -> L_MAP_VALUE_MUT_PTRS_PUSH, L_MAP_VALUE_MUT_PTRS_NEXT
+
+L_MAP_VALUE_MUT_PTRS_PUSH:
+    value_ptr = ptr_add slot, HashMapSlot_value
+    value_ptr_bits = bitcast value_ptr as u64
+    out_vec = call @sa_vec_push(^out_vec, value_ptr_bits, 8)
+    !value_ptr_bits
+    !value_ptr
+    jmp L_MAP_VALUE_MUT_PTRS_NEXT
+
+L_MAP_VALUE_MUT_PTRS_NEXT:
+    next_idx = add idx, 1
+    store idx_slot+0, next_idx as u64
+    !next_idx
+    !filled
+    !state
+    !slot
+    !slot_off
+    !done
+    !idx
+    jmp L_MAP_VALUE_MUT_PTRS_HEAD
+
+L_MAP_VALUE_MUT_PTRS_DONE:
+    !done
+    !idx
+    !cap
+    !slots
+    !len
+    !map
+    return out_vec
+
+@export sa_map_iter_vec(&map: ptr) -> ^ptr:
+L_ENTRY:
+    len = load map+HashMap_len as u64
+    EXPAND NUM_U64_CHECKED_ADD map_iter_cap_hint_ok, map_iter_cap_hint, len, len
+    br map_iter_cap_hint_ok -> L_MAP_ITER_CAP_OK, L_MAP_ITER_CAP_OVERFLOW
+
+L_MAP_ITER_CAP_OVERFLOW:
+    panic(1309)
+
+L_MAP_ITER_CAP_OK:
+    out_vec = call @sa_vec_with_capacity(map_iter_cap_hint, 8)
+    slots = load map+HashMap_slots as ptr
+    cap = load map+HashMap_cap as u64
+    idx_slot = stack_alloc 8
+    store idx_slot+0, 0 as u64
+    jmp L_MAP_ITER_HEAD
+
+L_MAP_ITER_HEAD:
+    idx = load idx_slot+0 as u64
+    done = eq idx, cap
+    br done -> L_MAP_ITER_DONE, L_MAP_ITER_BODY
+
+L_MAP_ITER_BODY:
+    slot_off = mul idx, HashMapSlot_SIZE
+    slot = ptr_add slots, slot_off
+    state = load slot+HashMapSlot_state as u8
+    filled = eq state, HashMap_STATE_FILLED
+    br filled -> L_MAP_ITER_PUSH, L_MAP_ITER_NEXT
+
+L_MAP_ITER_PUSH:
+    key = load slot+HashMapSlot_key as ptr
+    value = load slot+HashMapSlot_value as ptr
+    key_bits = bitcast key as u64
+    value_bits = bitcast value as u64
+    out_vec = call @sa_vec_push(^out_vec, key_bits, 8)
+    out_vec = call @sa_vec_push(^out_vec, value_bits, 8)
+    !value_bits
+    !key_bits
+    !value
+    !key
+    jmp L_MAP_ITER_NEXT
+
+L_MAP_ITER_NEXT:
+    next_idx = add idx, 1
+    store idx_slot+0, next_idx as u64
+    !next_idx
+    !filled
+    !state
+    !slot
+    !slot_off
+    !done
+    !idx
+    jmp L_MAP_ITER_HEAD
+
+L_MAP_ITER_DONE:
+    !done
+    !idx
+    !cap
+    !slots
+    !map_iter_cap_hint_ok
+    !map_iter_cap_hint
+    !len
+    !map
+    return out_vec
+
+@export sa_map_iter_mut_ptrs_vec(&map: ptr) -> ^ptr:
+L_ENTRY:
+    len = load map+HashMap_len as u64
+    EXPAND NUM_U64_CHECKED_ADD map_iter_mut_cap_hint_ok, map_iter_mut_cap_hint, len, len
+    br map_iter_mut_cap_hint_ok -> L_MAP_ITER_MUT_CAP_OK, L_MAP_ITER_MUT_CAP_OVERFLOW
+
+L_MAP_ITER_MUT_CAP_OVERFLOW:
+    panic(1310)
+
+L_MAP_ITER_MUT_CAP_OK:
+    out_vec = call @sa_vec_with_capacity(map_iter_mut_cap_hint, 8)
+    slots = load map+HashMap_slots as ptr
+    cap = load map+HashMap_cap as u64
+    idx_slot = stack_alloc 8
+    store idx_slot+0, 0 as u64
+    jmp L_MAP_ITER_MUT_HEAD
+
+L_MAP_ITER_MUT_HEAD:
+    idx = load idx_slot+0 as u64
+    done = eq idx, cap
+    br done -> L_MAP_ITER_MUT_DONE, L_MAP_ITER_MUT_BODY
+
+L_MAP_ITER_MUT_BODY:
+    slot_off = mul idx, HashMapSlot_SIZE
+    slot = ptr_add slots, slot_off
+    state = load slot+HashMapSlot_state as u8
+    filled = eq state, HashMap_STATE_FILLED
+    br filled -> L_MAP_ITER_MUT_PUSH, L_MAP_ITER_MUT_NEXT
+
+L_MAP_ITER_MUT_PUSH:
+    key = load slot+HashMapSlot_key as ptr
+    value_ptr = ptr_add slot, HashMapSlot_value
+    key_bits = bitcast key as u64
+    value_ptr_bits = bitcast value_ptr as u64
+    out_vec = call @sa_vec_push(^out_vec, key_bits, 8)
+    out_vec = call @sa_vec_push(^out_vec, value_ptr_bits, 8)
+    !value_ptr_bits
+    !key_bits
+    !value_ptr
+    !key
+    jmp L_MAP_ITER_MUT_NEXT
+
+L_MAP_ITER_MUT_NEXT:
+    next_idx = add idx, 1
+    store idx_slot+0, next_idx as u64
+    !next_idx
+    !filled
+    !state
+    !slot
+    !slot_off
+    !done
+    !idx
+    jmp L_MAP_ITER_MUT_HEAD
+
+L_MAP_ITER_MUT_DONE:
+    !done
+    !idx
+    !cap
+    !slots
+    !map_iter_mut_cap_hint_ok
+    !map_iter_mut_cap_hint
+    !len
+    !map
+    return out_vec
+
+@export sa_map_remove_entry(&map: ptr, &key: ptr, &out_key_slot: ptr, &out_value_slot: ptr) -> i32:
+L_ENTRY:
+    found = call @sa_map_try_get_key_value(&map, &key, &out_key_slot, &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_map_del(&map, &key)
+    !removed
+    !found_nonzero
+    !found
+    !out_value_slot
+    !out_key_slot
+    !key
+    !map
+    return 1
+
+L_REMOVE_ENTRY_MISS:
+    !found_nonzero
+    !found
+    !out_value_slot
+    !out_key_slot
+    !key
+    !map
+    return 0
+
+@export sa_map_del(&map: ptr, &key: ptr) -> &ptr:
+L_ENTRY:
+    slots = load map+HashMap_slots as ptr
+    cap = load map+HashMap_cap as u64
+    len = load map+HashMap_len as u64
+    tombs = load map+HashMap_tombs as u64
+    cap_is_zero = eq cap, 0
+    br cap_is_zero -> L_DEL_MISS_ZERO, L_DEL_PROBE
+
+L_DEL_PROBE:
+    seed = load map+HashMap_seed as u64
+    hash = call @map_hash_ptr_seed(&key, seed)
+    probe_index_slot = stack_alloc 8
+    probe_found_slot = stack_alloc 8
+    call @map_table_probe(&slots, cap, hash, &key, &probe_index_slot, &probe_found_slot)
+    probe_found = load probe_found_slot+0 as u64
+    found = ne probe_found, 0
+    br found -> L_DEL_HIT, L_DEL_MISS_PROBE
+
+L_DEL_HIT:
+    probe_index = load probe_index_slot+0 as u64
+    slot_off = mul probe_index, HashMapSlot_SIZE
+    slot = ptr_add slots, slot_off
+    value = load slot+HashMapSlot_value as ptr
+    next_len = sub len, 1
+    next_tombs = add tombs, 1
+    store map+HashMap_len, next_len as u64
+    store map+HashMap_tombs, next_tombs as u64
+    store slot+HashMapSlot_hash, 0 as u64
+    store slot+HashMapSlot_key, 0 as ptr
+    store slot+HashMapSlot_value, 0 as ptr
+    store slot+HashMapSlot_state, HashMap_STATE_TOMB as u8
+    !slot
+    !slot_off
+    !probe_index
+    !probe_found
+    !hash
+    !seed
+    !cap
+    !len
+    !tombs
+    !next_len
+    !next_tombs
+    !cap_is_zero
+    !key
+    !slots
+    !map
+    return value
+
+L_DEL_MISS_PROBE:
+    !probe_found
+    !hash
+    !seed
+    !key
+    !cap
+    !len
+    !tombs
+    !cap_is_zero
+    !slots
+    !map
+    return 0
+
+L_DEL_MISS_ZERO:
+    !cap
+    !len
+    !tombs
+    !cap_is_zero
+    !key
+    !slots
+    !map
+    return 0
+
+[MACRO] MAP_NEW %out_map
+    %out_map = call @sa_map_new()
+[END_MACRO]
+
+[MACRO] MAP_WITH_SEED %out_map, %seed
+    %out_map = call @sa_map_with_seed(%seed)
+[END_MACRO]
+
+[MACRO] MAP_WITH_CAPACITY %out_map, %cap
+    %out_map = call @sa_map_with_capacity(%cap)
+[END_MACRO]
+
+[MACRO] MAP_WITH_CAPACITY_SEED %out_map, %cap, %seed
+    %out_map = call @sa_map_with_capacity_seed(%cap, %seed)
+[END_MACRO]
+
+[MACRO] MAP_TRY_WITH_CAPACITY %out_ok, %out_map, %cap
+    __map_try_new_slot_%out_ok = stack_alloc 8
+    %out_ok = call @sa_map_try_with_capacity(%cap, &__map_try_new_slot_%out_ok)
+    %out_map = load __map_try_new_slot_%out_ok+0 as ptr
+[END_MACRO]
+
+[MACRO] MAP_LEN %out_len, %map_reg
+    %out_len = call @sa_map_len(&%map_reg)
+[END_MACRO]
+
+[MACRO] MAP_CAPACITY %out_cap, %map_reg
+    %out_cap = call @sa_map_capacity(&%map_reg)
+[END_MACRO]
+
+[MACRO] MAP_EXTRA_CAPACITY %out_extra, %map_reg
+    __map_ec_cap_%out_extra = call @sa_map_capacity(&%map_reg)
+    __map_ec_len_%out_extra = call @sa_map_len(&%map_reg)
+    %out_extra = sub __map_ec_cap_%out_extra, __map_ec_len_%out_extra
+    !__map_ec_len_%out_extra
+    !__map_ec_cap_%out_extra
+[END_MACRO]
+
+[MACRO] MAP_RESERVE %map_reg, %additional
+    call @sa_map_reserve(&%map_reg, %additional)
+[END_MACRO]
+
+[MACRO] MAP_TRY_RESERVE %out_ok, %map_reg, %additional
+    %out_ok = call @sa_map_try_reserve(&%map_reg, %additional)
+[END_MACRO]
+
+[MACRO] MAP_SHRINK_TO %map_reg, %min_capacity
+    call @sa_map_shrink_to(&%map_reg, %min_capacity)
+[END_MACRO]
+
+[MACRO] MAP_SHRINK_TO_FIT %map_reg
+    call @sa_map_shrink_to_fit(&%map_reg)
+[END_MACRO]
+
+[MACRO] MAP_IS_EMPTY %out_flag, %map_reg
+    %out_flag = call @sa_map_is_empty(&%map_reg)
+[END_MACRO]
+
+[MACRO] MAP_CONTAINS_KEY %out_flag, %map_reg, %key_reg
+    %out_flag = call @sa_map_contains_key(&%map_reg, &%key_reg)
+[END_MACRO]
+
+[MACRO] MAP_CLEAR %map_reg
+    call @sa_map_clear(&%map_reg)
+[END_MACRO]
+
+[MACRO] MAP_RETAIN %out_len, %map_reg, %pred_fn
+    __map_retain_slots_%out_len = load %map_reg+HashMap_slots as ptr
+    __map_retain_cap_%out_len = load %map_reg+HashMap_cap as u64
+    __map_retain_len_%out_len = load %map_reg+HashMap_len as u64
+    __map_retain_tombs_start_%out_len = load %map_reg+HashMap_tombs as u64
+    __map_retain_len_slot_%out_len = stack_alloc 8
+    __map_retain_tombs_slot_%out_len = stack_alloc 8
+    store __map_retain_len_slot_%out_len+0, __map_retain_len_%out_len as u64
+    store __map_retain_tombs_slot_%out_len+0, __map_retain_tombs_start_%out_len as u64
+    __map_retain_idx_slot_%out_len = stack_alloc 8
+    store __map_retain_idx_slot_%out_len+0, 0 as u64
+    jmp L_MAP_RETAIN_HEAD_%out_len
+
+L_MAP_RETAIN_HEAD_%out_len:
+    __map_retain_idx_%out_len = load __map_retain_idx_slot_%out_len+0 as u64
+    __map_retain_done_%out_len = eq __map_retain_idx_%out_len, __map_retain_cap_%out_len
+    br __map_retain_done_%out_len -> L_MAP_RETAIN_DONE_%out_len, L_MAP_RETAIN_BODY_%out_len
+
+L_MAP_RETAIN_BODY_%out_len:
+    __map_retain_slot_off_%out_len = mul __map_retain_idx_%out_len, HashMapSlot_SIZE
+    __map_retain_slot_%out_len = ptr_add __map_retain_slots_%out_len, __map_retain_slot_off_%out_len
+    __map_retain_state_%out_len = load __map_retain_slot_%out_len+HashMapSlot_state as u8
+    __map_retain_filled_%out_len = eq __map_retain_state_%out_len, HashMap_STATE_FILLED
+    br __map_retain_filled_%out_len -> L_MAP_RETAIN_CHECK_%out_len, L_MAP_RETAIN_NEXT_%out_len
+
+L_MAP_RETAIN_CHECK_%out_len:
+    __map_retain_key_%out_len = load __map_retain_slot_%out_len+HashMapSlot_key as ptr
+    __map_retain_value_ptr_%out_len = ptr_add __map_retain_slot_%out_len, HashMapSlot_value
+    __map_retain_pred_%out_len = call %pred_fn(__map_retain_key_%out_len, __map_retain_value_ptr_%out_len)
+    __map_retain_keep_%out_len = ne __map_retain_pred_%out_len, 0
+    br __map_retain_keep_%out_len -> L_MAP_RETAIN_KEEP_%out_len, L_MAP_RETAIN_DROP_%out_len
+
+L_MAP_RETAIN_KEEP_%out_len:
+    !__map_retain_keep_%out_len
+    !__map_retain_pred_%out_len
+    !__map_retain_value_ptr_%out_len
+    !__map_retain_key_%out_len
+    jmp L_MAP_RETAIN_NEXT_%out_len
+
+L_MAP_RETAIN_DROP_%out_len:
+    __map_retain_cur_len_%out_len = load __map_retain_len_slot_%out_len+0 as u64
+    __map_retain_cur_tombs_%out_len = load __map_retain_tombs_slot_%out_len+0 as u64
+    __map_retain_next_len_%out_len = sub __map_retain_cur_len_%out_len, 1
+    __map_retain_next_tombs_%out_len = add __map_retain_cur_tombs_%out_len, 1
+    store __map_retain_len_slot_%out_len+0, __map_retain_next_len_%out_len as u64
+    store __map_retain_tombs_slot_%out_len+0, __map_retain_next_tombs_%out_len as u64
+    store __map_retain_slot_%out_len+HashMapSlot_hash, 0 as u64
+    store __map_retain_slot_%out_len+HashMapSlot_key, 0 as ptr
+    store __map_retain_slot_%out_len+HashMapSlot_value, 0 as ptr
+    store __map_retain_slot_%out_len+HashMapSlot_state, HashMap_STATE_TOMB as u8
+    !__map_retain_next_tombs_%out_len
+    !__map_retain_next_len_%out_len
+    !__map_retain_cur_tombs_%out_len
+    !__map_retain_cur_len_%out_len
+    !__map_retain_keep_%out_len
+    !__map_retain_pred_%out_len
+    !__map_retain_value_ptr_%out_len
+    !__map_retain_key_%out_len
+    jmp L_MAP_RETAIN_NEXT_%out_len
+
+L_MAP_RETAIN_NEXT_%out_len:
+    __map_retain_next_idx_%out_len = add __map_retain_idx_%out_len, 1
+    store __map_retain_idx_slot_%out_len+0, __map_retain_next_idx_%out_len as u64
+    !__map_retain_next_idx_%out_len
+    !__map_retain_filled_%out_len
+    !__map_retain_state_%out_len
+    !__map_retain_slot_%out_len
+    !__map_retain_slot_off_%out_len
+    !__map_retain_done_%out_len
+    !__map_retain_idx_%out_len
+    jmp L_MAP_RETAIN_HEAD_%out_len
+
+L_MAP_RETAIN_DONE_%out_len:
+    %out_len = load __map_retain_len_slot_%out_len+0 as u64
+    __map_retain_tombs_%out_len = load __map_retain_tombs_slot_%out_len+0 as u64
+    store %map_reg+HashMap_len, %out_len as u64
+    store %map_reg+HashMap_tombs, __map_retain_tombs_%out_len as u64
+    !__map_retain_done_%out_len
+    !__map_retain_idx_%out_len
+    !__map_retain_tombs_%out_len
+    !__map_retain_tombs_start_%out_len
+    !__map_retain_len_%out_len
+    !__map_retain_cap_%out_len
+    !__map_retain_slots_%out_len
+[END_MACRO]
+
+[MACRO] MAP_DRAIN %out_vec, %map_reg
+    __map_drain_len_%out_vec = load %map_reg+HashMap_len as u64
+    EXPAND NUM_U64_CHECKED_ADD __map_drain_cap_hint_ok_%out_vec, __map_drain_cap_hint_%out_vec, __map_drain_len_%out_vec, __map_drain_len_%out_vec
+    br __map_drain_cap_hint_ok_%out_vec -> L_MAP_DRAIN_CAP_HINT_OK_%out_vec, L_MAP_DRAIN_CAP_HINT_OVERFLOW_%out_vec
+L_MAP_DRAIN_CAP_HINT_OVERFLOW_%out_vec:
+    panic(1306)
+L_MAP_DRAIN_CAP_HINT_OK_%out_vec:
+    EXPAND VEC_WITH_CAPACITY_U64 %out_vec, __map_drain_cap_hint_%out_vec
+    __map_drain_slots_%out_vec = load %map_reg+HashMap_slots as ptr
+    __map_drain_cap_%out_vec = load %map_reg+HashMap_cap as u64
+    __map_drain_idx_slot_%out_vec = stack_alloc 8
+    store __map_drain_idx_slot_%out_vec+0, 0 as u64
+    jmp L_MAP_DRAIN_HEAD_%out_vec
+
+L_MAP_DRAIN_HEAD_%out_vec:
+    __map_drain_idx_%out_vec = load __map_drain_idx_slot_%out_vec+0 as u64
+    __map_drain_done_%out_vec = eq __map_drain_idx_%out_vec, __map_drain_cap_%out_vec
+    br __map_drain_done_%out_vec -> L_MAP_DRAIN_DONE_%out_vec, L_MAP_DRAIN_BODY_%out_vec
+
+L_MAP_DRAIN_BODY_%out_vec:
+    __map_drain_slot_off_%out_vec = mul __map_drain_idx_%out_vec, HashMapSlot_SIZE
+    __map_drain_slot_%out_vec = ptr_add __map_drain_slots_%out_vec, __map_drain_slot_off_%out_vec
+    __map_drain_state_%out_vec = load __map_drain_slot_%out_vec+HashMapSlot_state as u8
+    __map_drain_filled_%out_vec = eq __map_drain_state_%out_vec, HashMap_STATE_FILLED
+    br __map_drain_filled_%out_vec -> L_MAP_DRAIN_PUSH_%out_vec, L_MAP_DRAIN_NEXT_%out_vec
+
+L_MAP_DRAIN_PUSH_%out_vec:
+    __map_drain_key_%out_vec = load __map_drain_slot_%out_vec+HashMapSlot_key as ptr
+    __map_drain_value_%out_vec = load __map_drain_slot_%out_vec+HashMapSlot_value as ptr
+    __map_drain_key_bits_%out_vec = bitcast __map_drain_key_%out_vec as u64
+    __map_drain_value_bits_%out_vec = bitcast __map_drain_value_%out_vec as u64
+    EXPAND VEC_PUSH_U64 %out_vec, __map_drain_key_bits_%out_vec
+    EXPAND VEC_PUSH_U64 %out_vec, __map_drain_value_bits_%out_vec
+    store __map_drain_slot_%out_vec+HashMapSlot_hash, 0 as u64
+    store __map_drain_slot_%out_vec+HashMapSlot_key, 0 as ptr
+    store __map_drain_slot_%out_vec+HashMapSlot_value, 0 as ptr
+    store __map_drain_slot_%out_vec+HashMapSlot_state, HashMap_STATE_EMPTY as u8
+    !__map_drain_value_bits_%out_vec
+    !__map_drain_key_bits_%out_vec
+    !__map_drain_value_%out_vec
+    !__map_drain_key_%out_vec
+    jmp L_MAP_DRAIN_NEXT_%out_vec
+
+L_MAP_DRAIN_NEXT_%out_vec:
+    __map_drain_next_idx_%out_vec = add __map_drain_idx_%out_vec, 1
+    store __map_drain_idx_slot_%out_vec+0, __map_drain_next_idx_%out_vec as u64
+    !__map_drain_next_idx_%out_vec
+    !__map_drain_filled_%out_vec
+    !__map_drain_state_%out_vec
+    !__map_drain_slot_%out_vec
+    !__map_drain_slot_off_%out_vec
+    !__map_drain_done_%out_vec
+    !__map_drain_idx_%out_vec
+    jmp L_MAP_DRAIN_HEAD_%out_vec
+
+L_MAP_DRAIN_DONE_%out_vec:
+    EXPAND NUM_U64_CHECKED_MUL __map_drain_bytes_ok_%out_vec, __map_drain_bytes_%out_vec, __map_drain_cap_%out_vec, HashMapSlot_SIZE
+    br __map_drain_bytes_ok_%out_vec -> L_MAP_DRAIN_BYTES_OK_%out_vec, L_MAP_DRAIN_BYTES_OVERFLOW_%out_vec
+L_MAP_DRAIN_BYTES_OVERFLOW_%out_vec:
+    panic(1307)
+L_MAP_DRAIN_BYTES_OK_%out_vec:
+    __map_drain_has_slots_%out_vec = ne __map_drain_slots_%out_vec, 0
+    br __map_drain_has_slots_%out_vec -> L_MAP_DRAIN_CLEAR_SLOTS_%out_vec, L_MAP_DRAIN_FINISH_%out_vec
+
+L_MAP_DRAIN_CLEAR_SLOTS_%out_vec:
+    call @sa_mem_set(&__map_drain_slots_%out_vec, 0, __map_drain_bytes_%out_vec)
+    jmp L_MAP_DRAIN_FINISH_%out_vec
+
+L_MAP_DRAIN_FINISH_%out_vec:
+    store %map_reg+HashMap_len, 0 as u64
+    store %map_reg+HashMap_tombs, 0 as u64
+    !__map_drain_has_slots_%out_vec
+    !__map_drain_bytes_ok_%out_vec
+    !__map_drain_bytes_%out_vec
+    !__map_drain_done_%out_vec
+    !__map_drain_idx_%out_vec
+    !__map_drain_cap_%out_vec
+    !__map_drain_slots_%out_vec
+    !__map_drain_cap_hint_ok_%out_vec
+    !__map_drain_cap_hint_%out_vec
+    !__map_drain_len_%out_vec
+[END_MACRO]
+
+[MACRO] MAP_EXTRACT_IF %out_len, %out_vec, %map_reg, %pred_fn
+    __map_extract_slots_%out_len = load %map_reg+HashMap_slots as ptr
+    __map_extract_cap_%out_len = load %map_reg+HashMap_cap as u64
+    __map_extract_len_%out_len = load %map_reg+HashMap_len as u64
+    __map_extract_tombs_start_%out_len = load %map_reg+HashMap_tombs as u64
+    EXPAND NUM_U64_CHECKED_ADD __map_extract_cap_hint_ok_%out_len, __map_extract_cap_hint_%out_len, __map_extract_len_%out_len, __map_extract_len_%out_len
+    br __map_extract_cap_hint_ok_%out_len -> L_MAP_EXTRACT_CAP_HINT_OK_%out_len, L_MAP_EXTRACT_CAP_HINT_OVERFLOW_%out_len
+L_MAP_EXTRACT_CAP_HINT_OVERFLOW_%out_len:
+    panic(1308)
+L_MAP_EXTRACT_CAP_HINT_OK_%out_len:
+    EXPAND VEC_WITH_CAPACITY_U64 %out_vec, __map_extract_cap_hint_%out_len
+    __map_extract_len_slot_%out_len = stack_alloc 8
+    __map_extract_tombs_slot_%out_len = stack_alloc 8
+    store __map_extract_len_slot_%out_len+0, __map_extract_len_%out_len as u64
+    store __map_extract_tombs_slot_%out_len+0, __map_extract_tombs_start_%out_len as u64
+    __map_extract_idx_slot_%out_len = stack_alloc 8
+    store __map_extract_idx_slot_%out_len+0, 0 as u64
+    jmp L_MAP_EXTRACT_HEAD_%out_len
+
+L_MAP_EXTRACT_HEAD_%out_len:
+    __map_extract_idx_%out_len = load __map_extract_idx_slot_%out_len+0 as u64
+    __map_extract_done_%out_len = eq __map_extract_idx_%out_len, __map_extract_cap_%out_len
+    br __map_extract_done_%out_len -> L_MAP_EXTRACT_DONE_%out_len, L_MAP_EXTRACT_BODY_%out_len
+
+L_MAP_EXTRACT_BODY_%out_len:
+    __map_extract_slot_off_%out_len = mul __map_extract_idx_%out_len, HashMapSlot_SIZE
+    __map_extract_slot_%out_len = ptr_add __map_extract_slots_%out_len, __map_extract_slot_off_%out_len
+    __map_extract_state_%out_len = load __map_extract_slot_%out_len+HashMapSlot_state as u8
+    __map_extract_filled_%out_len = eq __map_extract_state_%out_len, HashMap_STATE_FILLED
+    br __map_extract_filled_%out_len -> L_MAP_EXTRACT_CHECK_%out_len, L_MAP_EXTRACT_NEXT_%out_len
+
+L_MAP_EXTRACT_CHECK_%out_len:
+    __map_extract_key_%out_len = load __map_extract_slot_%out_len+HashMapSlot_key as ptr
+    __map_extract_value_ptr_%out_len = ptr_add __map_extract_slot_%out_len, HashMapSlot_value
+    __map_extract_pred_%out_len = call %pred_fn(__map_extract_key_%out_len, __map_extract_value_ptr_%out_len)
+    __map_extract_take_%out_len = ne __map_extract_pred_%out_len, 0
+    br __map_extract_take_%out_len -> L_MAP_EXTRACT_TAKE_%out_len, L_MAP_EXTRACT_KEEP_%out_len
+
+L_MAP_EXTRACT_KEEP_%out_len:
+    !__map_extract_take_%out_len
+    !__map_extract_pred_%out_len
+    !__map_extract_value_ptr_%out_len
+    !__map_extract_key_%out_len
+    jmp L_MAP_EXTRACT_NEXT_%out_len
+
+L_MAP_EXTRACT_TAKE_%out_len:
+    __map_extract_value_%out_len = load __map_extract_slot_%out_len+HashMapSlot_value as ptr
+    __map_extract_key_bits_%out_len = bitcast __map_extract_key_%out_len as u64
+    __map_extract_value_bits_%out_len = bitcast __map_extract_value_%out_len as u64
+    EXPAND VEC_PUSH_U64 %out_vec, __map_extract_key_bits_%out_len
+    EXPAND VEC_PUSH_U64 %out_vec, __map_extract_value_bits_%out_len
+    __map_extract_cur_len_%out_len = load __map_extract_len_slot_%out_len+0 as u64
+    __map_extract_cur_tombs_%out_len = load __map_extract_tombs_slot_%out_len+0 as u64
+    __map_extract_next_len_%out_len = sub __map_extract_cur_len_%out_len, 1
+    __map_extract_next_tombs_%out_len = add __map_extract_cur_tombs_%out_len, 1
+    store __map_extract_len_slot_%out_len+0, __map_extract_next_len_%out_len as u64
+    store __map_extract_tombs_slot_%out_len+0, __map_extract_next_tombs_%out_len as u64
+    store __map_extract_slot_%out_len+HashMapSlot_hash, 0 as u64
+    store __map_extract_slot_%out_len+HashMapSlot_key, 0 as ptr
+    store __map_extract_slot_%out_len+HashMapSlot_value, 0 as ptr
+    store __map_extract_slot_%out_len+HashMapSlot_state, HashMap_STATE_TOMB as u8
+    !__map_extract_next_tombs_%out_len
+    !__map_extract_next_len_%out_len
+    !__map_extract_cur_tombs_%out_len
+    !__map_extract_cur_len_%out_len
+    !__map_extract_value_bits_%out_len
+    !__map_extract_key_bits_%out_len
+    !__map_extract_take_%out_len
+    !__map_extract_pred_%out_len
+    !__map_extract_value_%out_len
+    !__map_extract_value_ptr_%out_len
+    !__map_extract_key_%out_len
+    jmp L_MAP_EXTRACT_NEXT_%out_len
+
+L_MAP_EXTRACT_NEXT_%out_len:
+    __map_extract_next_idx_%out_len = add __map_extract_idx_%out_len, 1
+    store __map_extract_idx_slot_%out_len+0, __map_extract_next_idx_%out_len as u64
+    !__map_extract_next_idx_%out_len
+    !__map_extract_filled_%out_len
+    !__map_extract_state_%out_len
+    !__map_extract_slot_%out_len
+    !__map_extract_slot_off_%out_len
+    !__map_extract_done_%out_len
+    !__map_extract_idx_%out_len
+    jmp L_MAP_EXTRACT_HEAD_%out_len
+
+L_MAP_EXTRACT_DONE_%out_len:
+    %out_len = load __map_extract_len_slot_%out_len+0 as u64
+    __map_extract_tombs_%out_len = load __map_extract_tombs_slot_%out_len+0 as u64
+    store %map_reg+HashMap_len, %out_len as u64
+    store %map_reg+HashMap_tombs, __map_extract_tombs_%out_len as u64
+    !__map_extract_done_%out_len
+    !__map_extract_idx_%out_len
+    !__map_extract_tombs_%out_len
+    !__map_extract_tombs_start_%out_len
+    !__map_extract_cap_hint_ok_%out_len
+    !__map_extract_cap_hint_%out_len
+    !__map_extract_len_%out_len
+    !__map_extract_cap_%out_len
+    !__map_extract_slots_%out_len
+[END_MACRO]
+
+[MACRO] MAP_PUT %map_reg, %key, %value
+    call @sa_map_put(&%map_reg, &%key, &%value)
+[END_MACRO]
+
+[MACRO] MAP_GET %out_value, %map_reg, %key
+    %out_value = call @sa_map_get(&%map_reg, &%key)
+[END_MACRO]
+
+[MACRO] MAP_TRY_GET %out_ok, %out_value, %map_reg, %key
+    __map_try_get_slot_%out_ok = stack_alloc 8
+    %out_ok = call @sa_map_try_get(&%map_reg, &%key, &__map_try_get_slot_%out_ok)
+    %out_value = load __map_try_get_slot_%out_ok+0 as ptr
+[END_MACRO]
+
+[MACRO] MAP_GET_KEY_VALUE %out_ok, %out_key, %out_value, %map_reg, %key
+    __map_kv_key_slot_%out_ok = stack_alloc 8
+    __map_kv_value_slot_%out_ok = stack_alloc 8
+    %out_ok = call @sa_map_try_get_key_value(&%map_reg, &%key, &__map_kv_key_slot_%out_ok, &__map_kv_value_slot_%out_ok)
+    %out_key = load __map_kv_key_slot_%out_ok+0 as ptr
+    %out_value = load __map_kv_value_slot_%out_ok+0 as ptr
+[END_MACRO]
+
+[MACRO] MAP_GET_MUT_PTR %out_ok, %out_ptr, %map_reg, %key
+    __map_mut_slot_%out_ok = stack_alloc 8
+    %out_ok = call @sa_map_get_mut_ptr(&%map_reg, &%key, &__map_mut_slot_%out_ok)
+    %out_ptr = load __map_mut_slot_%out_ok+0 as ptr
+[END_MACRO]
+
+[MACRO] MAP_TRY_GET_DISJOINT_MUT_PTRS %out_ok, %out_ptr_a, %out_ptr_b, %map_reg, %key_a, %key_b
+    __map_disjoint_mut_a_slot_%out_ok = stack_alloc 8
+    __map_disjoint_mut_b_slot_%out_ok = stack_alloc 8
+    %out_ok = call @sa_map_try_get_disjoint_mut_ptrs(&%map_reg, &%key_a, &%key_b, &__map_disjoint_mut_a_slot_%out_ok, &__map_disjoint_mut_b_slot_%out_ok)
+    %out_ptr_a = load __map_disjoint_mut_a_slot_%out_ok+0 as ptr
+    %out_ptr_b = load __map_disjoint_mut_b_slot_%out_ok+0 as ptr
+[END_MACRO]
+
+// Rust method-name aliases over checked disjoint mutable value-slot pointers.
+[MACRO] MAP_GET_DISJOINT_MUT_PTRS %out_ok, %out_ptr_a, %out_ptr_b, %map_reg, %key_a, %key_b
+    EXPAND MAP_TRY_GET_DISJOINT_MUT_PTRS %out_ok, %out_ptr_a, %out_ptr_b, %map_reg, %key_a, %key_b
+[END_MACRO]
+
+[MACRO] MAP_GET_DISJOINT_MUT %out_ok, %out_ptr_a, %out_ptr_b, %map_reg, %key_a, %key_b
+    EXPAND MAP_TRY_GET_DISJOINT_MUT_PTRS %out_ok, %out_ptr_a, %out_ptr_b, %map_reg, %key_a, %key_b
+[END_MACRO]
+
+[MACRO] MAP_INSERT %out_replaced, %out_old_value, %map_reg, %key, %value
+    __map_insert_old_slot_%out_replaced = stack_alloc 8
+    %out_replaced = call @sa_map_insert(&%map_reg, &%key, &%value, &__map_insert_old_slot_%out_replaced)
+    %out_old_value = load __map_insert_old_slot_%out_replaced+0 as ptr
+[END_MACRO]
+
+[MACRO] MAP_TRY_INSERT %out_inserted, %out_value_ptr, %map_reg, %key, %value
+    __map_try_insert_ptr_slot_%out_inserted = stack_alloc 8
+    %out_inserted = call @sa_map_try_insert(&%map_reg, &%key, &%value, &__map_try_insert_ptr_slot_%out_inserted)
+    %out_value_ptr = load __map_try_insert_ptr_slot_%out_inserted+0 as ptr
+[END_MACRO]
+
+[MACRO] MAP_ENTRY_OR_INSERT %out_inserted, %out_value_ptr, %map_reg, %key, %value
+    EXPAND MAP_TRY_INSERT %out_inserted, %out_value_ptr, %map_reg, %key, %value
+[END_MACRO]
+
+// Rust method-name bare alias for the common entry path (or_insert).
+[MACRO] MAP_ENTRY %out_inserted, %out_value_ptr, %map_reg, %key, %value
+    EXPAND MAP_ENTRY_OR_INSERT %out_inserted, %out_value_ptr, %map_reg, %key, %value
+[END_MACRO]
+
+[MACRO] MAP_OR_INSERT %out_inserted, %out_value_ptr, %map_reg, %key, %value
+    EXPAND MAP_ENTRY_OR_INSERT %out_inserted, %out_value_ptr, %map_reg, %key, %value
+[END_MACRO]
+
+// Concrete entry-style helpers over try-insert / get-mut-ptr.
+// Default inserted value is a null pointer (0). and_modify stores only when present.
+
+[MACRO] MAP_ENTRY_OR_DEFAULT %out_inserted, %out_value_ptr, %map_reg, %key
+    __map_entry_default_%out_inserted = add 0, 0
+    EXPAND MAP_ENTRY_OR_INSERT %out_inserted, %out_value_ptr, %map_reg, %key, __map_entry_default_%out_inserted
+    !__map_entry_default_%out_inserted
+[END_MACRO]
+
+[MACRO] MAP_ENTRY_AND_MODIFY %out_ok, %map_reg, %key, %value
+    __map_and_mod_ptr_slot_%out_ok = stack_alloc 8
+    %out_ok = call @sa_map_get_mut_ptr(&%map_reg, &%key, &__map_and_mod_ptr_slot_%out_ok)
+    __map_and_mod_ptr_%out_ok = load __map_and_mod_ptr_slot_%out_ok+0 as ptr
+    __map_and_mod_has_%out_ok = eq %out_ok, 1
+    br __map_and_mod_has_%out_ok -> L_MAP_ENTRY_AND_MODIFY_SET_%out_ok, L_MAP_ENTRY_AND_MODIFY_SKIP_%out_ok
+L_MAP_ENTRY_AND_MODIFY_SET_%out_ok:
+    store __map_and_mod_ptr_%out_ok+0, %value as ptr
+    !__map_and_mod_has_%out_ok
+    !__map_and_mod_ptr_%out_ok
+    jmp L_MAP_ENTRY_AND_MODIFY_END_%out_ok
+L_MAP_ENTRY_AND_MODIFY_SKIP_%out_ok:
+    !__map_and_mod_has_%out_ok
+    !__map_and_mod_ptr_%out_ok
+    jmp L_MAP_ENTRY_AND_MODIFY_END_%out_ok
+L_MAP_ENTRY_AND_MODIFY_END_%out_ok:
+[END_MACRO]
+
+[MACRO] MAP_KEYS %out_vec, %map_reg
+    %out_vec = call @sa_map_keys_vec(&%map_reg)
+[END_MACRO]
+
+[MACRO] MAP_VALUES %out_vec, %map_reg
+    %out_vec = call @sa_map_values_vec(&%map_reg)
+[END_MACRO]
+
+[MACRO] MAP_INTO_KEYS %out_vec, %map_reg
+    EXPAND MAP_KEYS %out_vec, %map_reg
+    EXPAND MAP_CLEAR %map_reg
+[END_MACRO]
+
+[MACRO] MAP_INTO_VALUES %out_vec, %map_reg
+    EXPAND MAP_VALUES %out_vec, %map_reg
+    EXPAND MAP_CLEAR %map_reg
+[END_MACRO]
+
+[MACRO] MAP_VALUES_MUT_PTRS %out_vec, %map_reg
+    %out_vec = call @sa_map_value_mut_ptrs_vec(&%map_reg)
+[END_MACRO]
+
+[MACRO] MAP_VALUES_MUT %out_vec, %map_reg
+    EXPAND MAP_VALUES_MUT_PTRS %out_vec, %map_reg
+[END_MACRO]
+
+[MACRO] MAP_ITER %out_vec, %map_reg
+    %out_vec = call @sa_map_iter_vec(&%map_reg)
+[END_MACRO]
+
+[MACRO] MAP_ITER_MUT_PTRS %out_vec, %map_reg
+    %out_vec = call @sa_map_iter_mut_ptrs_vec(&%map_reg)
+[END_MACRO]
+
+// Rust method-name alias: HashMap::iter_mut (eager raw value-slot pointer materialization).
+[MACRO] MAP_ITER_MUT %out_vec, %map_reg
+    EXPAND MAP_ITER_MUT_PTRS %out_vec, %map_reg
+[END_MACRO]
+
+[MACRO] MAP_REF_INTO_ITER %out_vec, %map_reg
+    EXPAND MAP_ITER %out_vec, %map_reg
+[END_MACRO]
+
+[MACRO] MAP_MUT_REF_INTO_ITER %out_vec, %map_reg
+    EXPAND MAP_ITER_MUT_PTRS %out_vec, %map_reg
+[END_MACRO]
+
+[MACRO] MAP_INTO_ITER %out_vec, %map_reg
+    EXPAND MAP_DRAIN %out_vec, %map_reg
+[END_MACRO]
+
+[MACRO] MAP_REMOVE_ENTRY %out_ok, %out_key, %out_value, %map_reg, %key
+    __map_remove_key_slot_%out_ok = stack_alloc 8
+    __map_remove_value_slot_%out_ok = stack_alloc 8
+    %out_ok = call @sa_map_remove_entry(&%map_reg, &%key, &__map_remove_key_slot_%out_ok, &__map_remove_value_slot_%out_ok)
+    %out_key = load __map_remove_key_slot_%out_ok+0 as ptr
+    %out_value = load __map_remove_value_slot_%out_ok+0 as ptr
+[END_MACRO]
+
+[MACRO] MAP_DEL %out_value, %map_reg, %key
+    %out_value = call @sa_map_del(&%map_reg, &%key)
+[END_MACRO]
+
+[MACRO] MAP_FREE %map_reg
+    call @sa_map_free(^%map_reg)
+[END_MACRO]
+
+[MACRO] MAP_LIT1 %out_map, %key1, %value1
+    EXPAND MAP_NEW %out_map
+    EXPAND MAP_PUT %out_map, %key1, %value1
+[END_MACRO]
+
+[MACRO] MAP_LIT2 %out_map, %key1, %value1, %key2, %value2
+    EXPAND MAP_NEW %out_map
+    EXPAND MAP_PUT %out_map, %key1, %value1
+    EXPAND MAP_PUT %out_map, %key2, %value2
+[END_MACRO]
+
+[MACRO] MAP_LIT3 %out_map, %key1, %value1, %key2, %value2, %key3, %value3
+    EXPAND MAP_NEW %out_map
+    EXPAND MAP_PUT %out_map, %key1, %value1
+    EXPAND MAP_PUT %out_map, %key2, %value2
+    EXPAND MAP_PUT %out_map, %key3, %value3
+[END_MACRO]
+
+// Rust Default-style empty map constructor alias.
+
+[MACRO] MAP_DEFAULT %out_map
+    EXPAND MAP_NEW %out_map
+[END_MACRO]