@salang/sa 0.1.2 → 0.1.4

package/sa_std/array.sa

@@ -0,0 +1,1876 @@
+@import "core/slice.sal"
+@import "core/slice.sa"
+@import "core/iter.sa"
+@import "core/mem.sa"
+@import "hash.sa"
+@import "vec.sa"
+
+[MACRO] ARRAY_LEN %out_len, %length
+    %out_len = add %length, 0
+[END_MACRO]
+
+[MACRO] ARRAY_IS_EMPTY %out_bool, %length
+    %out_bool = eq %length, 0
+[END_MACRO]
+
+[MACRO] ARRAY_AS_SLICE_U64 %out_slice, %array_ptr, %length
+    EXPAND SLICE_NEW %out_slice, %array_ptr, %length
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_AS_SLICE_U64.
+[MACRO] ARRAY_AS_SLICE %out_slice, %array_ptr, %length
+    EXPAND ARRAY_AS_SLICE_U64 %out_slice, %array_ptr, %length
+[END_MACRO]
+
+[MACRO] ARRAY_AS_MUT_SLICE_U64 %out_slice, %array_ptr, %length
+    EXPAND SLICE_NEW %out_slice, %array_ptr, %length
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_AS_MUT_SLICE_U64.
+[MACRO] ARRAY_AS_MUT_SLICE %out_slice, %array_ptr, %length
+    EXPAND ARRAY_AS_MUT_SLICE_U64 %out_slice, %array_ptr, %length
+[END_MACRO]
+
+[MACRO] ARRAY_AS_REF_SLICE_U64 %out_slice, %array_ptr, %length
+    EXPAND ARRAY_AS_SLICE_U64 %out_slice, %array_ptr, %length
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_AS_REF_SLICE_U64.
+[MACRO] ARRAY_AS_REF_SLICE %out_slice, %array_ptr, %length
+    EXPAND ARRAY_AS_REF_SLICE_U64 %out_slice, %array_ptr, %length
+[END_MACRO]
+
+[MACRO] ARRAY_AS_MUT_REF_SLICE_U64 %out_slice, %array_ptr, %length
+    EXPAND ARRAY_AS_MUT_SLICE_U64 %out_slice, %array_ptr, %length
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_AS_MUT_REF_SLICE_U64.
+[MACRO] ARRAY_AS_MUT_REF_SLICE %out_slice, %array_ptr, %length
+    EXPAND ARRAY_AS_MUT_REF_SLICE_U64 %out_slice, %array_ptr, %length
+[END_MACRO]
+
+[MACRO] ARRAY_BORROW_SLICE_U64 %out_slice, %array_ptr, %length
+    EXPAND ARRAY_AS_REF_SLICE_U64 %out_slice, %array_ptr, %length
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_BORROW_SLICE_U64.
+[MACRO] ARRAY_BORROW_SLICE %out_slice, %array_ptr, %length
+    EXPAND ARRAY_BORROW_SLICE_U64 %out_slice, %array_ptr, %length
+[END_MACRO]
+
+[MACRO] ARRAY_BORROW_MUT_SLICE_U64 %out_slice, %array_ptr, %length
+    EXPAND ARRAY_AS_MUT_REF_SLICE_U64 %out_slice, %array_ptr, %length
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_BORROW_MUT_SLICE_U64.
+[MACRO] ARRAY_BORROW_MUT_SLICE %out_slice, %array_ptr, %length
+    EXPAND ARRAY_BORROW_MUT_SLICE_U64 %out_slice, %array_ptr, %length
+[END_MACRO]
+
+[MACRO] ARRAY_FROM_REF_U64 %out_slice, %value_ptr
+    EXPAND SLICE_NEW %out_slice, %value_ptr, 1
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_FROM_REF_U64.
+[MACRO] ARRAY_FROM_REF %out_slice, %value_ptr
+    EXPAND ARRAY_FROM_REF_U64 %out_slice, %value_ptr
+[END_MACRO]
+
+[MACRO] ARRAY_FROM_MUT_U64 %out_slice, %value_ptr
+    EXPAND SLICE_NEW %out_slice, %value_ptr, 1
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_FROM_MUT_U64.
+[MACRO] ARRAY_FROM_MUT %out_slice, %value_ptr
+    EXPAND ARRAY_FROM_MUT_U64 %out_slice, %value_ptr
+[END_MACRO]
+
+[MACRO] ARRAY_EACH_REF_U64 %out_slice, %array_ptr, %length
+    EXPAND SLICE_NEW %out_slice, %array_ptr, %length
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_EACH_REF_U64.
+[MACRO] ARRAY_EACH_REF %out_slice, %array_ptr, %length
+    EXPAND ARRAY_EACH_REF_U64 %out_slice, %array_ptr, %length
+[END_MACRO]
+
+[MACRO] ARRAY_EACH_MUT_U64 %out_slice, %array_ptr, %length
+    EXPAND SLICE_NEW %out_slice, %array_ptr, %length
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_EACH_MUT_U64.
+[MACRO] ARRAY_EACH_MUT %out_slice, %array_ptr, %length
+    EXPAND ARRAY_EACH_MUT_U64 %out_slice, %array_ptr, %length
+[END_MACRO]
+
+[MACRO] ARRAY_ITER_U64 %out_iter, %array_ptr, %length
+    __array_iter_slice_%out_iter = stack_alloc Slice_SIZE
+    EXPAND ARRAY_AS_SLICE_U64 __array_iter_slice_%out_iter, %array_ptr, %length
+    EXPAND ITER_FROM_SLICE %out_iter, __array_iter_slice_%out_iter
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_ITER_U64.
+[MACRO] ARRAY_ITER %out_iter, %array_ptr, %length
+    EXPAND ARRAY_ITER_U64 %out_iter, %array_ptr, %length
+[END_MACRO]
+
+[MACRO] ARRAY_ITER_MUT_U64 %out_iter, %array_ptr, %length
+    __array_iter_mut_slice_%out_iter = stack_alloc Slice_SIZE
+    EXPAND ARRAY_AS_MUT_SLICE_U64 __array_iter_mut_slice_%out_iter, %array_ptr, %length
+    EXPAND ITER_FROM_SLICE %out_iter, __array_iter_mut_slice_%out_iter
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_ITER_MUT_U64.
+[MACRO] ARRAY_ITER_MUT %out_iter, %array_ptr, %length
+    EXPAND ARRAY_ITER_MUT_U64 %out_iter, %array_ptr, %length
+[END_MACRO]
+
+[MACRO] ARRAY_REF_INTO_ITER_U64 %out_iter, %array_ptr, %length
+    EXPAND ARRAY_ITER_U64 %out_iter, %array_ptr, %length
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_REF_INTO_ITER_U64.
+[MACRO] ARRAY_REF_INTO_ITER %out_iter, %array_ptr, %length
+    EXPAND ARRAY_REF_INTO_ITER_U64 %out_iter, %array_ptr, %length
+[END_MACRO]
+
+[MACRO] ARRAY_MUT_REF_INTO_ITER_U64 %out_iter, %array_ptr, %length
+    EXPAND ARRAY_ITER_MUT_U64 %out_iter, %array_ptr, %length
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_MUT_REF_INTO_ITER_U64.
+[MACRO] ARRAY_MUT_REF_INTO_ITER %out_iter, %array_ptr, %length
+    EXPAND ARRAY_MUT_REF_INTO_ITER_U64 %out_iter, %array_ptr, %length
+[END_MACRO]
+
+[MACRO] ARRAY_INTO_ITER_U64 %out_iter, %out_vec, %array_ptr, %length
+    __array_into_iter_slice_%out_iter = stack_alloc Slice_SIZE
+    EXPAND ARRAY_AS_SLICE_U64 __array_into_iter_slice_%out_iter, %array_ptr, %length
+    EXPAND VEC_FROM_SLICE_U64 %out_vec, __array_into_iter_slice_%out_iter
+    EXPAND VEC_AS_SLICE __array_into_iter_backing_slice_%out_iter, %out_vec
+    EXPAND ITER_FROM_SLICE %out_iter, __array_into_iter_backing_slice_%out_iter
+    !__array_into_iter_backing_slice_%out_iter
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_INTO_ITER_U64.
+[MACRO] ARRAY_INTO_ITER %out_iter, %out_vec, %array_ptr, %length
+    EXPAND ARRAY_INTO_ITER_U64 %out_iter, %out_vec, %array_ptr, %length
+[END_MACRO]
+
+[MACRO] ARRAY_INTO_ITER_NEW_U64 %out_iter, %out_vec, %array_ptr, %length
+    EXPAND ARRAY_INTO_ITER_U64 %out_iter, %out_vec, %array_ptr, %length
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_INTO_ITER_NEW_U64.
+[MACRO] ARRAY_INTO_ITER_NEW %out_iter, %out_vec, %array_ptr, %length
+    EXPAND ARRAY_INTO_ITER_NEW_U64 %out_iter, %out_vec, %array_ptr, %length
+[END_MACRO]
+
+[MACRO] ARRAY_INTO_ITER_EMPTY_U64 %out_iter, %out_vec
+    EXPAND VEC_INTO_ITER_DEFAULT_U64 %out_iter, %out_vec
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_INTO_ITER_EMPTY_U64.
+[MACRO] ARRAY_INTO_ITER_EMPTY %out_iter, %out_vec
+    EXPAND ARRAY_INTO_ITER_EMPTY_U64 %out_iter, %out_vec
+[END_MACRO]
+
+[MACRO] ARRAY_INTO_ITER_DEFAULT_U64 %out_iter, %out_vec
+    EXPAND ARRAY_INTO_ITER_EMPTY_U64 %out_iter, %out_vec
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_INTO_ITER_DEFAULT_U64.
+[MACRO] ARRAY_INTO_ITER_DEFAULT %out_iter, %out_vec
+    EXPAND ARRAY_INTO_ITER_DEFAULT_U64 %out_iter, %out_vec
+[END_MACRO]
+
+[MACRO] ARRAY_INTO_ITER_AS_SLICE_U64 %out_slice, %iter_reg
+    EXPAND ITER_AS_SLICE_U64 %out_slice, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_INTO_ITER_AS_SLICE_U64.
+[MACRO] ARRAY_INTO_ITER_AS_SLICE %out_slice, %iter_reg
+    EXPAND ARRAY_INTO_ITER_AS_SLICE_U64 %out_slice, %iter_reg
+[END_MACRO]
+
+[MACRO] ARRAY_INTO_ITER_AS_MUT_SLICE_U64 %out_slice, %iter_reg
+    EXPAND ITER_AS_SLICE_U64 %out_slice, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_INTO_ITER_AS_MUT_SLICE_U64.
+[MACRO] ARRAY_INTO_ITER_AS_MUT_SLICE %out_slice, %iter_reg
+    EXPAND ARRAY_INTO_ITER_AS_MUT_SLICE_U64 %out_slice, %iter_reg
+[END_MACRO]
+
+[MACRO] ARRAY_INTO_ITER_AS_REF_SLICE_U64 %out_slice, %iter_reg
+    EXPAND ARRAY_INTO_ITER_AS_SLICE_U64 %out_slice, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_INTO_ITER_AS_REF_SLICE_U64.
+[MACRO] ARRAY_INTO_ITER_AS_REF_SLICE %out_slice, %iter_reg
+    EXPAND ARRAY_INTO_ITER_AS_REF_SLICE_U64 %out_slice, %iter_reg
+[END_MACRO]
+
+[MACRO] ARRAY_INTO_ITER_SIZE_HINT_U64 %out_lower, %out_upper, %iter_reg
+    EXPAND ITER_SIZE_HINT %out_lower, %out_upper, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_INTO_ITER_SIZE_HINT_U64.
+[MACRO] ARRAY_INTO_ITER_SIZE_HINT %out_lower, %out_upper, %iter_reg
+    EXPAND ARRAY_INTO_ITER_SIZE_HINT_U64 %out_lower, %out_upper, %iter_reg
+[END_MACRO]
+
+[MACRO] ARRAY_INTO_ITER_EXACT_SIZE_LEN_U64 %out_len, %iter_reg
+    EXPAND ITER_EXACT_SIZE_LEN %out_len, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_INTO_ITER_EXACT_SIZE_LEN_U64.
+[MACRO] ARRAY_INTO_ITER_EXACT_SIZE_LEN %out_len, %iter_reg
+    EXPAND ARRAY_INTO_ITER_EXACT_SIZE_LEN_U64 %out_len, %iter_reg
+[END_MACRO]
+
+[MACRO] ARRAY_INTO_ITER_EXACT_SIZE_IS_EMPTY_U64 %out_bool, %iter_reg
+    EXPAND ITER_EXACT_SIZE_IS_EMPTY %out_bool, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_INTO_ITER_EXACT_SIZE_IS_EMPTY_U64.
+[MACRO] ARRAY_INTO_ITER_EXACT_SIZE_IS_EMPTY %out_bool, %iter_reg
+    EXPAND ARRAY_INTO_ITER_EXACT_SIZE_IS_EMPTY_U64 %out_bool, %iter_reg
+[END_MACRO]
+
+[MACRO] ARRAY_INTO_ITER_NEXT_U64 %out_has, %out_value, %iter_reg
+    EXPAND ITER_NEXT_U64 %out_has, %out_value, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_INTO_ITER_NEXT_U64.
+[MACRO] ARRAY_INTO_ITER_NEXT %out_has, %out_value, %iter_reg
+    EXPAND ARRAY_INTO_ITER_NEXT_U64 %out_has, %out_value, %iter_reg
+[END_MACRO]
+
+[MACRO] ARRAY_INTO_ITER_NEXT_BACK_U64 %out_has, %out_value, %iter_reg
+    EXPAND ITER_NEXT_BACK_U64 %out_has, %out_value, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_INTO_ITER_NEXT_BACK_U64.
+[MACRO] ARRAY_INTO_ITER_NEXT_BACK %out_has, %out_value, %iter_reg
+    EXPAND ARRAY_INTO_ITER_NEXT_BACK_U64 %out_has, %out_value, %iter_reg
+[END_MACRO]
+
+[MACRO] ARRAY_INTO_ITER_NTH_U64 %out_has, %out_value, %iter_reg, %nth
+    EXPAND ITER_NTH_U64 %out_has, %out_value, %iter_reg, %nth
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_INTO_ITER_NTH_U64.
+[MACRO] ARRAY_INTO_ITER_NTH %out_has, %out_value, %iter_reg, %nth
+    EXPAND ARRAY_INTO_ITER_NTH_U64 %out_has, %out_value, %iter_reg, %nth
+[END_MACRO]
+
+[MACRO] ARRAY_INTO_ITER_NTH_BACK_U64 %out_has, %out_value, %iter_reg, %nth
+    EXPAND ITER_NTH_BACK_U64 %out_has, %out_value, %iter_reg, %nth
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_INTO_ITER_NTH_BACK_U64.
+[MACRO] ARRAY_INTO_ITER_NTH_BACK %out_has, %out_value, %iter_reg, %nth
+    EXPAND ARRAY_INTO_ITER_NTH_BACK_U64 %out_has, %out_value, %iter_reg, %nth
+[END_MACRO]
+
+[MACRO] ARRAY_INTO_ITER_TRY_NEXT_CHUNK_U64 %out_ok, %out_filled, %iter_reg, %dst_ptr, %count
+    EXPAND ITER_TRY_NEXT_CHUNK_U64 %out_ok, %out_filled, %iter_reg, %dst_ptr, %count
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_INTO_ITER_TRY_NEXT_CHUNK_U64.
+[MACRO] ARRAY_INTO_ITER_TRY_NEXT_CHUNK %out_ok, %out_filled, %iter_reg, %dst_ptr, %count
+    EXPAND ARRAY_INTO_ITER_TRY_NEXT_CHUNK_U64 %out_ok, %out_filled, %iter_reg, %dst_ptr, %count
+[END_MACRO]
+
+[MACRO] ARRAY_INTO_ITER_COUNT_U64 %out_count, %iter_reg
+    EXPAND ITER_COUNT %out_count, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_INTO_ITER_COUNT_U64.
+[MACRO] ARRAY_INTO_ITER_COUNT %out_count, %iter_reg
+    EXPAND ARRAY_INTO_ITER_COUNT_U64 %out_count, %iter_reg
+[END_MACRO]
+
+[MACRO] ARRAY_INTO_ITER_LAST_U64 %out_has, %out_value, %iter_reg
+    EXPAND ITER_LAST_U64 %out_has, %out_value, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_INTO_ITER_LAST_U64.
+[MACRO] ARRAY_INTO_ITER_LAST %out_has, %out_value, %iter_reg
+    EXPAND ARRAY_INTO_ITER_LAST_U64 %out_has, %out_value, %iter_reg
+[END_MACRO]
+
+[MACRO] ARRAY_INTO_ITER_ADVANCE_BY %out_ok, %out_remaining, %iter_reg, %count
+    EXPAND ITER_ADVANCE_BY %out_ok, %out_remaining, %iter_reg, %count
+[END_MACRO]
+
+[MACRO] ARRAY_INTO_ITER_ADVANCE_BACK_BY %out_ok, %out_remaining, %iter_reg, %count
+    EXPAND ITER_ADVANCE_BACK_BY %out_ok, %out_remaining, %iter_reg, %count
+[END_MACRO]
+
+[MACRO] ARRAY_INTO_ITER_FOLD_U64 %out_value, %iter_reg, %init_value, %fold_fn
+    EXPAND ITER_FOLD_U64 %out_value, %iter_reg, %init_value, %fold_fn
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_INTO_ITER_FOLD_U64.
+[MACRO] ARRAY_INTO_ITER_FOLD %out_value, %iter_reg, %init_value, %fold_fn
+    EXPAND ARRAY_INTO_ITER_FOLD_U64 %out_value, %iter_reg, %init_value, %fold_fn
+[END_MACRO]
+
+[MACRO] ARRAY_INTO_ITER_TRY_FOLD_U64 %out_ok, %out_value, %iter_reg, %init_value, %fold_fn
+    EXPAND ITER_TRY_FOLD_U64 %out_ok, %out_value, %iter_reg, %init_value, %fold_fn
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_INTO_ITER_TRY_FOLD_U64.
+[MACRO] ARRAY_INTO_ITER_TRY_FOLD %out_ok, %out_value, %iter_reg, %init_value, %fold_fn
+    EXPAND ARRAY_INTO_ITER_TRY_FOLD_U64 %out_ok, %out_value, %iter_reg, %init_value, %fold_fn
+[END_MACRO]
+
+[MACRO] ARRAY_INTO_ITER_RFOLD_U64 %out_value, %iter_reg, %init_value, %fold_fn
+    EXPAND ITER_RFOLD_U64 %out_value, %iter_reg, %init_value, %fold_fn
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_INTO_ITER_RFOLD_U64.
+[MACRO] ARRAY_INTO_ITER_RFOLD %out_value, %iter_reg, %init_value, %fold_fn
+    EXPAND ARRAY_INTO_ITER_RFOLD_U64 %out_value, %iter_reg, %init_value, %fold_fn
+[END_MACRO]
+
+[MACRO] ARRAY_INTO_ITER_TRY_RFOLD_U64 %out_ok, %out_value, %iter_reg, %init_value, %fold_fn
+    EXPAND ITER_TRY_RFOLD_U64 %out_ok, %out_value, %iter_reg, %init_value, %fold_fn
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_INTO_ITER_TRY_RFOLD_U64.
+[MACRO] ARRAY_INTO_ITER_TRY_RFOLD %out_ok, %out_value, %iter_reg, %init_value, %fold_fn
+    EXPAND ARRAY_INTO_ITER_TRY_RFOLD_U64 %out_ok, %out_value, %iter_reg, %init_value, %fold_fn
+[END_MACRO]
+
+[MACRO] ARRAY_INTO_ITER_SUM_U64 %out_value, %iter_reg
+    EXPAND ITER_SUM_U64 %out_value, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_INTO_ITER_SUM_U64.
+[MACRO] ARRAY_INTO_ITER_SUM %out_value, %iter_reg
+    EXPAND ARRAY_INTO_ITER_SUM_U64 %out_value, %iter_reg
+[END_MACRO]
+
+[MACRO] ARRAY_INTO_ITER_PRODUCT_U64 %out_value, %iter_reg
+    EXPAND ITER_PRODUCT_U64 %out_value, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_INTO_ITER_PRODUCT_U64.
+[MACRO] ARRAY_INTO_ITER_PRODUCT %out_value, %iter_reg
+    EXPAND ARRAY_INTO_ITER_PRODUCT_U64 %out_value, %iter_reg
+[END_MACRO]
+
+[MACRO] ARRAY_INTO_ITER_MIN_U64 %out_has, %out_value, %iter_reg
+    EXPAND ITER_MIN_U64 %out_has, %out_value, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_INTO_ITER_MIN_U64.
+[MACRO] ARRAY_INTO_ITER_MIN %out_has, %out_value, %iter_reg
+    EXPAND ARRAY_INTO_ITER_MIN_U64 %out_has, %out_value, %iter_reg
+[END_MACRO]
+
+[MACRO] ARRAY_INTO_ITER_MAX_U64 %out_has, %out_value, %iter_reg
+    EXPAND ITER_MAX_U64 %out_has, %out_value, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_INTO_ITER_MAX_U64.
+[MACRO] ARRAY_INTO_ITER_MAX %out_has, %out_value, %iter_reg
+    EXPAND ARRAY_INTO_ITER_MAX_U64 %out_has, %out_value, %iter_reg
+[END_MACRO]
+
+[MACRO] ARRAY_INTO_ITER_REDUCE_U64 %out_has, %out_value, %iter_reg, %reduce_fn
+    EXPAND ITER_REDUCE_U64 %out_has, %out_value, %iter_reg, %reduce_fn
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_INTO_ITER_REDUCE_U64.
+[MACRO] ARRAY_INTO_ITER_REDUCE %out_has, %out_value, %iter_reg, %reduce_fn
+    EXPAND ARRAY_INTO_ITER_REDUCE_U64 %out_has, %out_value, %iter_reg, %reduce_fn
+[END_MACRO]
+
+[MACRO] ARRAY_INTO_ITER_TRY_REDUCE_U64 %out_ok, %out_has, %out_value, %iter_reg, %reduce_fn
+    EXPAND ITER_TRY_REDUCE_U64 %out_ok, %out_has, %out_value, %iter_reg, %reduce_fn
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_INTO_ITER_TRY_REDUCE_U64.
+[MACRO] ARRAY_INTO_ITER_TRY_REDUCE %out_ok, %out_has, %out_value, %iter_reg, %reduce_fn
+    EXPAND ARRAY_INTO_ITER_TRY_REDUCE_U64 %out_ok, %out_has, %out_value, %iter_reg, %reduce_fn
+[END_MACRO]
+
+[MACRO] ARRAY_INTO_ITER_MIN_BY_U64 %out_has, %out_value, %iter_reg, %compare_fn
+    EXPAND ITER_MIN_BY_U64 %out_has, %out_value, %iter_reg, %compare_fn
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_INTO_ITER_MIN_BY_U64.
+[MACRO] ARRAY_INTO_ITER_MIN_BY %out_has, %out_value, %iter_reg, %compare_fn
+    EXPAND ARRAY_INTO_ITER_MIN_BY_U64 %out_has, %out_value, %iter_reg, %compare_fn
+[END_MACRO]
+
+[MACRO] ARRAY_INTO_ITER_MAX_BY_U64 %out_has, %out_value, %iter_reg, %compare_fn
+    EXPAND ITER_MAX_BY_U64 %out_has, %out_value, %iter_reg, %compare_fn
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_INTO_ITER_MAX_BY_U64.
+[MACRO] ARRAY_INTO_ITER_MAX_BY %out_has, %out_value, %iter_reg, %compare_fn
+    EXPAND ARRAY_INTO_ITER_MAX_BY_U64 %out_has, %out_value, %iter_reg, %compare_fn
+[END_MACRO]
+
+[MACRO] ARRAY_INTO_ITER_MIN_BY_KEY_U64 %out_has, %out_value, %iter_reg, %key_fn
+    EXPAND ITER_MIN_BY_KEY_U64 %out_has, %out_value, %iter_reg, %key_fn
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_INTO_ITER_MIN_BY_KEY_U64.
+[MACRO] ARRAY_INTO_ITER_MIN_BY_KEY %out_has, %out_value, %iter_reg, %key_fn
+    EXPAND ARRAY_INTO_ITER_MIN_BY_KEY_U64 %out_has, %out_value, %iter_reg, %key_fn
+[END_MACRO]
+
+[MACRO] ARRAY_INTO_ITER_MAX_BY_KEY_U64 %out_has, %out_value, %iter_reg, %key_fn
+    EXPAND ITER_MAX_BY_KEY_U64 %out_has, %out_value, %iter_reg, %key_fn
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_INTO_ITER_MAX_BY_KEY_U64.
+[MACRO] ARRAY_INTO_ITER_MAX_BY_KEY %out_has, %out_value, %iter_reg, %key_fn
+    EXPAND ARRAY_INTO_ITER_MAX_BY_KEY_U64 %out_has, %out_value, %iter_reg, %key_fn
+[END_MACRO]
+
+[MACRO] ARRAY_INTO_ITER_IS_SORTED_U64 %out_bool, %iter_reg
+    EXPAND ITER_IS_SORTED_U64 %out_bool, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_INTO_ITER_IS_SORTED_U64.
+[MACRO] ARRAY_INTO_ITER_IS_SORTED %out_bool, %iter_reg
+    EXPAND ARRAY_INTO_ITER_IS_SORTED_U64 %out_bool, %iter_reg
+[END_MACRO]
+
+[MACRO] ARRAY_INTO_ITER_IS_SORTED_BY_U64 %out_bool, %iter_reg, %compare_fn
+    EXPAND ITER_IS_SORTED_BY_U64 %out_bool, %iter_reg, %compare_fn
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_INTO_ITER_IS_SORTED_BY_U64.
+[MACRO] ARRAY_INTO_ITER_IS_SORTED_BY %out_bool, %iter_reg, %compare_fn
+    EXPAND ARRAY_INTO_ITER_IS_SORTED_BY_U64 %out_bool, %iter_reg, %compare_fn
+[END_MACRO]
+
+[MACRO] ARRAY_INTO_ITER_IS_SORTED_BY_KEY_U64 %out_bool, %iter_reg, %key_fn
+    EXPAND ITER_IS_SORTED_BY_KEY_U64 %out_bool, %iter_reg, %key_fn
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_INTO_ITER_IS_SORTED_BY_KEY_U64.
+[MACRO] ARRAY_INTO_ITER_IS_SORTED_BY_KEY %out_bool, %iter_reg, %key_fn
+    EXPAND ARRAY_INTO_ITER_IS_SORTED_BY_KEY_U64 %out_bool, %iter_reg, %key_fn
+[END_MACRO]
+
+[MACRO] ARRAY_INTO_ITER_CMP_U64 %out_ordering, %left_iter, %right_iter
+    EXPAND ITER_CMP_U64 %out_ordering, %left_iter, %right_iter
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_INTO_ITER_CMP_U64.
+[MACRO] ARRAY_INTO_ITER_CMP %out_ordering, %left_iter, %right_iter
+    EXPAND ARRAY_INTO_ITER_CMP_U64 %out_ordering, %left_iter, %right_iter
+[END_MACRO]
+
+[MACRO] ARRAY_INTO_ITER_CMP_BY_U64 %out_ordering, %left_iter, %right_iter, %compare_fn
+    EXPAND ITER_CMP_BY_U64 %out_ordering, %left_iter, %right_iter, %compare_fn
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_INTO_ITER_CMP_BY_U64.
+[MACRO] ARRAY_INTO_ITER_CMP_BY %out_ordering, %left_iter, %right_iter, %compare_fn
+    EXPAND ARRAY_INTO_ITER_CMP_BY_U64 %out_ordering, %left_iter, %right_iter, %compare_fn
+[END_MACRO]
+
+[MACRO] ARRAY_INTO_ITER_PARTIAL_CMP_U64 %out_ordering, %left_iter, %right_iter
+    EXPAND ITER_PARTIAL_CMP_U64 %out_ordering, %left_iter, %right_iter
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_INTO_ITER_PARTIAL_CMP_U64.
+[MACRO] ARRAY_INTO_ITER_PARTIAL_CMP %out_ordering, %left_iter, %right_iter
+    EXPAND ARRAY_INTO_ITER_PARTIAL_CMP_U64 %out_ordering, %left_iter, %right_iter
+[END_MACRO]
+
+[MACRO] ARRAY_INTO_ITER_PARTIAL_CMP_BY_U64 %out_ok, %out_ordering, %left_iter, %right_iter, %compare_fn
+    EXPAND ITER_PARTIAL_CMP_BY_U64 %out_ok, %out_ordering, %left_iter, %right_iter, %compare_fn
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_INTO_ITER_PARTIAL_CMP_BY_U64.
+[MACRO] ARRAY_INTO_ITER_PARTIAL_CMP_BY %out_ok, %out_ordering, %left_iter, %right_iter, %compare_fn
+    EXPAND ARRAY_INTO_ITER_PARTIAL_CMP_BY_U64 %out_ok, %out_ordering, %left_iter, %right_iter, %compare_fn
+[END_MACRO]
+
+[MACRO] ARRAY_INTO_ITER_EQ_BY_U64 %out_bool, %left_iter, %right_iter, %eq_fn
+    EXPAND ITER_EQ_BY_U64 %out_bool, %left_iter, %right_iter, %eq_fn
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_INTO_ITER_EQ_BY_U64.
+[MACRO] ARRAY_INTO_ITER_EQ_BY %out_bool, %left_iter, %right_iter, %eq_fn
+    EXPAND ARRAY_INTO_ITER_EQ_BY_U64 %out_bool, %left_iter, %right_iter, %eq_fn
+[END_MACRO]
+
+[MACRO] ARRAY_INTO_ITER_EQ_U64 %out_bool, %left_iter, %right_iter
+    EXPAND ITER_EQ_U64 %out_bool, %left_iter, %right_iter
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_INTO_ITER_EQ_U64.
+[MACRO] ARRAY_INTO_ITER_EQ %out_bool, %left_iter, %right_iter
+    EXPAND ARRAY_INTO_ITER_EQ_U64 %out_bool, %left_iter, %right_iter
+[END_MACRO]
+
+[MACRO] ARRAY_INTO_ITER_PARTIAL_EQ_U64 %out_bool, %left_iter, %right_iter
+    EXPAND ITER_PARTIAL_EQ_U64 %out_bool, %left_iter, %right_iter
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_INTO_ITER_PARTIAL_EQ_U64.
+[MACRO] ARRAY_INTO_ITER_PARTIAL_EQ %out_bool, %left_iter, %right_iter
+    EXPAND ARRAY_INTO_ITER_PARTIAL_EQ_U64 %out_bool, %left_iter, %right_iter
+[END_MACRO]
+
+[MACRO] ARRAY_INTO_ITER_NE_U64 %out_bool, %left_iter, %right_iter
+    EXPAND ITER_NE_U64 %out_bool, %left_iter, %right_iter
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_INTO_ITER_NE_U64.
+[MACRO] ARRAY_INTO_ITER_NE %out_bool, %left_iter, %right_iter
+    EXPAND ARRAY_INTO_ITER_NE_U64 %out_bool, %left_iter, %right_iter
+[END_MACRO]
+
+[MACRO] ARRAY_INTO_ITER_LT_U64 %out_bool, %left_iter, %right_iter
+    EXPAND ITER_LT_U64 %out_bool, %left_iter, %right_iter
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_INTO_ITER_LT_U64.
+[MACRO] ARRAY_INTO_ITER_LT %out_bool, %left_iter, %right_iter
+    EXPAND ARRAY_INTO_ITER_LT_U64 %out_bool, %left_iter, %right_iter
+[END_MACRO]
+
+[MACRO] ARRAY_INTO_ITER_LE_U64 %out_bool, %left_iter, %right_iter
+    EXPAND ITER_LE_U64 %out_bool, %left_iter, %right_iter
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_INTO_ITER_LE_U64.
+[MACRO] ARRAY_INTO_ITER_LE %out_bool, %left_iter, %right_iter
+    EXPAND ARRAY_INTO_ITER_LE_U64 %out_bool, %left_iter, %right_iter
+[END_MACRO]
+
+[MACRO] ARRAY_INTO_ITER_GT_U64 %out_bool, %left_iter, %right_iter
+    EXPAND ITER_GT_U64 %out_bool, %left_iter, %right_iter
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_INTO_ITER_GT_U64.
+[MACRO] ARRAY_INTO_ITER_GT %out_bool, %left_iter, %right_iter
+    EXPAND ARRAY_INTO_ITER_GT_U64 %out_bool, %left_iter, %right_iter
+[END_MACRO]
+
+[MACRO] ARRAY_INTO_ITER_GE_U64 %out_bool, %left_iter, %right_iter
+    EXPAND ITER_GE_U64 %out_bool, %left_iter, %right_iter
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_INTO_ITER_GE_U64.
+[MACRO] ARRAY_INTO_ITER_GE %out_bool, %left_iter, %right_iter
+    EXPAND ARRAY_INTO_ITER_GE_U64 %out_bool, %left_iter, %right_iter
+[END_MACRO]
+
+[MACRO] ARRAY_INTO_ITER_FIND_U64 %out_has, %out_value, %iter_reg, %pred_fn
+    EXPAND ITER_FIND_U64 %out_has, %out_value, %iter_reg, %pred_fn
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_INTO_ITER_FIND_U64.
+[MACRO] ARRAY_INTO_ITER_FIND %out_has, %out_value, %iter_reg, %pred_fn
+    EXPAND ARRAY_INTO_ITER_FIND_U64 %out_has, %out_value, %iter_reg, %pred_fn
+[END_MACRO]
+
+[MACRO] ARRAY_INTO_ITER_TRY_FIND_U64 %out_ok, %out_has, %out_value, %iter_reg, %pred_fn
+    EXPAND ITER_TRY_FIND_U64 %out_ok, %out_has, %out_value, %iter_reg, %pred_fn
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_INTO_ITER_TRY_FIND_U64.
+[MACRO] ARRAY_INTO_ITER_TRY_FIND %out_ok, %out_has, %out_value, %iter_reg, %pred_fn
+    EXPAND ARRAY_INTO_ITER_TRY_FIND_U64 %out_ok, %out_has, %out_value, %iter_reg, %pred_fn
+[END_MACRO]
+
+[MACRO] ARRAY_INTO_ITER_FIND_MAP_U64 %out_has, %out_value, %iter_reg, %map_fn
+    EXPAND ITER_FIND_MAP_U64 %out_has, %out_value, %iter_reg, %map_fn
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_INTO_ITER_FIND_MAP_U64.
+[MACRO] ARRAY_INTO_ITER_FIND_MAP %out_has, %out_value, %iter_reg, %map_fn
+    EXPAND ARRAY_INTO_ITER_FIND_MAP_U64 %out_has, %out_value, %iter_reg, %map_fn
+[END_MACRO]
+
+[MACRO] ARRAY_INTO_ITER_POSITION_U64 %out_has, %out_index, %iter_reg, %pred_fn
+    EXPAND ITER_POSITION_U64 %out_has, %out_index, %iter_reg, %pred_fn
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_INTO_ITER_POSITION_U64.
+[MACRO] ARRAY_INTO_ITER_POSITION %out_has, %out_index, %iter_reg, %pred_fn
+    EXPAND ARRAY_INTO_ITER_POSITION_U64 %out_has, %out_index, %iter_reg, %pred_fn
+[END_MACRO]
+
+[MACRO] ARRAY_INTO_ITER_RPOSITION_U64 %out_has, %out_index, %iter_reg, %pred_fn
+    EXPAND ITER_RPOSITION_U64 %out_has, %out_index, %iter_reg, %pred_fn
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_INTO_ITER_RPOSITION_U64.
+[MACRO] ARRAY_INTO_ITER_RPOSITION %out_has, %out_index, %iter_reg, %pred_fn
+    EXPAND ARRAY_INTO_ITER_RPOSITION_U64 %out_has, %out_index, %iter_reg, %pred_fn
+[END_MACRO]
+
+[MACRO] ARRAY_INTO_ITER_RFIND_U64 %out_has, %out_value, %iter_reg, %pred_fn
+    EXPAND ITER_RFIND_U64 %out_has, %out_value, %iter_reg, %pred_fn
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_INTO_ITER_RFIND_U64.
+[MACRO] ARRAY_INTO_ITER_RFIND %out_has, %out_value, %iter_reg, %pred_fn
+    EXPAND ARRAY_INTO_ITER_RFIND_U64 %out_has, %out_value, %iter_reg, %pred_fn
+[END_MACRO]
+
+[MACRO] ARRAY_INTO_ITER_ANY_U64 %out_bool, %iter_reg, %pred_fn
+    EXPAND ITER_ANY_U64 %out_bool, %iter_reg, %pred_fn
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_INTO_ITER_ANY_U64.
+[MACRO] ARRAY_INTO_ITER_ANY %out_bool, %iter_reg, %pred_fn
+    EXPAND ARRAY_INTO_ITER_ANY_U64 %out_bool, %iter_reg, %pred_fn
+[END_MACRO]
+
+[MACRO] ARRAY_INTO_ITER_ALL_U64 %out_bool, %iter_reg, %pred_fn
+    EXPAND ITER_ALL_U64 %out_bool, %iter_reg, %pred_fn
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_INTO_ITER_ALL_U64.
+[MACRO] ARRAY_INTO_ITER_ALL %out_bool, %iter_reg, %pred_fn
+    EXPAND ARRAY_INTO_ITER_ALL_U64 %out_bool, %iter_reg, %pred_fn
+[END_MACRO]
+
+[MACRO] ARRAY_INTO_ITER_FOR_EACH_U64 %iter_reg, %each_fn
+    EXPAND ITER_FOR_EACH_U64 %iter_reg, %each_fn
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_INTO_ITER_FOR_EACH_U64.
+[MACRO] ARRAY_INTO_ITER_FOR_EACH %iter_reg, %each_fn
+    EXPAND ARRAY_INTO_ITER_FOR_EACH_U64 %iter_reg, %each_fn
+[END_MACRO]
+
+[MACRO] ARRAY_INTO_ITER_TRY_FOR_EACH_U64 %out_ok, %iter_reg, %each_fn
+    EXPAND ITER_TRY_FOR_EACH_U64 %out_ok, %iter_reg, %each_fn
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_INTO_ITER_TRY_FOR_EACH_U64.
+[MACRO] ARRAY_INTO_ITER_TRY_FOR_EACH %out_ok, %iter_reg, %each_fn
+    EXPAND ARRAY_INTO_ITER_TRY_FOR_EACH_U64 %out_ok, %iter_reg, %each_fn
+[END_MACRO]
+
+[MACRO] ARRAY_INTO_ITER_COLLECT_U64 %out_vec, %iter_reg
+    EXPAND ITER_COLLECT_U64 %out_vec, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_INTO_ITER_COLLECT_U64.
+[MACRO] ARRAY_INTO_ITER_COLLECT %out_vec, %iter_reg
+    EXPAND ARRAY_INTO_ITER_COLLECT_U64 %out_vec, %iter_reg
+[END_MACRO]
+
+[MACRO] ARRAY_INTO_ITER_TRY_COLLECT_U64 %out_ok, %out_vec, %iter_reg, %try_fn
+    EXPAND ITER_TRY_COLLECT_U64 %out_ok, %out_vec, %iter_reg, %try_fn
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_INTO_ITER_TRY_COLLECT_U64.
+[MACRO] ARRAY_INTO_ITER_TRY_COLLECT %out_ok, %out_vec, %iter_reg, %try_fn
+    EXPAND ARRAY_INTO_ITER_TRY_COLLECT_U64 %out_ok, %out_vec, %iter_reg, %try_fn
+[END_MACRO]
+
+[MACRO] ARRAY_INTO_ITER_COLLECT_INTO_U64 %vec_reg, %iter_reg
+    EXPAND ITER_COLLECT_INTO_U64 %vec_reg, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_INTO_ITER_COLLECT_INTO_U64.
+[MACRO] ARRAY_INTO_ITER_COLLECT_INTO %vec_reg, %iter_reg
+    EXPAND ARRAY_INTO_ITER_COLLECT_INTO_U64 %vec_reg, %iter_reg
+[END_MACRO]
+
+[MACRO] ARRAY_INTO_ITER_TAKE_COLLECT_U64 %out_vec, %iter_reg, %count
+    EXPAND ITER_TAKE_COLLECT_U64 %out_vec, %iter_reg, %count
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_INTO_ITER_TAKE_COLLECT_U64.
+[MACRO] ARRAY_INTO_ITER_TAKE_COLLECT %out_vec, %iter_reg, %count
+    EXPAND ARRAY_INTO_ITER_TAKE_COLLECT_U64 %out_vec, %iter_reg, %count
+[END_MACRO]
+
+[MACRO] ARRAY_INTO_ITER_SKIP_COLLECT_U64 %out_vec, %iter_reg, %count
+    EXPAND ITER_SKIP_COLLECT_U64 %out_vec, %iter_reg, %count
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_INTO_ITER_SKIP_COLLECT_U64.
+[MACRO] ARRAY_INTO_ITER_SKIP_COLLECT %out_vec, %iter_reg, %count
+    EXPAND ARRAY_INTO_ITER_SKIP_COLLECT_U64 %out_vec, %iter_reg, %count
+[END_MACRO]
+
+[MACRO] ARRAY_INTO_ITER_REV_COLLECT_U64 %out_vec, %iter_reg
+    EXPAND ITER_REV_COLLECT_U64 %out_vec, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_INTO_ITER_REV_COLLECT_U64.
+[MACRO] ARRAY_INTO_ITER_REV_COLLECT %out_vec, %iter_reg
+    EXPAND ARRAY_INTO_ITER_REV_COLLECT_U64 %out_vec, %iter_reg
+[END_MACRO]
+
+[MACRO] ARRAY_INTO_ITER_TRY_STEP_BY_COLLECT_U64 %out_ok, %out_vec, %iter_reg, %step
+    EXPAND ITER_TRY_STEP_BY_COLLECT_U64 %out_ok, %out_vec, %iter_reg, %step
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_INTO_ITER_TRY_STEP_BY_COLLECT_U64.
+[MACRO] ARRAY_INTO_ITER_TRY_STEP_BY_COLLECT %out_ok, %out_vec, %iter_reg, %step
+    EXPAND ARRAY_INTO_ITER_TRY_STEP_BY_COLLECT_U64 %out_ok, %out_vec, %iter_reg, %step
+[END_MACRO]
+
+[MACRO] ARRAY_INTO_ITER_STEP_BY_COLLECT_U64 %out_vec, %iter_reg, %step
+    EXPAND ITER_STEP_BY_COLLECT_U64 %out_vec, %iter_reg, %step
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_INTO_ITER_STEP_BY_COLLECT_U64.
+[MACRO] ARRAY_INTO_ITER_STEP_BY_COLLECT %out_vec, %iter_reg, %step
+    EXPAND ARRAY_INTO_ITER_STEP_BY_COLLECT_U64 %out_vec, %iter_reg, %step
+[END_MACRO]
+
+[MACRO] ARRAY_INTO_ITER_MAP_COLLECT_U64 %out_vec, %iter_reg, %map_fn
+    EXPAND ITER_MAP_COLLECT_U64 %out_vec, %iter_reg, %map_fn
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_INTO_ITER_MAP_COLLECT_U64.
+[MACRO] ARRAY_INTO_ITER_MAP_COLLECT %out_vec, %iter_reg, %map_fn
+    EXPAND ARRAY_INTO_ITER_MAP_COLLECT_U64 %out_vec, %iter_reg, %map_fn
+[END_MACRO]
+
+[MACRO] ARRAY_INTO_ITER_INSPECT_COLLECT_U64 %out_vec, %iter_reg, %inspect_fn
+    EXPAND ITER_INSPECT_COLLECT_U64 %out_vec, %iter_reg, %inspect_fn
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_INTO_ITER_INSPECT_COLLECT_U64.
+[MACRO] ARRAY_INTO_ITER_INSPECT_COLLECT %out_vec, %iter_reg, %inspect_fn
+    EXPAND ARRAY_INTO_ITER_INSPECT_COLLECT_U64 %out_vec, %iter_reg, %inspect_fn
+[END_MACRO]
+
+[MACRO] ARRAY_INTO_ITER_SCAN_COLLECT_U64 %out_vec, %iter_reg, %initial_state, %scan_fn
+    EXPAND ITER_SCAN_COLLECT_U64 %out_vec, %iter_reg, %initial_state, %scan_fn
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_INTO_ITER_SCAN_COLLECT_U64.
+[MACRO] ARRAY_INTO_ITER_SCAN_COLLECT %out_vec, %iter_reg, %initial_state, %scan_fn
+    EXPAND ARRAY_INTO_ITER_SCAN_COLLECT_U64 %out_vec, %iter_reg, %initial_state, %scan_fn
+[END_MACRO]
+
+[MACRO] ARRAY_INTO_ITER_FILTER_COLLECT_U64 %out_vec, %iter_reg, %pred_fn
+    EXPAND ITER_FILTER_COLLECT_U64 %out_vec, %iter_reg, %pred_fn
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_INTO_ITER_FILTER_COLLECT_U64.
+[MACRO] ARRAY_INTO_ITER_FILTER_COLLECT %out_vec, %iter_reg, %pred_fn
+    EXPAND ARRAY_INTO_ITER_FILTER_COLLECT_U64 %out_vec, %iter_reg, %pred_fn
+[END_MACRO]
+
+[MACRO] ARRAY_INTO_ITER_FILTER_MAP_COLLECT_U64 %out_vec, %iter_reg, %map_fn
+    EXPAND ITER_FILTER_MAP_COLLECT_U64 %out_vec, %iter_reg, %map_fn
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_INTO_ITER_FILTER_MAP_COLLECT_U64.
+[MACRO] ARRAY_INTO_ITER_FILTER_MAP_COLLECT %out_vec, %iter_reg, %map_fn
+    EXPAND ARRAY_INTO_ITER_FILTER_MAP_COLLECT_U64 %out_vec, %iter_reg, %map_fn
+[END_MACRO]
+
+[MACRO] ARRAY_INTO_ITER_MAP_WHILE_COLLECT_U64 %out_vec, %iter_reg, %map_fn
+    EXPAND ITER_MAP_WHILE_COLLECT_U64 %out_vec, %iter_reg, %map_fn
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_INTO_ITER_MAP_WHILE_COLLECT_U64.
+[MACRO] ARRAY_INTO_ITER_MAP_WHILE_COLLECT %out_vec, %iter_reg, %map_fn
+    EXPAND ARRAY_INTO_ITER_MAP_WHILE_COLLECT_U64 %out_vec, %iter_reg, %map_fn
+[END_MACRO]
+
+[MACRO] ARRAY_INTO_ITER_INTERSPERSE_COLLECT_U64 %out_vec, %iter_reg, %separator
+    EXPAND ITER_INTERSPERSE_COLLECT_U64 %out_vec, %iter_reg, %separator
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_INTO_ITER_INTERSPERSE_COLLECT_U64.
+[MACRO] ARRAY_INTO_ITER_INTERSPERSE_COLLECT %out_vec, %iter_reg, %separator
+    EXPAND ARRAY_INTO_ITER_INTERSPERSE_COLLECT_U64 %out_vec, %iter_reg, %separator
+[END_MACRO]
+
+[MACRO] ARRAY_INTO_ITER_INTERSPERSE_WITH_COLLECT_U64 %out_vec, %iter_reg, %sep_fn
+    EXPAND ITER_INTERSPERSE_WITH_COLLECT_U64 %out_vec, %iter_reg, %sep_fn
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_INTO_ITER_INTERSPERSE_WITH_COLLECT_U64.
+[MACRO] ARRAY_INTO_ITER_INTERSPERSE_WITH_COLLECT %out_vec, %iter_reg, %sep_fn
+    EXPAND ARRAY_INTO_ITER_INTERSPERSE_WITH_COLLECT_U64 %out_vec, %iter_reg, %sep_fn
+[END_MACRO]
+
+[MACRO] ARRAY_INTO_ITER_CYCLE_TAKE_COLLECT_U64 %out_vec, %iter_reg, %count
+    EXPAND ITER_CYCLE_TAKE_COLLECT_U64 %out_vec, %iter_reg, %count
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_INTO_ITER_CYCLE_TAKE_COLLECT_U64.
+[MACRO] ARRAY_INTO_ITER_CYCLE_TAKE_COLLECT %out_vec, %iter_reg, %count
+    EXPAND ARRAY_INTO_ITER_CYCLE_TAKE_COLLECT_U64 %out_vec, %iter_reg, %count
+[END_MACRO]
+
+[MACRO] ARRAY_INTO_ITER_TAKE_WHILE_COLLECT_U64 %out_vec, %iter_reg, %pred_fn
+    EXPAND ITER_TAKE_WHILE_COLLECT_U64 %out_vec, %iter_reg, %pred_fn
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_INTO_ITER_TAKE_WHILE_COLLECT_U64.
+[MACRO] ARRAY_INTO_ITER_TAKE_WHILE_COLLECT %out_vec, %iter_reg, %pred_fn
+    EXPAND ARRAY_INTO_ITER_TAKE_WHILE_COLLECT_U64 %out_vec, %iter_reg, %pred_fn
+[END_MACRO]
+
+[MACRO] ARRAY_INTO_ITER_SKIP_WHILE_COLLECT_U64 %out_vec, %iter_reg, %pred_fn
+    EXPAND ITER_SKIP_WHILE_COLLECT_U64 %out_vec, %iter_reg, %pred_fn
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_INTO_ITER_SKIP_WHILE_COLLECT_U64.
+[MACRO] ARRAY_INTO_ITER_SKIP_WHILE_COLLECT %out_vec, %iter_reg, %pred_fn
+    EXPAND ARRAY_INTO_ITER_SKIP_WHILE_COLLECT_U64 %out_vec, %iter_reg, %pred_fn
+[END_MACRO]
+
+[MACRO] ARRAY_INTO_ITER_ENUMERATE_COLLECT_U64 %out_vec, %iter_reg
+    EXPAND ITER_ENUMERATE_COLLECT_U64 %out_vec, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_INTO_ITER_ENUMERATE_COLLECT_U64.
+[MACRO] ARRAY_INTO_ITER_ENUMERATE_COLLECT %out_vec, %iter_reg
+    EXPAND ARRAY_INTO_ITER_ENUMERATE_COLLECT_U64 %out_vec, %iter_reg
+[END_MACRO]
+
+[MACRO] ARRAY_INTO_ITER_ZIP_COLLECT_U64 %out_vec, %left_iter, %right_iter
+    EXPAND ITER_ZIP_COLLECT_U64 %out_vec, %left_iter, %right_iter
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_INTO_ITER_ZIP_COLLECT_U64.
+[MACRO] ARRAY_INTO_ITER_ZIP_COLLECT %out_vec, %left_iter, %right_iter
+    EXPAND ARRAY_INTO_ITER_ZIP_COLLECT_U64 %out_vec, %left_iter, %right_iter
+[END_MACRO]
+
+[MACRO] ARRAY_INTO_ITER_CHAIN_COLLECT_U64 %out_vec, %left_iter, %right_iter
+    EXPAND ITER_CHAIN_COLLECT_U64 %out_vec, %left_iter, %right_iter
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_INTO_ITER_CHAIN_COLLECT_U64.
+[MACRO] ARRAY_INTO_ITER_CHAIN_COLLECT %out_vec, %left_iter, %right_iter
+    EXPAND ARRAY_INTO_ITER_CHAIN_COLLECT_U64 %out_vec, %left_iter, %right_iter
+[END_MACRO]
+
+[MACRO] ARRAY_INTO_ITER_BY_REF_COLLECT_U64 %out_vec, %iter_reg
+    EXPAND ITER_BY_REF_COLLECT_U64 %out_vec, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_INTO_ITER_BY_REF_COLLECT_U64.
+[MACRO] ARRAY_INTO_ITER_BY_REF_COLLECT %out_vec, %iter_reg
+    EXPAND ARRAY_INTO_ITER_BY_REF_COLLECT_U64 %out_vec, %iter_reg
+[END_MACRO]
+
+[MACRO] ARRAY_INTO_ITER_FUSE_COLLECT_U64 %out_vec, %iter_reg
+    EXPAND ITER_FUSE_COLLECT_U64 %out_vec, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_INTO_ITER_FUSE_COLLECT_U64.
+[MACRO] ARRAY_INTO_ITER_FUSE_COLLECT %out_vec, %iter_reg
+    EXPAND ARRAY_INTO_ITER_FUSE_COLLECT_U64 %out_vec, %iter_reg
+[END_MACRO]
+
+[MACRO] ARRAY_INTO_ITER_PEEKABLE_COLLECT_U64 %out_vec, %iter_reg
+    EXPAND ITER_PEEKABLE_COLLECT_U64 %out_vec, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_INTO_ITER_PEEKABLE_COLLECT_U64.
+[MACRO] ARRAY_INTO_ITER_PEEKABLE_COLLECT %out_vec, %iter_reg
+    EXPAND ARRAY_INTO_ITER_PEEKABLE_COLLECT_U64 %out_vec, %iter_reg
+[END_MACRO]
+
+[MACRO] ARRAY_INTO_ITER_PARTITION_U64 %out_true_vec, %out_false_vec, %iter_reg, %pred_fn
+    EXPAND ITER_PARTITION_U64 %out_true_vec, %out_false_vec, %iter_reg, %pred_fn
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_INTO_ITER_PARTITION_U64.
+[MACRO] ARRAY_INTO_ITER_PARTITION %out_true_vec, %out_false_vec, %iter_reg, %pred_fn
+    EXPAND ARRAY_INTO_ITER_PARTITION_U64 %out_true_vec, %out_false_vec, %iter_reg, %pred_fn
+[END_MACRO]
+
+[MACRO] ARRAY_INTO_ITER_IS_PARTITIONED_U64 %out_bool, %iter_reg, %pred_fn
+    EXPAND ITER_IS_PARTITIONED_U64 %out_bool, %iter_reg, %pred_fn
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_INTO_ITER_IS_PARTITIONED_U64.
+[MACRO] ARRAY_INTO_ITER_IS_PARTITIONED %out_bool, %iter_reg, %pred_fn
+    EXPAND ARRAY_INTO_ITER_IS_PARTITIONED_U64 %out_bool, %iter_reg, %pred_fn
+[END_MACRO]
+
+[MACRO] ARRAY_INTO_ITER_ARRAY_CHUNKS_COLLECT_U64 %out_ok, %out_vec, %iter_reg, %chunk_size
+    EXPAND ITER_ARRAY_CHUNKS_COLLECT_U64 %out_ok, %out_vec, %iter_reg, %chunk_size
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_INTO_ITER_ARRAY_CHUNKS_COLLECT_U64.
+[MACRO] ARRAY_INTO_ITER_ARRAY_CHUNKS_COLLECT %out_ok, %out_vec, %iter_reg, %chunk_size
+    EXPAND ARRAY_INTO_ITER_ARRAY_CHUNKS_COLLECT_U64 %out_ok, %out_vec, %iter_reg, %chunk_size
+[END_MACRO]
+
+[MACRO] ARRAY_INTO_ITER_MAP_WINDOWS_COLLECT_U64 %out_ok, %out_vec, %iter_reg, %window_size, %map_fn
+    EXPAND ITER_MAP_WINDOWS_COLLECT_U64 %out_ok, %out_vec, %iter_reg, %window_size, %map_fn
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_INTO_ITER_MAP_WINDOWS_COLLECT_U64.
+[MACRO] ARRAY_INTO_ITER_MAP_WINDOWS_COLLECT %out_ok, %out_vec, %iter_reg, %window_size, %map_fn
+    EXPAND ARRAY_INTO_ITER_MAP_WINDOWS_COLLECT_U64 %out_ok, %out_vec, %iter_reg, %window_size, %map_fn
+[END_MACRO]
+
+[MACRO] ARRAY_INTO_ITER_CLONE_U64 %out_iter, %out_vec, %iter_reg
+    EXPAND VEC_INTO_ITER_CLONE_U64 %out_iter, %out_vec, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_INTO_ITER_CLONE_U64.
+[MACRO] ARRAY_INTO_ITER_CLONE %out_iter, %out_vec, %iter_reg
+    EXPAND ARRAY_INTO_ITER_CLONE_U64 %out_iter, %out_vec, %iter_reg
+[END_MACRO]
+
+[MACRO] ARRAY_ITER_AS_REF_SLICE_U64 %out_slice, %iter_reg
+    EXPAND ITER_AS_SLICE_U64 %out_slice, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_ITER_AS_REF_SLICE_U64.
+[MACRO] ARRAY_ITER_AS_REF_SLICE %out_slice, %iter_reg
+    EXPAND ARRAY_ITER_AS_REF_SLICE_U64 %out_slice, %iter_reg
+[END_MACRO]
+
+[MACRO] ARRAY_ITER_SIZE_HINT_U64 %out_lower, %out_upper, %iter_reg
+    EXPAND ITER_SIZE_HINT %out_lower, %out_upper, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_ITER_SIZE_HINT_U64.
+[MACRO] ARRAY_ITER_SIZE_HINT %out_lower, %out_upper, %iter_reg
+    EXPAND ARRAY_ITER_SIZE_HINT_U64 %out_lower, %out_upper, %iter_reg
+[END_MACRO]
+
+[MACRO] ARRAY_ITER_EXACT_SIZE_LEN_U64 %out_len, %iter_reg
+    EXPAND ITER_EXACT_SIZE_LEN %out_len, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_ITER_EXACT_SIZE_LEN_U64.
+[MACRO] ARRAY_ITER_EXACT_SIZE_LEN %out_len, %iter_reg
+    EXPAND ARRAY_ITER_EXACT_SIZE_LEN_U64 %out_len, %iter_reg
+[END_MACRO]
+
+[MACRO] ARRAY_ITER_EXACT_SIZE_IS_EMPTY_U64 %out_bool, %iter_reg
+    EXPAND ITER_EXACT_SIZE_IS_EMPTY %out_bool, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_ITER_EXACT_SIZE_IS_EMPTY_U64.
+[MACRO] ARRAY_ITER_EXACT_SIZE_IS_EMPTY %out_bool, %iter_reg
+    EXPAND ARRAY_ITER_EXACT_SIZE_IS_EMPTY_U64 %out_bool, %iter_reg
+[END_MACRO]
+
+[MACRO] ARRAY_ITER_NEXT_U64 %out_has, %out_value, %iter_reg
+    EXPAND ITER_NEXT_U64 %out_has, %out_value, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_ITER_NEXT_U64.
+[MACRO] ARRAY_ITER_NEXT %out_has, %out_value, %iter_reg
+    EXPAND ARRAY_ITER_NEXT_U64 %out_has, %out_value, %iter_reg
+[END_MACRO]
+
+[MACRO] ARRAY_ITER_NEXT_BACK_U64 %out_has, %out_value, %iter_reg
+    EXPAND ITER_NEXT_BACK_U64 %out_has, %out_value, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_ITER_NEXT_BACK_U64.
+[MACRO] ARRAY_ITER_NEXT_BACK %out_has, %out_value, %iter_reg
+    EXPAND ARRAY_ITER_NEXT_BACK_U64 %out_has, %out_value, %iter_reg
+[END_MACRO]
+
+[MACRO] ARRAY_ITER_CLONE_U64 %out_iter, %iter_reg
+    EXPAND ITER_CLONE %out_iter, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_ITER_CLONE_U64.
+[MACRO] ARRAY_ITER_CLONE %out_iter, %iter_reg
+    EXPAND ARRAY_ITER_CLONE_U64 %out_iter, %iter_reg
+[END_MACRO]
+
+[MACRO] ARRAY_ITER_MUT_AS_REF_SLICE_U64 %out_slice, %iter_reg
+    EXPAND ITER_AS_SLICE_U64 %out_slice, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_ITER_MUT_AS_REF_SLICE_U64.
+[MACRO] ARRAY_ITER_MUT_AS_REF_SLICE %out_slice, %iter_reg
+    EXPAND ARRAY_ITER_MUT_AS_REF_SLICE_U64 %out_slice, %iter_reg
+[END_MACRO]
+
+[MACRO] ARRAY_ITER_MUT_AS_MUT_SLICE_U64 %out_slice, %iter_reg
+    EXPAND ITER_AS_SLICE_U64 %out_slice, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_ITER_MUT_AS_MUT_SLICE_U64.
+[MACRO] ARRAY_ITER_MUT_AS_MUT_SLICE %out_slice, %iter_reg
+    EXPAND ARRAY_ITER_MUT_AS_MUT_SLICE_U64 %out_slice, %iter_reg
+[END_MACRO]
+
+[MACRO] ARRAY_ITER_MUT_SIZE_HINT_U64 %out_lower, %out_upper, %iter_reg
+    EXPAND ITER_SIZE_HINT %out_lower, %out_upper, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_ITER_MUT_SIZE_HINT_U64.
+[MACRO] ARRAY_ITER_MUT_SIZE_HINT %out_lower, %out_upper, %iter_reg
+    EXPAND ARRAY_ITER_MUT_SIZE_HINT_U64 %out_lower, %out_upper, %iter_reg
+[END_MACRO]
+
+[MACRO] ARRAY_ITER_MUT_EXACT_SIZE_LEN_U64 %out_len, %iter_reg
+    EXPAND ITER_EXACT_SIZE_LEN %out_len, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_ITER_MUT_EXACT_SIZE_LEN_U64.
+[MACRO] ARRAY_ITER_MUT_EXACT_SIZE_LEN %out_len, %iter_reg
+    EXPAND ARRAY_ITER_MUT_EXACT_SIZE_LEN_U64 %out_len, %iter_reg
+[END_MACRO]
+
+[MACRO] ARRAY_ITER_MUT_EXACT_SIZE_IS_EMPTY_U64 %out_bool, %iter_reg
+    EXPAND ITER_EXACT_SIZE_IS_EMPTY %out_bool, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_ITER_MUT_EXACT_SIZE_IS_EMPTY_U64.
+[MACRO] ARRAY_ITER_MUT_EXACT_SIZE_IS_EMPTY %out_bool, %iter_reg
+    EXPAND ARRAY_ITER_MUT_EXACT_SIZE_IS_EMPTY_U64 %out_bool, %iter_reg
+[END_MACRO]
+
+[MACRO] ARRAY_ITER_MUT_NEXT_U64 %out_has, %out_value, %iter_reg
+    EXPAND ITER_NEXT_U64 %out_has, %out_value, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_ITER_MUT_NEXT_U64.
+[MACRO] ARRAY_ITER_MUT_NEXT %out_has, %out_value, %iter_reg
+    EXPAND ARRAY_ITER_MUT_NEXT_U64 %out_has, %out_value, %iter_reg
+[END_MACRO]
+
+[MACRO] ARRAY_ITER_MUT_NEXT_BACK_U64 %out_has, %out_value, %iter_reg
+    EXPAND ITER_NEXT_BACK_U64 %out_has, %out_value, %iter_reg
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_ITER_MUT_NEXT_BACK_U64.
+[MACRO] ARRAY_ITER_MUT_NEXT_BACK %out_has, %out_value, %iter_reg
+    EXPAND ARRAY_ITER_MUT_NEXT_BACK_U64 %out_has, %out_value, %iter_reg
+[END_MACRO]
+
+[MACRO] ARRAY_GET_U64 %out_value, %array_ptr, %index
+    __array_get_off_%out_value = mul %index, 8
+    __array_get_ptr_%out_value = ptr_add %array_ptr, __array_get_off_%out_value
+    %out_value = load __array_get_ptr_%out_value+0 as u64
+    !__array_get_ptr_%out_value
+    !__array_get_off_%out_value
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_GET_U64.
+[MACRO] ARRAY_GET %out_value, %array_ptr, %index
+    EXPAND ARRAY_GET_U64 %out_value, %array_ptr, %index
+[END_MACRO]
+
+[MACRO] ARRAY_GET_MUT_PTR_U64 %out_ptr, %array_ptr, %index
+    __array_mut_off_%out_ptr = mul %index, 8
+    %out_ptr = ptr_add %array_ptr, __array_mut_off_%out_ptr
+    !__array_mut_off_%out_ptr
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_GET_MUT_PTR_U64.
+[MACRO] ARRAY_GET_MUT_PTR %out_ptr, %array_ptr, %index
+    EXPAND ARRAY_GET_MUT_PTR_U64 %out_ptr, %array_ptr, %index
+[END_MACRO]
+
+[MACRO] ARRAY_INDEX_U64 %out_value, %array_ptr, %index
+    EXPAND ARRAY_GET_U64 %out_value, %array_ptr, %index
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_INDEX_U64.
+[MACRO] ARRAY_INDEX %out_value, %array_ptr, %index
+    EXPAND ARRAY_INDEX_U64 %out_value, %array_ptr, %index
+[END_MACRO]
+
+[MACRO] ARRAY_INDEX_MUT_PTR_U64 %out_ptr, %array_ptr, %index
+    EXPAND ARRAY_GET_MUT_PTR_U64 %out_ptr, %array_ptr, %index
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_INDEX_MUT_PTR_U64.
+[MACRO] ARRAY_INDEX_MUT_PTR %out_ptr, %array_ptr, %index
+    EXPAND ARRAY_INDEX_MUT_PTR_U64 %out_ptr, %array_ptr, %index
+[END_MACRO]
+
+[MACRO] ARRAY_TRY_GET_U64 %out_ok, %out_value, %array_ptr, %length, %index
+    __array_get_in_bounds_%out_ok = ult %index, %length
+    br __array_get_in_bounds_%out_ok -> L_ARRAY_TRY_GET_HIT_%out_ok, L_ARRAY_TRY_GET_MISS_%out_ok
+
+L_ARRAY_TRY_GET_HIT_%out_ok:
+    EXPAND ARRAY_GET_U64 %out_value, %array_ptr, %index
+    %out_ok = add 0, 1
+    !__array_get_in_bounds_%out_ok
+    jmp L_ARRAY_TRY_GET_END_%out_ok
+
+L_ARRAY_TRY_GET_MISS_%out_ok:
+    %out_value = add 0, 0
+    %out_ok = add 0, 0
+    !__array_get_in_bounds_%out_ok
+
+L_ARRAY_TRY_GET_END_%out_ok:
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_TRY_GET_U64.
+[MACRO] ARRAY_TRY_GET %out_ok, %out_value, %array_ptr, %length, %index
+    EXPAND ARRAY_TRY_GET_U64 %out_ok, %out_value, %array_ptr, %length, %index
+[END_MACRO]
+
+[MACRO] ARRAY_TRY_GET_MUT_PTR_U64 %out_ok, %out_ptr, %array_ptr, %length, %index
+    __array_mut_in_bounds_%out_ok = ult %index, %length
+    br __array_mut_in_bounds_%out_ok -> L_ARRAY_TRY_MUT_HIT_%out_ok, L_ARRAY_TRY_MUT_MISS_%out_ok
+
+L_ARRAY_TRY_MUT_HIT_%out_ok:
+    EXPAND ARRAY_GET_MUT_PTR_U64 %out_ptr, %array_ptr, %index
+    %out_ok = add 0, 1
+    !__array_mut_in_bounds_%out_ok
+    jmp L_ARRAY_TRY_MUT_END_%out_ok
+
+L_ARRAY_TRY_MUT_MISS_%out_ok:
+    %out_ptr = 0 as ptr
+    %out_ok = add 0, 0
+    !__array_mut_in_bounds_%out_ok
+
+L_ARRAY_TRY_MUT_END_%out_ok:
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_TRY_GET_MUT_PTR_U64.
+[MACRO] ARRAY_TRY_GET_MUT_PTR %out_ok, %out_ptr, %array_ptr, %length, %index
+    EXPAND ARRAY_TRY_GET_MUT_PTR_U64 %out_ok, %out_ptr, %array_ptr, %length, %index
+[END_MACRO]
+
+[MACRO] ARRAY_FIRST_U64 %out_value, %array_ptr
+    EXPAND ARRAY_GET_U64 %out_value, %array_ptr, 0
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_FIRST_U64.
+[MACRO] ARRAY_FIRST %out_value, %array_ptr
+    EXPAND ARRAY_FIRST_U64 %out_value, %array_ptr
+[END_MACRO]
+
+[MACRO] ARRAY_LAST_U64 %out_value, %array_ptr, %length
+    __array_last_idx_%out_value = sub %length, 1
+    EXPAND ARRAY_GET_U64 %out_value, %array_ptr, __array_last_idx_%out_value
+    !__array_last_idx_%out_value
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_LAST_U64.
+[MACRO] ARRAY_LAST %out_value, %array_ptr, %length
+    EXPAND ARRAY_LAST_U64 %out_value, %array_ptr, %length
+[END_MACRO]
+
+[MACRO] ARRAY_FILL_U64 %array_ptr, %length, %value
+    __array_fill_idx_slot_%array_ptr = stack_alloc 8
+    store __array_fill_idx_slot_%array_ptr+0, 0 as u64
+    jmp L_ARRAY_FILL_HEAD_%array_ptr
+
+L_ARRAY_FILL_HEAD_%array_ptr:
+    __array_fill_idx_%array_ptr = load __array_fill_idx_slot_%array_ptr+0 as u64
+    __array_fill_done_%array_ptr = eq __array_fill_idx_%array_ptr, %length
+    br __array_fill_done_%array_ptr -> L_ARRAY_FILL_DONE_%array_ptr, L_ARRAY_FILL_BODY_%array_ptr
+
+L_ARRAY_FILL_BODY_%array_ptr:
+    __array_fill_off_%array_ptr = mul __array_fill_idx_%array_ptr, 8
+    __array_fill_ptr_%array_ptr = ptr_add %array_ptr, __array_fill_off_%array_ptr
+    store __array_fill_ptr_%array_ptr+0, %value as u64
+    __array_fill_next_%array_ptr = add __array_fill_idx_%array_ptr, 1
+    store __array_fill_idx_slot_%array_ptr+0, __array_fill_next_%array_ptr as u64
+    !__array_fill_next_%array_ptr
+    !__array_fill_ptr_%array_ptr
+    !__array_fill_off_%array_ptr
+    !__array_fill_done_%array_ptr
+    !__array_fill_idx_%array_ptr
+    jmp L_ARRAY_FILL_HEAD_%array_ptr
+
+L_ARRAY_FILL_DONE_%array_ptr:
+    !__array_fill_done_%array_ptr
+    !__array_fill_idx_%array_ptr
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_FILL_U64.
+[MACRO] ARRAY_FILL %array_ptr, %length, %value
+    EXPAND ARRAY_FILL_U64 %array_ptr, %length, %value
+[END_MACRO]
+
+[MACRO] ARRAY_REPEAT_U64 %array_ptr, %length, %value
+    EXPAND ARRAY_FILL_U64 %array_ptr, %length, %value
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_REPEAT_U64.
+[MACRO] ARRAY_REPEAT %array_ptr, %length, %value
+    EXPAND ARRAY_REPEAT_U64 %array_ptr, %length, %value
+[END_MACRO]
+
+[MACRO] ARRAY_DEFAULT_U64 %array_ptr, %length
+    EXPAND ARRAY_FILL_U64 %array_ptr, %length, 0
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_DEFAULT_U64.
+[MACRO] ARRAY_DEFAULT %array_ptr, %length
+    EXPAND ARRAY_DEFAULT_U64 %array_ptr, %length
+[END_MACRO]
+
+[MACRO] ARRAY_DEFAULT_I64 %array_ptr, %length
+    EXPAND ARRAY_DEFAULT_U64 %array_ptr, %length
+[END_MACRO]
+
+[MACRO] ARRAY_DEFAULT_USIZE %array_ptr, %length
+    EXPAND ARRAY_DEFAULT_U64 %array_ptr, %length
+[END_MACRO]
+
+[MACRO] ARRAY_DEFAULT_BOOL %array_ptr, %length
+    EXPAND ARRAY_DEFAULT_U64 %array_ptr, %length
+[END_MACRO]
+
+[MACRO] DEFAULT_ARRAY_U64 %array_ptr, %length
+    EXPAND ARRAY_DEFAULT_U64 %array_ptr, %length
+[END_MACRO]
+
+// Rust method-name alias over DEFAULT_ARRAY_U64.
+[MACRO] DEFAULT_ARRAY %array_ptr, %length
+    EXPAND DEFAULT_ARRAY_U64 %array_ptr, %length
+[END_MACRO]
+
+[MACRO] DEFAULT_ARRAY_I64 %array_ptr, %length
+    EXPAND ARRAY_DEFAULT_I64 %array_ptr, %length
+[END_MACRO]
+
+[MACRO] DEFAULT_ARRAY_USIZE %array_ptr, %length
+    EXPAND ARRAY_DEFAULT_USIZE %array_ptr, %length
+[END_MACRO]
+
+[MACRO] DEFAULT_ARRAY_BOOL %array_ptr, %length
+    EXPAND ARRAY_DEFAULT_BOOL %array_ptr, %length
+[END_MACRO]
+
+[MACRO] ARRAY_COPY_U64 %dst_ptr, %src_ptr, %length
+    __array_copy_bytes_%dst_ptr = mul %length, 8
+    call @sa_mem_copy(&%dst_ptr, &%src_ptr, __array_copy_bytes_%dst_ptr)
+    !__array_copy_bytes_%dst_ptr
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_COPY_U64.
+[MACRO] ARRAY_COPY %dst_ptr, %src_ptr, %length
+    EXPAND ARRAY_COPY_U64 %dst_ptr, %src_ptr, %length
+[END_MACRO]
+
+[MACRO] ARRAY_CLONE_U64 %dst_ptr, %src_ptr, %length
+    EXPAND ARRAY_COPY_U64 %dst_ptr, %src_ptr, %length
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_CLONE_U64.
+[MACRO] ARRAY_CLONE %dst_ptr, %src_ptr, %length
+    EXPAND ARRAY_CLONE_U64 %dst_ptr, %src_ptr, %length
+[END_MACRO]
+
+[MACRO] ARRAY_CLONE_FROM_U64 %dst_ptr, %src_ptr, %length
+    EXPAND ARRAY_COPY_U64 %dst_ptr, %src_ptr, %length
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_CLONE_FROM_U64.
+[MACRO] ARRAY_CLONE_FROM %dst_ptr, %src_ptr, %length
+    EXPAND ARRAY_CLONE_FROM_U64 %dst_ptr, %src_ptr, %length
+[END_MACRO]
+
+[MACRO] ARRAY_COPY_FROM_U64 %dst_ptr, %src_ptr, %length
+    EXPAND ARRAY_COPY_U64 %dst_ptr, %src_ptr, %length
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_COPY_FROM_U64.
+[MACRO] ARRAY_COPY_FROM %dst_ptr, %src_ptr, %length
+    EXPAND ARRAY_COPY_FROM_U64 %dst_ptr, %src_ptr, %length
+[END_MACRO]
+
+[MACRO] ARRAY_EQ_U64 %out_bool, %left_ptr, %right_ptr, %length
+    __array_eq_left_%out_bool = stack_alloc Slice_SIZE
+    __array_eq_right_%out_bool = stack_alloc Slice_SIZE
+    EXPAND ARRAY_AS_SLICE_U64 __array_eq_left_%out_bool, %left_ptr, %length
+    EXPAND ARRAY_AS_SLICE_U64 __array_eq_right_%out_bool, %right_ptr, %length
+    EXPAND SLICE_EQ_U64 %out_bool, __array_eq_left_%out_bool, __array_eq_right_%out_bool
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_EQ_U64.
+[MACRO] ARRAY_EQ %out_bool, %left_ptr, %right_ptr, %length
+    EXPAND ARRAY_EQ_U64 %out_bool, %left_ptr, %right_ptr, %length
+[END_MACRO]
+
+[MACRO] ARRAY_NE_U64 %out_bool, %left_ptr, %right_ptr, %length
+    EXPAND ARRAY_EQ_U64 __array_ne_eq_%out_bool, %left_ptr, %right_ptr, %length
+    %out_bool = eq __array_ne_eq_%out_bool, 0
+    !__array_ne_eq_%out_bool
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_NE_U64.
+[MACRO] ARRAY_NE %out_bool, %left_ptr, %right_ptr, %length
+    EXPAND ARRAY_NE_U64 %out_bool, %left_ptr, %right_ptr, %length
+[END_MACRO]
+
+[MACRO] ARRAY_PARTIAL_EQ_U64 %out_bool, %left_ptr, %right_ptr, %length
+    EXPAND ARRAY_EQ_U64 %out_bool, %left_ptr, %right_ptr, %length
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_PARTIAL_EQ_U64.
+[MACRO] ARRAY_PARTIAL_EQ %out_bool, %left_ptr, %right_ptr, %length
+    EXPAND ARRAY_PARTIAL_EQ_U64 %out_bool, %left_ptr, %right_ptr, %length
+[END_MACRO]
+
+[MACRO] ARRAY_CMP_U64 %out_ordering, %left_ptr, %right_ptr, %length
+    __array_cmp_left_%out_ordering = stack_alloc Slice_SIZE
+    __array_cmp_right_%out_ordering = stack_alloc Slice_SIZE
+    EXPAND ARRAY_AS_SLICE_U64 __array_cmp_left_%out_ordering, %left_ptr, %length
+    EXPAND ARRAY_AS_SLICE_U64 __array_cmp_right_%out_ordering, %right_ptr, %length
+    EXPAND SLICE_CMP_U64 %out_ordering, __array_cmp_left_%out_ordering, __array_cmp_right_%out_ordering
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_CMP_U64.
+[MACRO] ARRAY_CMP %out_ordering, %left_ptr, %right_ptr, %length
+    EXPAND ARRAY_CMP_U64 %out_ordering, %left_ptr, %right_ptr, %length
+[END_MACRO]
+
+[MACRO] ARRAY_PARTIAL_CMP_U64 %out_ordering, %left_ptr, %right_ptr, %length
+    EXPAND ARRAY_CMP_U64 %out_ordering, %left_ptr, %right_ptr, %length
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_PARTIAL_CMP_U64.
+[MACRO] ARRAY_PARTIAL_CMP %out_ordering, %left_ptr, %right_ptr, %length
+    EXPAND ARRAY_PARTIAL_CMP_U64 %out_ordering, %left_ptr, %right_ptr, %length
+[END_MACRO]
+
+[MACRO] ARRAY_LT_U64 %out_bool, %left_ptr, %right_ptr, %length
+    EXPAND ARRAY_CMP_U64 __array_lt_order_%out_bool, %left_ptr, %right_ptr, %length
+    %out_bool = slt __array_lt_order_%out_bool, 0
+    !__array_lt_order_%out_bool
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_LT_U64.
+[MACRO] ARRAY_LT %out_bool, %left_ptr, %right_ptr, %length
+    EXPAND ARRAY_LT_U64 %out_bool, %left_ptr, %right_ptr, %length
+[END_MACRO]
+
+[MACRO] ARRAY_LE_U64 %out_bool, %left_ptr, %right_ptr, %length
+    EXPAND ARRAY_CMP_U64 __array_le_order_%out_bool, %left_ptr, %right_ptr, %length
+    %out_bool = sle __array_le_order_%out_bool, 0
+    !__array_le_order_%out_bool
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_LE_U64.
+[MACRO] ARRAY_LE %out_bool, %left_ptr, %right_ptr, %length
+    EXPAND ARRAY_LE_U64 %out_bool, %left_ptr, %right_ptr, %length
+[END_MACRO]
+
+[MACRO] ARRAY_GT_U64 %out_bool, %left_ptr, %right_ptr, %length
+    EXPAND ARRAY_CMP_U64 __array_gt_order_%out_bool, %left_ptr, %right_ptr, %length
+    %out_bool = sgt __array_gt_order_%out_bool, 0
+    !__array_gt_order_%out_bool
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_GT_U64.
+[MACRO] ARRAY_GT %out_bool, %left_ptr, %right_ptr, %length
+    EXPAND ARRAY_GT_U64 %out_bool, %left_ptr, %right_ptr, %length
+[END_MACRO]
+
+[MACRO] ARRAY_GE_U64 %out_bool, %left_ptr, %right_ptr, %length
+    EXPAND ARRAY_CMP_U64 __array_ge_order_%out_bool, %left_ptr, %right_ptr, %length
+    %out_bool = sge __array_ge_order_%out_bool, 0
+    !__array_ge_order_%out_bool
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_GE_U64.
+[MACRO] ARRAY_GE %out_bool, %left_ptr, %right_ptr, %length
+    EXPAND ARRAY_GE_U64 %out_bool, %left_ptr, %right_ptr, %length
+[END_MACRO]
+
+[MACRO] DEFAULT_HASHER_WRITE_ARRAY_U64 %hasher, %array_ptr, %length
+    __array_hash_slice_%hasher = stack_alloc Slice_SIZE
+    EXPAND ARRAY_AS_SLICE_U64 __array_hash_slice_%hasher, %array_ptr, %length
+    EXPAND DEFAULT_HASHER_WRITE_SLICE_U64 %hasher, __array_hash_slice_%hasher
+[END_MACRO]
+
+// Rust method-name alias over DEFAULT_HASHER_WRITE_ARRAY_U64.
+[MACRO] DEFAULT_HASHER_WRITE_ARRAY %hasher, %array_ptr, %length
+    EXPAND DEFAULT_HASHER_WRITE_ARRAY_U64 %hasher, %array_ptr, %length
+[END_MACRO]
+
+[MACRO] ARRAY_HASH_U64 %out_hash, %array_ptr, %length
+    __array_hash_hasher_%out_hash = stack_alloc DefaultHasher_SIZE
+    EXPAND DEFAULT_HASHER_NEW __array_hash_hasher_%out_hash
+    EXPAND DEFAULT_HASHER_WRITE_ARRAY_U64 __array_hash_hasher_%out_hash, %array_ptr, %length
+    EXPAND DEFAULT_HASHER_FINISH %out_hash, __array_hash_hasher_%out_hash
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_HASH_U64.
+[MACRO] ARRAY_HASH %out_hash, %array_ptr, %length
+    EXPAND ARRAY_HASH_U64 %out_hash, %array_ptr, %length
+[END_MACRO]
+
+[MACRO] BUILD_HASHER_DEFAULT_HASH_ONE_ARRAY_U64 %out_hash, %builder, %array_ptr, %length
+    __build_hash_one_array_u64_hasher_%out_hash = stack_alloc DefaultHasher_SIZE
+    EXPAND BUILD_HASHER_DEFAULT_BUILD __build_hash_one_array_u64_hasher_%out_hash, %builder
+    EXPAND DEFAULT_HASHER_WRITE_ARRAY_U64 __build_hash_one_array_u64_hasher_%out_hash, %array_ptr, %length
+    EXPAND DEFAULT_HASHER_FINISH %out_hash, __build_hash_one_array_u64_hasher_%out_hash
+[END_MACRO]
+
+// Rust method-name alias over BUILD_HASHER_DEFAULT_HASH_ONE_ARRAY_U64.
+[MACRO] BUILD_HASHER_DEFAULT_HASH_ONE_ARRAY %out_hash, %builder, %array_ptr, %length
+    EXPAND BUILD_HASHER_DEFAULT_HASH_ONE_ARRAY_U64 %out_hash, %builder, %array_ptr, %length
+[END_MACRO]
+
+[MACRO] RANDOM_STATE_HASH_ONE_ARRAY_U64 %out_hash, %state, %array_ptr, %length
+    __random_state_hash_one_array_u64_hasher_%out_hash = stack_alloc DefaultHasher_SIZE
+    EXPAND RANDOM_STATE_BUILD __random_state_hash_one_array_u64_hasher_%out_hash, %state
+    EXPAND DEFAULT_HASHER_WRITE_ARRAY_U64 __random_state_hash_one_array_u64_hasher_%out_hash, %array_ptr, %length
+    EXPAND DEFAULT_HASHER_FINISH %out_hash, __random_state_hash_one_array_u64_hasher_%out_hash
+[END_MACRO]
+
+// Rust method-name alias over RANDOM_STATE_HASH_ONE_ARRAY_U64.
+[MACRO] RANDOM_STATE_HASH_ONE_ARRAY %out_hash, %state, %array_ptr, %length
+    EXPAND RANDOM_STATE_HASH_ONE_ARRAY_U64 %out_hash, %state, %array_ptr, %length
+[END_MACRO]
+
+[MACRO] ARRAY_TRY_COPY_FROM_SLICE_U64 %out_ok, %dst_ptr, %length, %src_slice
+    __array_copy_src_len_%out_ok = load %src_slice+Slice_len as u64
+    __array_copy_same_len_%out_ok = eq %length, __array_copy_src_len_%out_ok
+    br __array_copy_same_len_%out_ok -> L_ARRAY_COPY_SLICE_HIT_%out_ok, L_ARRAY_COPY_SLICE_MISS_%out_ok
+
+L_ARRAY_COPY_SLICE_HIT_%out_ok:
+    __array_copy_src_ptr_%out_ok = load %src_slice+Slice_ptr as ptr
+    EXPAND ARRAY_COPY_U64 %dst_ptr, __array_copy_src_ptr_%out_ok, %length
+    %out_ok = add 0, 1
+    !__array_copy_src_ptr_%out_ok
+    !__array_copy_same_len_%out_ok
+    !__array_copy_src_len_%out_ok
+    jmp L_ARRAY_COPY_SLICE_END_%out_ok
+
+L_ARRAY_COPY_SLICE_MISS_%out_ok:
+    %out_ok = add 0, 0
+    !__array_copy_same_len_%out_ok
+    !__array_copy_src_len_%out_ok
+
+L_ARRAY_COPY_SLICE_END_%out_ok:
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_TRY_COPY_FROM_SLICE_U64.
+[MACRO] ARRAY_TRY_COPY_FROM_SLICE %out_ok, %dst_ptr, %length, %src_slice
+    EXPAND ARRAY_TRY_COPY_FROM_SLICE_U64 %out_ok, %dst_ptr, %length, %src_slice
+[END_MACRO]
+
+[MACRO] ARRAY_TRY_FROM_SLICE_U64 %out_ok, %dst_ptr, %length, %src_slice
+    EXPAND ARRAY_TRY_COPY_FROM_SLICE_U64 %out_ok, %dst_ptr, %length, %src_slice
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_TRY_FROM_SLICE_U64.
+[MACRO] ARRAY_TRY_FROM_SLICE %out_ok, %dst_ptr, %length, %src_slice
+    EXPAND ARRAY_TRY_FROM_SLICE_U64 %out_ok, %dst_ptr, %length, %src_slice
+[END_MACRO]
+
+[MACRO] ARRAY_TRY_FROM_MUT_SLICE_U64 %out_ok, %dst_ptr, %length, %src_slice
+    EXPAND ARRAY_TRY_COPY_FROM_SLICE_U64 %out_ok, %dst_ptr, %length, %src_slice
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_TRY_FROM_MUT_SLICE_U64.
+[MACRO] ARRAY_TRY_FROM_MUT_SLICE %out_ok, %dst_ptr, %length, %src_slice
+    EXPAND ARRAY_TRY_FROM_MUT_SLICE_U64 %out_ok, %dst_ptr, %length, %src_slice
+[END_MACRO]
+
+[MACRO] ARRAY_TRY_SPLIT_ARRAY_REF_U64 %out_ok, %out_prefix, %out_suffix, %array_ptr, %length, %prefix_len
+    __array_split_ref_ok_%out_ok = ule %prefix_len, %length
+    br __array_split_ref_ok_%out_ok -> L_ARRAY_SPLIT_REF_OK_%out_ok, L_ARRAY_SPLIT_REF_MISS_%out_ok
+
+L_ARRAY_SPLIT_REF_OK_%out_ok:
+    __array_split_ref_suffix_len_%out_ok = sub %length, %prefix_len
+    __array_split_ref_suffix_off_%out_ok = mul %prefix_len, 8
+    __array_split_ref_suffix_ptr_%out_ok = ptr_add %array_ptr, __array_split_ref_suffix_off_%out_ok
+    EXPAND SLICE_NEW %out_prefix, %array_ptr, %prefix_len
+    EXPAND SLICE_NEW %out_suffix, __array_split_ref_suffix_ptr_%out_ok, __array_split_ref_suffix_len_%out_ok
+    %out_ok = add 0, 1
+    !__array_split_ref_suffix_ptr_%out_ok
+    !__array_split_ref_suffix_off_%out_ok
+    !__array_split_ref_suffix_len_%out_ok
+    !__array_split_ref_ok_%out_ok
+    jmp L_ARRAY_SPLIT_REF_END_%out_ok
+
+L_ARRAY_SPLIT_REF_MISS_%out_ok:
+    EXPAND SLICE_NEW %out_prefix, %array_ptr, 0
+    EXPAND SLICE_NEW %out_suffix, %array_ptr, 0
+    %out_ok = add 0, 0
+    !__array_split_ref_ok_%out_ok
+
+L_ARRAY_SPLIT_REF_END_%out_ok:
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_TRY_SPLIT_ARRAY_REF_U64.
+[MACRO] ARRAY_TRY_SPLIT_ARRAY_REF %out_ok, %out_prefix, %out_suffix, %array_ptr, %length, %prefix_len
+    EXPAND ARRAY_TRY_SPLIT_ARRAY_REF_U64 %out_ok, %out_prefix, %out_suffix, %array_ptr, %length, %prefix_len
+[END_MACRO]
+
+[MACRO] ARRAY_TRY_SPLIT_ARRAY_MUT_U64 %out_ok, %out_prefix, %out_suffix, %array_ptr, %length, %prefix_len
+    EXPAND ARRAY_TRY_SPLIT_ARRAY_REF_U64 %out_ok, %out_prefix, %out_suffix, %array_ptr, %length, %prefix_len
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_TRY_SPLIT_ARRAY_MUT_U64.
+[MACRO] ARRAY_TRY_SPLIT_ARRAY_MUT %out_ok, %out_prefix, %out_suffix, %array_ptr, %length, %prefix_len
+    EXPAND ARRAY_TRY_SPLIT_ARRAY_MUT_U64 %out_ok, %out_prefix, %out_suffix, %array_ptr, %length, %prefix_len
+[END_MACRO]
+
+[MACRO] ARRAY_TRY_RSPLIT_ARRAY_REF_U64 %out_ok, %out_prefix, %out_suffix, %array_ptr, %length, %suffix_len
+    __array_rsplit_ref_ok_%out_ok = ule %suffix_len, %length
+    br __array_rsplit_ref_ok_%out_ok -> L_ARRAY_RSPLIT_REF_OK_%out_ok, L_ARRAY_RSPLIT_REF_MISS_%out_ok
+
+L_ARRAY_RSPLIT_REF_OK_%out_ok:
+    __array_rsplit_ref_prefix_len_%out_ok = sub %length, %suffix_len
+    __array_rsplit_ref_suffix_off_%out_ok = mul __array_rsplit_ref_prefix_len_%out_ok, 8
+    __array_rsplit_ref_suffix_ptr_%out_ok = ptr_add %array_ptr, __array_rsplit_ref_suffix_off_%out_ok
+    EXPAND SLICE_NEW %out_prefix, %array_ptr, __array_rsplit_ref_prefix_len_%out_ok
+    EXPAND SLICE_NEW %out_suffix, __array_rsplit_ref_suffix_ptr_%out_ok, %suffix_len
+    %out_ok = add 0, 1
+    !__array_rsplit_ref_suffix_ptr_%out_ok
+    !__array_rsplit_ref_suffix_off_%out_ok
+    !__array_rsplit_ref_prefix_len_%out_ok
+    !__array_rsplit_ref_ok_%out_ok
+    jmp L_ARRAY_RSPLIT_REF_END_%out_ok
+
+L_ARRAY_RSPLIT_REF_MISS_%out_ok:
+    EXPAND SLICE_NEW %out_prefix, %array_ptr, 0
+    EXPAND SLICE_NEW %out_suffix, %array_ptr, 0
+    %out_ok = add 0, 0
+    !__array_rsplit_ref_ok_%out_ok
+
+L_ARRAY_RSPLIT_REF_END_%out_ok:
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_TRY_RSPLIT_ARRAY_REF_U64.
+[MACRO] ARRAY_TRY_RSPLIT_ARRAY_REF %out_ok, %out_prefix, %out_suffix, %array_ptr, %length, %suffix_len
+    EXPAND ARRAY_TRY_RSPLIT_ARRAY_REF_U64 %out_ok, %out_prefix, %out_suffix, %array_ptr, %length, %suffix_len
+[END_MACRO]
+
+[MACRO] ARRAY_TRY_RSPLIT_ARRAY_MUT_U64 %out_ok, %out_prefix, %out_suffix, %array_ptr, %length, %suffix_len
+    EXPAND ARRAY_TRY_RSPLIT_ARRAY_REF_U64 %out_ok, %out_prefix, %out_suffix, %array_ptr, %length, %suffix_len
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_TRY_RSPLIT_ARRAY_MUT_U64.
+[MACRO] ARRAY_TRY_RSPLIT_ARRAY_MUT %out_ok, %out_prefix, %out_suffix, %array_ptr, %length, %suffix_len
+    EXPAND ARRAY_TRY_RSPLIT_ARRAY_MUT_U64 %out_ok, %out_prefix, %out_suffix, %array_ptr, %length, %suffix_len
+[END_MACRO]
+
+[MACRO] ARRAY_TRY_AS_ARRAY_REF_U64 %out_ok, %out_slice, %slice, %length
+    __array_as_ref_len_%out_ok = load %slice+Slice_len as u64
+    __array_as_ref_ok_%out_ok = eq __array_as_ref_len_%out_ok, %length
+    br __array_as_ref_ok_%out_ok -> L_ARRAY_AS_REF_OK_%out_ok, L_ARRAY_AS_REF_MISS_%out_ok
+
+L_ARRAY_AS_REF_OK_%out_ok:
+    __array_as_ref_ptr_%out_ok = load %slice+Slice_ptr as ptr
+    EXPAND SLICE_NEW %out_slice, __array_as_ref_ptr_%out_ok, %length
+    %out_ok = add 0, 1
+    !__array_as_ref_ptr_%out_ok
+    !__array_as_ref_ok_%out_ok
+    !__array_as_ref_len_%out_ok
+    jmp L_ARRAY_AS_REF_END_%out_ok
+
+L_ARRAY_AS_REF_MISS_%out_ok:
+    __array_as_ref_miss_ptr_%out_ok = load %slice+Slice_ptr as ptr
+    EXPAND SLICE_NEW %out_slice, __array_as_ref_miss_ptr_%out_ok, 0
+    %out_ok = add 0, 0
+    !__array_as_ref_miss_ptr_%out_ok
+    !__array_as_ref_ok_%out_ok
+    !__array_as_ref_len_%out_ok
+
+L_ARRAY_AS_REF_END_%out_ok:
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_TRY_AS_ARRAY_REF_U64.
+[MACRO] ARRAY_TRY_AS_ARRAY_REF %out_ok, %out_slice, %slice, %length
+    EXPAND ARRAY_TRY_AS_ARRAY_REF_U64 %out_ok, %out_slice, %slice, %length
+[END_MACRO]
+
+[MACRO] ARRAY_TRY_AS_ARRAY_MUT_U64 %out_ok, %out_slice, %slice, %length
+    EXPAND ARRAY_TRY_AS_ARRAY_REF_U64 %out_ok, %out_slice, %slice, %length
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_TRY_AS_ARRAY_MUT_U64.
+[MACRO] ARRAY_TRY_AS_ARRAY_MUT %out_ok, %out_slice, %slice, %length
+    EXPAND ARRAY_TRY_AS_ARRAY_MUT_U64 %out_ok, %out_slice, %slice, %length
+[END_MACRO]
+
+[MACRO] ARRAY_REF_TRY_FROM_SLICE_U64 %out_ok, %out_slice, %slice, %length
+    EXPAND ARRAY_TRY_AS_ARRAY_REF_U64 %out_ok, %out_slice, %slice, %length
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_REF_TRY_FROM_SLICE_U64.
+[MACRO] ARRAY_REF_TRY_FROM_SLICE %out_ok, %out_slice, %slice, %length
+    EXPAND ARRAY_REF_TRY_FROM_SLICE_U64 %out_ok, %out_slice, %slice, %length
+[END_MACRO]
+
+[MACRO] ARRAY_MUT_REF_TRY_FROM_MUT_SLICE_U64 %out_ok, %out_slice, %slice, %length
+    EXPAND ARRAY_TRY_AS_ARRAY_MUT_U64 %out_ok, %out_slice, %slice, %length
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_MUT_REF_TRY_FROM_MUT_SLICE_U64.
+[MACRO] ARRAY_MUT_REF_TRY_FROM_MUT_SLICE %out_ok, %out_slice, %slice, %length
+    EXPAND ARRAY_MUT_REF_TRY_FROM_MUT_SLICE_U64 %out_ok, %out_slice, %slice, %length
+[END_MACRO]
+
+[MACRO] ARRAY_SWAP_U64 %array_ptr, %left_index, %right_index
+    __array_swap_left_off_%array_ptr = mul %left_index, 8
+    __array_swap_right_off_%array_ptr = mul %right_index, 8
+    __array_swap_left_ptr_%array_ptr = ptr_add %array_ptr, __array_swap_left_off_%array_ptr
+    __array_swap_right_ptr_%array_ptr = ptr_add %array_ptr, __array_swap_right_off_%array_ptr
+    __array_swap_left_value_%array_ptr = load __array_swap_left_ptr_%array_ptr+0 as u64
+    __array_swap_right_value_%array_ptr = load __array_swap_right_ptr_%array_ptr+0 as u64
+    store __array_swap_left_ptr_%array_ptr+0, __array_swap_right_value_%array_ptr as u64
+    store __array_swap_right_ptr_%array_ptr+0, __array_swap_left_value_%array_ptr as u64
+    !__array_swap_right_value_%array_ptr
+    !__array_swap_left_value_%array_ptr
+    !__array_swap_right_ptr_%array_ptr
+    !__array_swap_left_ptr_%array_ptr
+    !__array_swap_right_off_%array_ptr
+    !__array_swap_left_off_%array_ptr
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_SWAP_U64.
+[MACRO] ARRAY_SWAP %array_ptr, %left_index, %right_index
+    EXPAND ARRAY_SWAP_U64 %array_ptr, %left_index, %right_index
+[END_MACRO]
+
+[MACRO] ARRAY_REVERSE_U64 %array_ptr, %length
+    __array_rev_small_%array_ptr = ule %length, 1
+    br __array_rev_small_%array_ptr -> L_ARRAY_REV_DONE_SMALL_%array_ptr, L_ARRAY_REV_INIT_%array_ptr
+
+L_ARRAY_REV_INIT_%array_ptr:
+    __array_rev_left_slot_%array_ptr = stack_alloc 8
+    __array_rev_right_slot_%array_ptr = stack_alloc 8
+    __array_rev_last_%array_ptr = sub %length, 1
+    store __array_rev_left_slot_%array_ptr+0, 0 as u64
+    store __array_rev_right_slot_%array_ptr+0, __array_rev_last_%array_ptr as u64
+    !__array_rev_last_%array_ptr
+    jmp L_ARRAY_REV_HEAD_%array_ptr
+
+L_ARRAY_REV_HEAD_%array_ptr:
+    __array_rev_left_%array_ptr = load __array_rev_left_slot_%array_ptr+0 as u64
+    __array_rev_right_%array_ptr = load __array_rev_right_slot_%array_ptr+0 as u64
+    __array_rev_continue_%array_ptr = ult __array_rev_left_%array_ptr, __array_rev_right_%array_ptr
+    br __array_rev_continue_%array_ptr -> L_ARRAY_REV_BODY_%array_ptr, L_ARRAY_REV_DONE_%array_ptr
+
+L_ARRAY_REV_BODY_%array_ptr:
+    EXPAND ARRAY_SWAP_U64 %array_ptr, __array_rev_left_%array_ptr, __array_rev_right_%array_ptr
+    __array_rev_next_left_%array_ptr = add __array_rev_left_%array_ptr, 1
+    __array_rev_next_right_%array_ptr = sub __array_rev_right_%array_ptr, 1
+    store __array_rev_left_slot_%array_ptr+0, __array_rev_next_left_%array_ptr as u64
+    store __array_rev_right_slot_%array_ptr+0, __array_rev_next_right_%array_ptr as u64
+    !__array_rev_next_right_%array_ptr
+    !__array_rev_next_left_%array_ptr
+    !__array_rev_continue_%array_ptr
+    !__array_rev_right_%array_ptr
+    !__array_rev_left_%array_ptr
+    jmp L_ARRAY_REV_HEAD_%array_ptr
+
+L_ARRAY_REV_DONE_%array_ptr:
+    !__array_rev_continue_%array_ptr
+    !__array_rev_right_%array_ptr
+    !__array_rev_left_%array_ptr
+    !__array_rev_small_%array_ptr
+    jmp L_ARRAY_REV_END_%array_ptr
+
+L_ARRAY_REV_DONE_SMALL_%array_ptr:
+    !__array_rev_small_%array_ptr
+
+L_ARRAY_REV_END_%array_ptr:
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_REVERSE_U64.
+[MACRO] ARRAY_REVERSE %array_ptr, %length
+    EXPAND ARRAY_REVERSE_U64 %array_ptr, %length
+[END_MACRO]
+
+[MACRO] ARRAY_FROM_FN_U64 %array_ptr, %length, %gen_fn
+    __array_fn_idx_slot_%array_ptr = stack_alloc 8
+    store __array_fn_idx_slot_%array_ptr+0, 0 as u64
+    jmp L_ARRAY_FROM_FN_HEAD_%array_ptr
+
+L_ARRAY_FROM_FN_HEAD_%array_ptr:
+    __array_fn_idx_%array_ptr = load __array_fn_idx_slot_%array_ptr+0 as u64
+    __array_fn_done_%array_ptr = eq __array_fn_idx_%array_ptr, %length
+    br __array_fn_done_%array_ptr -> L_ARRAY_FROM_FN_DONE_%array_ptr, L_ARRAY_FROM_FN_BODY_%array_ptr
+
+L_ARRAY_FROM_FN_BODY_%array_ptr:
+    __array_fn_value_%array_ptr = call %gen_fn(__array_fn_idx_%array_ptr)
+    __array_fn_off_%array_ptr = mul __array_fn_idx_%array_ptr, 8
+    __array_fn_ptr_%array_ptr = ptr_add %array_ptr, __array_fn_off_%array_ptr
+    store __array_fn_ptr_%array_ptr+0, __array_fn_value_%array_ptr as u64
+    __array_fn_next_%array_ptr = add __array_fn_idx_%array_ptr, 1
+    store __array_fn_idx_slot_%array_ptr+0, __array_fn_next_%array_ptr as u64
+    !__array_fn_next_%array_ptr
+    !__array_fn_ptr_%array_ptr
+    !__array_fn_off_%array_ptr
+    !__array_fn_value_%array_ptr
+    !__array_fn_done_%array_ptr
+    !__array_fn_idx_%array_ptr
+    jmp L_ARRAY_FROM_FN_HEAD_%array_ptr
+
+L_ARRAY_FROM_FN_DONE_%array_ptr:
+    !__array_fn_done_%array_ptr
+    !__array_fn_idx_%array_ptr
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_FROM_FN_U64.
+[MACRO] ARRAY_FROM_FN %array_ptr, %length, %gen_fn
+    EXPAND ARRAY_FROM_FN_U64 %array_ptr, %length, %gen_fn
+[END_MACRO]
+
+[MACRO] ARRAY_TRY_FROM_FN_U64 %out_ok, %array_ptr, %length, %gen_fn
+    __array_try_fn_idx_slot_%out_ok = stack_alloc 8
+    __array_try_fn_value_slot_%out_ok = stack_alloc 8
+    store __array_try_fn_idx_slot_%out_ok+0, 0 as u64
+    jmp L_ARRAY_TRY_FROM_FN_HEAD_%out_ok
+
+L_ARRAY_TRY_FROM_FN_HEAD_%out_ok:
+    __array_try_fn_idx_%out_ok = load __array_try_fn_idx_slot_%out_ok+0 as u64
+    __array_try_fn_done_%out_ok = eq __array_try_fn_idx_%out_ok, %length
+    br __array_try_fn_done_%out_ok -> L_ARRAY_TRY_FROM_FN_DONE_%out_ok, L_ARRAY_TRY_FROM_FN_BODY_%out_ok
+
+L_ARRAY_TRY_FROM_FN_BODY_%out_ok:
+    __array_try_fn_item_ok_%out_ok = call %gen_fn(__array_try_fn_idx_%out_ok, &__array_try_fn_value_slot_%out_ok)
+    __array_try_fn_keep_%out_ok = ne __array_try_fn_item_ok_%out_ok, 0
+    br __array_try_fn_keep_%out_ok -> L_ARRAY_TRY_FROM_FN_STORE_%out_ok, L_ARRAY_TRY_FROM_FN_FAIL_%out_ok
+
+L_ARRAY_TRY_FROM_FN_STORE_%out_ok:
+    __array_try_fn_value_%out_ok = load __array_try_fn_value_slot_%out_ok+0 as u64
+    __array_try_fn_off_%out_ok = mul __array_try_fn_idx_%out_ok, 8
+    __array_try_fn_ptr_%out_ok = ptr_add %array_ptr, __array_try_fn_off_%out_ok
+    store __array_try_fn_ptr_%out_ok+0, __array_try_fn_value_%out_ok as u64
+    __array_try_fn_next_%out_ok = add __array_try_fn_idx_%out_ok, 1
+    store __array_try_fn_idx_slot_%out_ok+0, __array_try_fn_next_%out_ok as u64
+    !__array_try_fn_next_%out_ok
+    !__array_try_fn_ptr_%out_ok
+    !__array_try_fn_off_%out_ok
+    !__array_try_fn_value_%out_ok
+    !__array_try_fn_keep_%out_ok
+    !__array_try_fn_item_ok_%out_ok
+    !__array_try_fn_done_%out_ok
+    !__array_try_fn_idx_%out_ok
+    jmp L_ARRAY_TRY_FROM_FN_HEAD_%out_ok
+
+L_ARRAY_TRY_FROM_FN_FAIL_%out_ok:
+    %out_ok = add 0, 0
+    !__array_try_fn_keep_%out_ok
+    !__array_try_fn_item_ok_%out_ok
+    !__array_try_fn_done_%out_ok
+    !__array_try_fn_idx_%out_ok
+    jmp L_ARRAY_TRY_FROM_FN_END_%out_ok
+
+L_ARRAY_TRY_FROM_FN_DONE_%out_ok:
+    %out_ok = add 0, 1
+    !__array_try_fn_done_%out_ok
+    !__array_try_fn_idx_%out_ok
+
+L_ARRAY_TRY_FROM_FN_END_%out_ok:
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_TRY_FROM_FN_U64.
+[MACRO] ARRAY_TRY_FROM_FN %out_ok, %array_ptr, %length, %gen_fn
+    EXPAND ARRAY_TRY_FROM_FN_U64 %out_ok, %array_ptr, %length, %gen_fn
+[END_MACRO]
+
+[MACRO] ARRAY_MAP_U64 %dst_ptr, %src_ptr, %length, %map_fn
+    __array_map_idx_slot_%dst_ptr = stack_alloc 8
+    store __array_map_idx_slot_%dst_ptr+0, 0 as u64
+    jmp L_ARRAY_MAP_HEAD_%dst_ptr
+
+L_ARRAY_MAP_HEAD_%dst_ptr:
+    __array_map_idx_%dst_ptr = load __array_map_idx_slot_%dst_ptr+0 as u64
+    __array_map_done_%dst_ptr = eq __array_map_idx_%dst_ptr, %length
+    br __array_map_done_%dst_ptr -> L_ARRAY_MAP_DONE_%dst_ptr, L_ARRAY_MAP_BODY_%dst_ptr
+
+L_ARRAY_MAP_BODY_%dst_ptr:
+    __array_map_off_%dst_ptr = mul __array_map_idx_%dst_ptr, 8
+    __array_map_src_ptr_%dst_ptr = ptr_add %src_ptr, __array_map_off_%dst_ptr
+    __array_map_dst_ptr_%dst_ptr = ptr_add %dst_ptr, __array_map_off_%dst_ptr
+    __array_map_src_value_%dst_ptr = load __array_map_src_ptr_%dst_ptr+0 as u64
+    __array_map_dst_value_%dst_ptr = call %map_fn(__array_map_src_value_%dst_ptr)
+    store __array_map_dst_ptr_%dst_ptr+0, __array_map_dst_value_%dst_ptr as u64
+    __array_map_next_%dst_ptr = add __array_map_idx_%dst_ptr, 1
+    store __array_map_idx_slot_%dst_ptr+0, __array_map_next_%dst_ptr as u64
+    !__array_map_next_%dst_ptr
+    !__array_map_dst_value_%dst_ptr
+    !__array_map_src_value_%dst_ptr
+    !__array_map_dst_ptr_%dst_ptr
+    !__array_map_src_ptr_%dst_ptr
+    !__array_map_off_%dst_ptr
+    !__array_map_done_%dst_ptr
+    !__array_map_idx_%dst_ptr
+    jmp L_ARRAY_MAP_HEAD_%dst_ptr
+
+L_ARRAY_MAP_DONE_%dst_ptr:
+    !__array_map_done_%dst_ptr
+    !__array_map_idx_%dst_ptr
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_MAP_U64.
+[MACRO] ARRAY_MAP %dst_ptr, %src_ptr, %length, %map_fn
+    EXPAND ARRAY_MAP_U64 %dst_ptr, %src_ptr, %length, %map_fn
+[END_MACRO]
+
+[MACRO] ARRAY_TRY_MAP_U64 %out_ok, %dst_ptr, %src_ptr, %length, %map_fn
+    __array_try_map_idx_slot_%out_ok = stack_alloc 8
+    __array_try_map_value_slot_%out_ok = stack_alloc 8
+    store __array_try_map_idx_slot_%out_ok+0, 0 as u64
+    jmp L_ARRAY_TRY_MAP_HEAD_%out_ok
+
+L_ARRAY_TRY_MAP_HEAD_%out_ok:
+    __array_try_map_idx_%out_ok = load __array_try_map_idx_slot_%out_ok+0 as u64
+    __array_try_map_done_%out_ok = eq __array_try_map_idx_%out_ok, %length
+    br __array_try_map_done_%out_ok -> L_ARRAY_TRY_MAP_DONE_%out_ok, L_ARRAY_TRY_MAP_BODY_%out_ok
+
+L_ARRAY_TRY_MAP_BODY_%out_ok:
+    __array_try_map_off_%out_ok = mul __array_try_map_idx_%out_ok, 8
+    __array_try_map_src_ptr_%out_ok = ptr_add %src_ptr, __array_try_map_off_%out_ok
+    __array_try_map_src_value_%out_ok = load __array_try_map_src_ptr_%out_ok+0 as u64
+    __array_try_map_item_ok_%out_ok = call %map_fn(__array_try_map_src_value_%out_ok, &__array_try_map_value_slot_%out_ok)
+    __array_try_map_keep_%out_ok = ne __array_try_map_item_ok_%out_ok, 0
+    br __array_try_map_keep_%out_ok -> L_ARRAY_TRY_MAP_STORE_%out_ok, L_ARRAY_TRY_MAP_FAIL_%out_ok
+
+L_ARRAY_TRY_MAP_STORE_%out_ok:
+    __array_try_map_dst_value_%out_ok = load __array_try_map_value_slot_%out_ok+0 as u64
+    __array_try_map_dst_ptr_%out_ok = ptr_add %dst_ptr, __array_try_map_off_%out_ok
+    store __array_try_map_dst_ptr_%out_ok+0, __array_try_map_dst_value_%out_ok as u64
+    __array_try_map_next_%out_ok = add __array_try_map_idx_%out_ok, 1
+    store __array_try_map_idx_slot_%out_ok+0, __array_try_map_next_%out_ok as u64
+    !__array_try_map_next_%out_ok
+    !__array_try_map_dst_ptr_%out_ok
+    !__array_try_map_dst_value_%out_ok
+    !__array_try_map_keep_%out_ok
+    !__array_try_map_item_ok_%out_ok
+    !__array_try_map_src_value_%out_ok
+    !__array_try_map_src_ptr_%out_ok
+    !__array_try_map_off_%out_ok
+    !__array_try_map_done_%out_ok
+    !__array_try_map_idx_%out_ok
+    jmp L_ARRAY_TRY_MAP_HEAD_%out_ok
+
+L_ARRAY_TRY_MAP_FAIL_%out_ok:
+    %out_ok = add 0, 0
+    !__array_try_map_keep_%out_ok
+    !__array_try_map_item_ok_%out_ok
+    !__array_try_map_src_value_%out_ok
+    !__array_try_map_src_ptr_%out_ok
+    !__array_try_map_off_%out_ok
+    !__array_try_map_done_%out_ok
+    !__array_try_map_idx_%out_ok
+    jmp L_ARRAY_TRY_MAP_END_%out_ok
+
+L_ARRAY_TRY_MAP_DONE_%out_ok:
+    %out_ok = add 0, 1
+    !__array_try_map_done_%out_ok
+    !__array_try_map_idx_%out_ok
+
+L_ARRAY_TRY_MAP_END_%out_ok:
+[END_MACRO]
+
+// Rust method-name alias over ARRAY_TRY_MAP_U64.
+[MACRO] ARRAY_TRY_MAP %out_ok, %dst_ptr, %src_ptr, %length, %map_fn
+    EXPAND ARRAY_TRY_MAP_U64 %out_ok, %dst_ptr, %src_ptr, %length, %map_fn
+[END_MACRO]