bac 0.1.0

// Generated by odin run bac/bindgen. Do not edit.
#![allow(
    non_camel_case_types,
    non_upper_case_globals,
    non_snake_case,
    improper_ctypes,
    clippy::identity_op
)]
pub use crate::FixedCapDynArray;
#[cfg(not(target_endian = "little"))]
compile_error!("BAC Rust bitfield bindings currently require a little-endian target");
#[repr(C)]
#[derive(Clone, Copy)]
pub struct Slice<T> {
    pub data: *mut T,
    pub len: isize,
}
#[repr(C)]
#[derive(Clone, Copy)]
pub struct String {
    pub data: *mut u8,
    pub len: isize,
}
#[repr(C)]
#[derive(Clone, Copy)]
pub struct DynamicArray<T> {
    pub data: *mut T,
    pub len: isize,
    pub cap: isize,
    pub allocator: runtime_Allocator,
}

impl<T> Default for Slice<T> {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
impl Default for String {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
impl<T> Default for DynamicArray<T> {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
unsafe extern "C" {
    pub fn bac_add_always(
        arg0: *mut bac_Proc,
        arg1: String,
        arg2: Slice<bac_Node_ID>,
    ) -> bac_Node_ID;
    pub fn bac_add_bin_op(
        arg0: *mut bac_Proc,
        arg1: String,
        arg2: bac_Bin_Op,
        arg3: bac_Node_Datatype,
        arg4: bac_Node_ID,
        arg5: bac_Node_ID,
        arg6: bac_Lane_Type,
    ) -> bac_Node_ID;
    pub fn bac_add_c_int(
        arg0: *mut bac_Proc,
        arg1: String,
        arg2: bac_Node_Datatype,
        arg3: i64,
    ) -> bac_Node_ID;
    pub fn bac_add_call(
        arg0: *mut bac_Proc,
        arg1: String,
        arg2: Slice<bac_Node_ID>,
        arg3: bac_Call,
    ) -> bac_Node_ID;
    pub fn bac_add_call_end(arg0: *mut bac_Proc, arg1: String, arg2: bac_Node_ID) -> bac_Node_ID;
    pub fn bac_add_copy(
        arg0: *mut bac_Proc,
        arg1: String,
        arg2: bac_Node_ID,
        arg3: bac_Node_ID,
        arg4: bac_Node_ID,
        arg5: bac_Node_ID,
        arg6: bac_Node_ID,
    ) -> bac_Node_ID;
    pub fn bac_add_dbg_scope(
        arg0: *mut bac_Proc,
        arg1: String,
        arg2: Slice<bac_Node_ID>,
    ) -> bac_Node_ID;
    pub fn bac_add_dbg_sym_decl(arg0: *mut bac_Proc, arg1: String) -> bac_Node_ID;
    pub fn bac_add_dbg_sym_update(
        arg0: *mut bac_Proc,
        arg1: String,
        arg2: bac_Node_ID,
        arg3: bac_Node_ID,
    ) -> bac_Node_ID;
    pub fn bac_add_efficiency_stat(
        arg0: *mut bac_Stats,
        arg1: bac_Efficiency_Stat_Kind,
        arg2: isize,
        arg3: isize,
    );
    pub fn bac_add_else(arg0: *mut bac_Proc, arg1: String, arg2: bac_Node_ID) -> bac_Node_ID;
    pub fn bac_add_end(arg0: *mut bac_Proc, arg1: String, arg2: Slice<bac_Node_ID>) -> bac_Node_ID;
    pub fn bac_add_entry(arg0: *mut bac_Proc, arg1: String) -> bac_Node_ID;
    pub fn bac_add_global(arg0: *mut bac_Proc, arg1: String, arg2: u32) -> bac_Node_ID;
    pub fn bac_add_global_addr(arg0: *mut bac_Proc, arg1: String, arg2: bac_Node_ID)
    -> bac_Node_ID;
    pub fn bac_add_if(
        arg0: *mut bac_Proc,
        arg1: String,
        arg2: bac_Node_ID,
        arg3: bac_Node_ID,
    ) -> bac_Node_ID;
    pub fn bac_add_jump(arg0: *mut bac_Proc, arg1: String, arg2: bac_Node_ID) -> bac_Node_ID;
    pub fn bac_add_load(
        arg0: *mut bac_Proc,
        arg1: String,
        arg2: bac_Node_Datatype,
        arg3: bac_Node_ID,
        arg4: bac_Node_ID,
        arg5: bac_Node_ID,
    ) -> bac_Node_ID;
    pub fn bac_add_local(arg0: *mut bac_Proc, arg1: String, arg2: bac_Node_ID) -> bac_Node_ID;
    pub fn bac_add_local_addr(arg0: *mut bac_Proc, arg1: String, arg2: bac_Node_ID) -> bac_Node_ID;
    pub fn bac_add_loop(arg0: *mut bac_Proc, arg1: String, arg2: bac_Node_ID) -> bac_Node_ID;
    pub fn bac_add_mem(arg0: *mut bac_Proc, arg1: String, arg2: bac_Node_ID) -> bac_Node_ID;
    pub fn bac_add_merge_mem(
        arg0: *mut bac_Proc,
        arg1: String,
        arg2: Slice<bac_Node_ID>,
    ) -> bac_Node_ID;
    pub fn bac_add_param(
        arg0: *mut bac_Proc,
        arg1: String,
        arg2: bac_Node_Datatype,
        arg3: bac_Node_ID,
        arg4: u32,
    ) -> bac_Node_ID;
    pub fn bac_add_phi(
        arg0: *mut bac_Proc,
        arg1: String,
        arg2: bac_Node_Datatype,
        arg3: bac_Node_ID,
        arg4: bac_Node_ID,
        arg5: bac_Node_ID,
    ) -> bac_Node_ID;
    pub fn bac_add_poison(arg0: *mut bac_Proc, arg1: String) -> bac_Node_ID;
    pub fn bac_add_proc_addr(arg0: *mut bac_Proc, arg1: String, arg2: u32) -> bac_Node_ID;
    pub fn bac_add_region(
        arg0: *mut bac_Proc,
        arg1: String,
        arg2: Slice<bac_Node_ID>,
    ) -> bac_Node_ID;
    pub fn bac_add_ret(
        arg0: *mut bac_Proc,
        arg1: String,
        arg2: bac_Node_Datatype,
        arg3: bac_Node_ID,
        arg4: u32,
    ) -> bac_Node_ID;
    pub fn bac_add_return(
        arg0: *mut bac_Proc,
        arg1: String,
        arg2: Slice<bac_Node_ID>,
    ) -> bac_Node_ID;
    pub fn bac_add_set(
        arg0: *mut bac_Proc,
        arg1: String,
        arg2: bac_Node_ID,
        arg3: bac_Node_ID,
        arg4: bac_Node_ID,
        arg5: bac_Node_ID,
        arg6: bac_Node_ID,
    ) -> bac_Node_ID;
    pub fn bac_add_split(
        arg0: *mut bac_Proc,
        arg1: String,
        arg2: bac_Node_Datatype,
        arg3: bac_Node_ID,
    ) -> bac_Node_ID;
    pub fn bac_add_split_mem(arg0: *mut bac_Proc, arg1: String, arg2: bac_Node_ID) -> bac_Node_ID;
    pub fn bac_add_store(
        arg0: *mut bac_Proc,
        arg1: String,
        arg2: bac_Node_ID,
        arg3: bac_Node_ID,
        arg4: bac_Node_ID,
        arg5: bac_Node_ID,
    ) -> bac_Node_ID;
    pub fn bac_add_sym(arg0: *mut bac_Proc, arg1: String, arg2: bac_Node_ID) -> bac_Node_ID;
    pub fn bac_add_then(arg0: *mut bac_Proc, arg1: String, arg2: bac_Node_ID) -> bac_Node_ID;
    pub fn bac_add_trap(arg0: *mut bac_Proc, arg1: String, arg2: Slice<bac_Node_ID>)
    -> bac_Node_ID;
    pub fn bac_add_un_op(
        arg0: *mut bac_Proc,
        arg1: String,
        arg2: bac_Un_Op,
        arg3: bac_Node_Datatype,
        arg4: bac_Node_ID,
        arg5: bac_Lane_Type,
    ) -> bac_Node_ID;
    pub fn bac_apply_peep(arg0: *mut bac_Proc, arg1: bac_Node_ID) -> bac_Node_ID;
    pub fn bac_apply_peeps(arg0: bac_Peep_Ctx) -> bool;
    pub fn bac_compact(arg0: *mut bac_Proc);
    pub fn bac_compute_latices(arg0: *mut bac_Proc, arg1: runtime_Allocator) -> bool;
    pub fn bac_connect(arg0: *mut bac_Proc, arg1: bac_Node_ID, arg2: bac_Node_ID) -> isize;
    pub fn bac_delete_node_node(arg0: *mut bac_Proc, arg1: *mut bac_Node);
    pub fn bac_delete_node_node_id(arg0: *mut bac_Proc, arg1: bac_Node_ID);
    pub fn bac_expand_node(arg0: *mut bac_Proc, arg1: bac_Node_ID) -> bac_Expanded_Node;
    pub fn bac_find_node(
        arg0: *mut bac_Proc,
        arg1: bac_Node_Type,
        arg2: bac_Node_ID,
        out0: *mut bac_Node_ID,
    ) -> bool;
    pub fn bac_find_or_create_node(arg0: *mut bac_Proc, arg1: bac_Node_Type) -> bac_Node_ID;
    pub fn bac_get_inputs_node(arg0: *mut bac_Proc, arg1: *mut bac_Node) -> Slice<bac_Node_ID>;
    pub fn bac_get_inputs_node_id(arg0: *mut bac_Proc, arg1: bac_Node_ID) -> Slice<bac_Node_ID>;
    pub fn bac_get_node(arg0: *mut bac_Proc, arg1: bac_Node_ID) -> *mut bac_Node;
    pub fn bac_get_stencil(arg0: *mut bac_Proc) -> bac_Stencil;
    pub fn bac_get_sym_count(arg0: *mut bac_Proc, out0: *mut bac_Node_ID) -> isize;
    pub fn bac_init_custom_fmt();
    pub fn bac_lane_from_dt(arg0: bac_Node_Datatype, out0: *mut bac_Lane_Type) -> bool;
    pub fn bac_mount_stencil(arg0: *mut bac_Proc, arg1: bac_Stencil);
    pub fn bac_pin(arg0: *mut bac_Proc, arg1: bac_Node_ID);
    pub fn bac_schedule_graph(
        arg0: *mut bac_Proc,
        arg1: *mut bac_Schedule,
        arg2: bac_schedule_graph_purpose,
        arg3: runtime_Allocator,
    );
    pub fn bac_schedule_peeps(arg0: *mut bac_Proc, arg1: *mut bac_Schedule);
    pub fn bac_set_input(
        arg0: *mut bac_Proc,
        arg1: bac_Node_ID,
        arg2: isize,
        arg3: bac_Node_ID,
        arg4: bool,
    ) -> bac_Node_ID;
    pub fn bac_set_local_size(arg0: *mut bac_Proc, arg1: bac_Node_ID, arg2: i32);
    pub fn bac_sloc_scope(
        arg0: *mut bac_Proc,
        arg1: bac_Sloc,
        out0: *mut *mut bac_Proc,
    ) -> bac_Sloc;
    pub fn bac_sym_iter_next(
        arg0: *mut bac_Proc,
        arg1: bac_Node_ID,
        arg2: *mut isize,
        out0: *mut bac_Sym_Ref,
    ) -> bool;
    pub fn bac_take_dbg_data(
        arg0: *mut bac_Proc,
        arg1: *mut bac_Schedule,
        arg2: *mut bac_Dbg_Data,
        arg3: runtime_Allocator,
    );
    pub fn bac_unpin(arg0: *mut bac_Proc, arg1: bac_Node_ID, arg2: bool);
    pub static bac_anal_SPEC: bac_Node_Spec;
    pub static bac_arm_CC_TABLE: [bac_Call_Conv; 1];
    pub static bac_arm_SPEC: bac_Node_Spec;
    pub fn bac_regalloc(
        arg0: *mut bac_Regalloc,
        arg1: *mut bac_Proc,
        arg2: *mut bac_Schedule,
        arg3: bac_Regalloc_Mode,
        arg4: runtime_Allocator,
    ) -> bac_Regalloc_Output;
    pub static bac_ssa_SPEC: bac_Node_Spec;
    pub fn bac_add_arbitrary_load(
        arg0: *mut bac_Proc,
        arg1: bac_Node_ID,
        arg2: bac_Node_ID,
        arg3: bac_Node_ID,
        arg4: isize,
        arg5: isize,
        arg6: bac_Node_Datatype,
    ) -> bac_Node_ID;
    pub fn bac_add_arbitrary_store(
        arg0: *mut bac_Proc,
        arg1: bac_Node_ID,
        arg2: bac_Node_ID,
        arg3: bac_Node_ID,
        arg4: bac_Node_ID,
        arg5: isize,
        arg6: isize,
        arg7: bac_Node_Datatype,
    ) -> bac_Node_ID;
    pub fn bac_add_field_load(
        arg0: *mut bac_Proc,
        arg1: String,
        arg2: bac_Node_Datatype,
        arg3: bac_Node_ID,
        arg4: bac_Node_ID,
        arg5: bac_Node_ID,
        arg6: isize,
    ) -> bac_Node_ID;
    pub fn bac_add_field_offset(arg0: *mut bac_Proc, arg1: bac_Node_ID, arg2: isize)
    -> bac_Node_ID;
    pub fn bac_add_field_store(
        arg0: *mut bac_Proc,
        arg1: String,
        arg2: bac_Node_ID,
        arg3: bac_Node_ID,
        arg4: bac_Node_ID,
        arg5: isize,
        arg6: bac_Node_ID,
    ) -> bac_Node_ID;
    pub fn bac_add_lazy_phi(
        arg0: *mut bac_Proc,
        arg1: String,
        arg2: bac_Node_Datatype,
        arg3: bac_Node_ID,
        arg4: bac_Node_ID,
    ) -> bac_Node_ID;
    pub fn bac_add_scope(arg0: *mut bac_Proc, arg1: String, arg2: bac_Node_ID) -> bac_Node_ID;
    pub fn bac_arg_gen_finalize(
        arg0: *mut bac_Proc,
        arg1: *mut bac_ssa_Param_Gen,
    ) -> Slice<bac_Param_Spec>;
    pub fn bac_arg_gen_next(
        arg0: *mut bac_Proc,
        arg1: bac_Node_ID,
        arg2: *mut bac_ssa_Param_Gen,
        arg3: String,
        arg4: *mut bac_ssa_Abi_Param,
        out0: *mut bac_Node_ID,
    ) -> bac_Node_ID;
    pub fn bac_break_block(
        arg0: *mut bac_Proc,
        arg1: *mut bac_Node_ID,
        arg2: *mut bac_ssa_Block_State,
    );
    pub fn bac_compile(arg0: bac_Codegen_Emit_Ctx) -> bac_Codegen_Output;
    pub fn bac_compute_index_offset(
        arg0: *mut bac_Proc,
        arg1: bac_Node_ID,
        arg2: bac_Node_ID,
        arg3: i64,
    ) -> bac_Node_ID;
    pub fn bac_decl_local(arg0: *mut bac_Proc, arg1: bac_Node_ID, arg2: String, arg3: u64);
    pub fn bac_delete_scope(arg0: *mut bac_Proc, arg1: bac_Node_ID);
    pub fn bac_end_block(
        arg0: *mut bac_Proc,
        arg1: *mut bac_Node_ID,
        arg2: *mut bac_ssa_Block_State,
    );
    pub fn bac_end_else(arg0: *mut bac_Proc, arg1: *mut bac_Node_ID, arg2: *mut bac_ssa_If_State);
    pub fn bac_end_if(arg0: *mut bac_Proc, arg1: *mut bac_Node_ID, arg2: *mut bac_ssa_If_State);
    pub fn bac_end_loop(arg0: *mut bac_Proc, arg1: *mut bac_Node_ID, arg2: *mut bac_ssa_Loop_State);
    pub fn bac_get_scope_value(arg0: *mut bac_Proc, arg1: bac_Node_ID, arg2: isize) -> bac_Node_ID;
    pub fn bac_inline_graph(arg0: *mut bac_Proc, arg1: bac_Node_ID, arg2: *mut bac_Proc);
    pub fn bac_inline_stencil(arg0: *mut bac_Proc, arg1: bac_Node_ID, arg2: bac_Stencil);
    pub fn bac_loop_control(
        arg0: bac_ssa_Loop_Control,
        arg1: *mut bac_Proc,
        arg2: bac_Node_ID,
        arg3: *mut bac_ssa_Loop_State,
    );
    pub fn bac_loopopt(arg0: *mut bac_Proc) -> bool;
    pub fn bac_make_call(
        arg0: *mut bac_Proc,
        arg1: Slice<bac_Node_ID>,
        arg2: bac_Call,
        out0: *mut bac_Node_ID,
    ) -> bac_Node_ID;
    pub fn bac_memopt(arg0: *mut bac_Proc) -> bool;
    pub fn bac_merge_returns(arg0: *mut bac_Proc, arg1: Slice<bac_Node_ID>) -> bac_Node_ID;
    pub fn bac_push_scope_value(
        arg0: *mut bac_Proc,
        arg1: bac_Node_ID,
        arg2: bac_Node_ID,
        arg3: String,
        arg4: u64,
    ) -> isize;
    pub fn bac_set_scope_value(
        arg0: *mut bac_Proc,
        arg1: bac_Node_ID,
        arg2: isize,
        arg3: bac_Node_ID,
    );
    pub fn bac_start_block(arg0: *mut bac_ssa_Block_State);
    pub fn bac_start_else(arg0: *mut bac_Proc, arg1: *mut bac_Node_ID, arg2: *mut bac_ssa_If_State);
    pub fn bac_start_if(
        arg0: *mut bac_Proc,
        arg1: bac_Node_ID,
        arg2: *mut bac_ssa_If_State,
        arg3: bac_Node_ID,
    );
    pub fn bac_start_loop(arg0: *mut bac_Proc, arg1: bac_Node_ID, arg2: *mut bac_ssa_Loop_State);
    pub fn bac_start_loop_increment(
        arg0: *mut bac_Proc,
        arg1: *mut bac_Node_ID,
        arg2: *mut bac_ssa_Loop_State,
    );
    pub fn bac_start_proc(
        arg0: *mut bac_Proc,
        arg1: *mut arna_Allocator,
        arg2: *mut arna_Temps,
    ) -> bac_Node_ID;
    pub fn bac_truncate_scope(arg0: *mut bac_Proc, arg1: bac_Node_ID, arg2: isize);
    pub static bac_wasm_CC_TABLE: [bac_Call_Conv; 1];
    pub static bac_wasm_SPEC: bac_Node_Spec;
    pub static bac_x64_CC_TABLE: [bac_Call_Conv; 2];
    pub static bac_x64_SPEC: bac_Node_Spec;
    pub fn arna_init_from_buffer(arg0: Slice<u8>) -> arna_Allocator;
}
pub type bac_ssa_Node_Type = u16;
pub const bac_ssa_Node_Type_Nil: bac_ssa_Node_Type = 0;
pub const bac_ssa_Node_Type_Entry: bac_ssa_Node_Type = 1;
pub const bac_ssa_Node_Type_Then: bac_ssa_Node_Type = 2;
pub const bac_ssa_Node_Type_Else: bac_ssa_Node_Type = 3;
pub const bac_ssa_Node_Type_Region: bac_ssa_Node_Type = 4;
pub const bac_ssa_Node_Type_Loop: bac_ssa_Node_Type = 5;
pub const bac_ssa_Node_Type_Call_End: bac_ssa_Node_Type = 6;
pub const bac_ssa_Node_Type_End: bac_ssa_Node_Type = 7;
pub const bac_ssa_Node_Type_Dbg_Sym_Decl: bac_ssa_Node_Type = 8;
pub const bac_ssa_Node_Type_Dbg_Sym_Update: bac_ssa_Node_Type = 9;
pub const bac_ssa_Node_Type_Dbg_Scope: bac_ssa_Node_Type = 10;
pub const bac_ssa_Node_Type_If: bac_ssa_Node_Type = 11;
pub const bac_ssa_Node_Type_Jump: bac_ssa_Node_Type = 12;
pub const bac_ssa_Node_Type_Trap: bac_ssa_Node_Type = 13;
pub const bac_ssa_Node_Type_Call: bac_ssa_Node_Type = 14;
pub const bac_ssa_Node_Type_Always: bac_ssa_Node_Type = 15;
pub const bac_ssa_Node_Type_Return: bac_ssa_Node_Type = 16;
pub const bac_ssa_Node_Type_Poison: bac_ssa_Node_Type = 17;
pub const bac_ssa_Node_Type_Mem: bac_ssa_Node_Type = 18;
pub const bac_ssa_Node_Type_Split_Mem: bac_ssa_Node_Type = 19;
pub const bac_ssa_Node_Type_Merge_Mem: bac_ssa_Node_Type = 20;
pub const bac_ssa_Node_Type_Sym: bac_ssa_Node_Type = 21;
pub const bac_ssa_Node_Type_Local: bac_ssa_Node_Type = 22;
pub const bac_ssa_Node_Type_Global: bac_ssa_Node_Type = 23;
pub const bac_ssa_Node_Type_Param: bac_ssa_Node_Type = 24;
pub const bac_ssa_Node_Type_Ret: bac_ssa_Node_Type = 25;
pub const bac_ssa_Node_Type_Phi: bac_ssa_Node_Type = 26;
pub const bac_ssa_Node_Type_CInt: bac_ssa_Node_Type = 27;
pub const bac_ssa_Node_Type_Add: bac_ssa_Node_Type = 28;
pub const bac_ssa_Node_Type_Sub: bac_ssa_Node_Type = 29;
pub const bac_ssa_Node_Type_And: bac_ssa_Node_Type = 30;
pub const bac_ssa_Node_Type_Or: bac_ssa_Node_Type = 31;
pub const bac_ssa_Node_Type_Xor: bac_ssa_Node_Type = 32;
pub const bac_ssa_Node_Type_Eq: bac_ssa_Node_Type = 33;
pub const bac_ssa_Node_Type_Ne: bac_ssa_Node_Type = 34;
pub const bac_ssa_Node_Type_Le: bac_ssa_Node_Type = 35;
pub const bac_ssa_Node_Type_Lt: bac_ssa_Node_Type = 36;
pub const bac_ssa_Node_Type_Gt: bac_ssa_Node_Type = 37;
pub const bac_ssa_Node_Type_Ge: bac_ssa_Node_Type = 38;
pub const bac_ssa_Node_Type_U_Lt: bac_ssa_Node_Type = 39;
pub const bac_ssa_Node_Type_U_Gt: bac_ssa_Node_Type = 40;
pub const bac_ssa_Node_Type_U_Le: bac_ssa_Node_Type = 41;
pub const bac_ssa_Node_Type_U_Ge: bac_ssa_Node_Type = 42;
pub const bac_ssa_Node_Type_Shl: bac_ssa_Node_Type = 43;
pub const bac_ssa_Node_Type_Shr: bac_ssa_Node_Type = 44;
pub const bac_ssa_Node_Type_U_Shr: bac_ssa_Node_Type = 45;
pub const bac_ssa_Node_Type_Mul: bac_ssa_Node_Type = 46;
pub const bac_ssa_Node_Type_Div: bac_ssa_Node_Type = 47;
pub const bac_ssa_Node_Type_U_Div: bac_ssa_Node_Type = 48;
pub const bac_ssa_Node_Type_Rem: bac_ssa_Node_Type = 49;
pub const bac_ssa_Node_Type_U_Rem: bac_ssa_Node_Type = 50;
pub const bac_ssa_Node_Type_And_Not: bac_ssa_Node_Type = 51;
pub const bac_ssa_Node_Type_Split: bac_ssa_Node_Type = 52;
pub const bac_ssa_Node_Type_Local_Addr: bac_ssa_Node_Type = 53;
pub const bac_ssa_Node_Type_Global_Addr: bac_ssa_Node_Type = 54;
pub const bac_ssa_Node_Type_Proc_Addr: bac_ssa_Node_Type = 55;
pub const bac_ssa_Node_Type_Copy: bac_ssa_Node_Type = 56;
pub const bac_ssa_Node_Type_Set: bac_ssa_Node_Type = 57;
pub const bac_ssa_Node_Type_Store: bac_ssa_Node_Type = 58;
pub const bac_ssa_Node_Type_Load: bac_ssa_Node_Type = 59;
pub const bac_ssa_Node_Type_Neg: bac_ssa_Node_Type = 60;
pub const bac_ssa_Node_Type_Not: bac_ssa_Node_Type = 61;
pub const bac_ssa_Node_Type_Cast: bac_ssa_Node_Type = 62;
pub const bac_ssa_Node_Type_Conv: bac_ssa_Node_Type = 63;
pub const bac_ssa_Node_Type_U_Conv: bac_ssa_Node_Type = 64;
pub const bac_ssa_Node_Type_Splat: bac_ssa_Node_Type = 65;
pub const bac_ssa_Node_Type_Ctz: bac_ssa_Node_Type = 66;
pub const bac_ssa_Node_Type_Simd_Extract_Lsbs: bac_ssa_Node_Type = 67;
pub const bac_ssa_Node_Type_Simd_Reduce_Add_Bisect: bac_ssa_Node_Type = 68;
pub const bac_ssa_Node_Type_Scope: bac_ssa_Node_Type = 69;
pub const bac_ssa_Node_Type_Lazy_Phi: bac_ssa_Node_Type = 70;
const _: () = assert!(core::mem::size_of::<bac_ssa_Node_Type>() == 2);
const _: () = assert!(core::mem::align_of::<bac_ssa_Node_Type>() == 2);
#[repr(C, align(8))]
#[derive(Clone, Copy)]
pub struct bac_Proc {
    pub r#node_spec: *mut bac_Node_Spec,
    pub r#stats: *mut bac_Stats,
    pub r#worklist: *mut bac_Worklist,
    pub r#triggers: *mut DynamicArray<DynamicArray<bac_Node_ID>>,
    pub r#mem: *mut arna_Allocator,
    pub r#temps: *mut arna_Temps,
    pub r#curret_sloc: bac_Sloc,
    pub r#nil_sloc_slot: bac_Sloc,
    pub r#meta: bac_Proc_Meta,
    pub r#dont_intern: bool,
    pub r#dont_delete: bool,
    pub r#computed_passes: bac_Proc_computed_passes,
    pub r#opt_flags: bac_Proc_opt_flags,
    pub r#lattices: Slice<bac_Lattice>,
}
const _: () = assert!(core::mem::offset_of!(bac_Proc, r#node_spec) == 0);
const _: () = assert!(core::mem::offset_of!(bac_Proc, r#stats) == 8);
const _: () = assert!(core::mem::offset_of!(bac_Proc, r#worklist) == 16);
const _: () = assert!(core::mem::offset_of!(bac_Proc, r#triggers) == 24);
const _: () = assert!(core::mem::offset_of!(bac_Proc, r#mem) == 32);
const _: () = assert!(core::mem::offset_of!(bac_Proc, r#temps) == 40);
const _: () = assert!(core::mem::offset_of!(bac_Proc, r#curret_sloc) == 48);
const _: () = assert!(core::mem::offset_of!(bac_Proc, r#nil_sloc_slot) == 56);
const _: () = assert!(core::mem::offset_of!(bac_Proc, r#meta) == 64);
const _: () = assert!(core::mem::offset_of!(bac_Proc, r#dont_intern) == 160);
const _: () = assert!(core::mem::offset_of!(bac_Proc, r#dont_delete) == 161);
const _: () = assert!(core::mem::offset_of!(bac_Proc, r#computed_passes) == 162);
const _: () = assert!(core::mem::offset_of!(bac_Proc, r#opt_flags) == 163);
const _: () = assert!(core::mem::offset_of!(bac_Proc, r#lattices) == 168);
impl Default for bac_Proc {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
const _: () = assert!(core::mem::size_of::<bac_Proc>() == 184);
const _: () = assert!(core::mem::align_of::<bac_Proc>() == 8);
pub type bac_Node_ID = u32;
const _: () = assert!(core::mem::size_of::<bac_Node_ID>() == 4);
const _: () = assert!(core::mem::align_of::<bac_Node_ID>() == 4);
pub type bac_Bin_Op = u16;
pub const bac_Bin_Op_Shr: bac_Bin_Op = 44;
pub const bac_Bin_Op_And_Not: bac_Bin_Op = 51;
pub const bac_Bin_Op_U_Ge: bac_Bin_Op = 42;
pub const bac_Bin_Op_Eq: bac_Bin_Op = 33;
pub const bac_Bin_Op_Ne: bac_Bin_Op = 34;
pub const bac_Bin_Op_U_Div: bac_Bin_Op = 48;
pub const bac_Bin_Op_Mul: bac_Bin_Op = 46;
pub const bac_Bin_Op_U_Gt: bac_Bin_Op = 40;
pub const bac_Bin_Op_Xor: bac_Bin_Op = 32;
pub const bac_Bin_Op_Ge: bac_Bin_Op = 38;
pub const bac_Bin_Op_Or: bac_Bin_Op = 31;
pub const bac_Bin_Op_Le: bac_Bin_Op = 35;
pub const bac_Bin_Op_Gt: bac_Bin_Op = 37;
pub const bac_Bin_Op_U_Le: bac_Bin_Op = 41;
pub const bac_Bin_Op_U_Shr: bac_Bin_Op = 45;
pub const bac_Bin_Op_U_Lt: bac_Bin_Op = 39;
pub const bac_Bin_Op_Rem: bac_Bin_Op = 49;
pub const bac_Bin_Op_U_Rem: bac_Bin_Op = 50;
pub const bac_Bin_Op_Add: bac_Bin_Op = 28;
pub const bac_Bin_Op_Sub: bac_Bin_Op = 29;
pub const bac_Bin_Op_Div: bac_Bin_Op = 47;
pub const bac_Bin_Op_Shl: bac_Bin_Op = 43;
pub const bac_Bin_Op_And: bac_Bin_Op = 30;
pub const bac_Bin_Op_Lt: bac_Bin_Op = 36;
const _: () = assert!(core::mem::size_of::<bac_Bin_Op>() == 2);
const _: () = assert!(core::mem::align_of::<bac_Bin_Op>() == 2);
pub type bac_Node_Datatype = u8;
pub const bac_Node_Datatype_Void: bac_Node_Datatype = 0;
pub const bac_Node_Datatype_Mem: bac_Node_Datatype = 1;
pub const bac_Node_Datatype_I8: bac_Node_Datatype = 2;
pub const bac_Node_Datatype_I16: bac_Node_Datatype = 3;
pub const bac_Node_Datatype_I32: bac_Node_Datatype = 4;
pub const bac_Node_Datatype_I64: bac_Node_Datatype = 5;
pub const bac_Node_Datatype_F32: bac_Node_Datatype = 6;
pub const bac_Node_Datatype_F64: bac_Node_Datatype = 7;
pub const bac_Node_Datatype_V128: bac_Node_Datatype = 8;
pub const bac_Node_Datatype_V256: bac_Node_Datatype = 9;
pub const bac_Node_Datatype_V512: bac_Node_Datatype = 10;
const _: () = assert!(core::mem::size_of::<bac_Node_Datatype>() == 1);
const _: () = assert!(core::mem::align_of::<bac_Node_Datatype>() == 1);
pub type bac_Lane_Type = u8;
pub const bac_Lane_Type_I8: bac_Lane_Type = 0;
pub const bac_Lane_Type_I16: bac_Lane_Type = 1;
pub const bac_Lane_Type_I32: bac_Lane_Type = 2;
pub const bac_Lane_Type_I64: bac_Lane_Type = 3;
pub const bac_Lane_Type_F32: bac_Lane_Type = 4;
pub const bac_Lane_Type_F64: bac_Lane_Type = 5;
const _: () = assert!(core::mem::size_of::<bac_Lane_Type>() == 1);
const _: () = assert!(core::mem::align_of::<bac_Lane_Type>() == 1);
#[repr(C, align(4))]
#[derive(Clone, Copy)]
pub struct bac_Call {
    pub r#field_0: bac_Cfg,
    pub r#flags: bac_Call_flags,
    pub r#cid: u32,
    pub r#rets: [bac_Node_Datatype; 4],
}
const _: () = assert!(core::mem::offset_of!(bac_Call, r#field_0) == 0);
const _: () = assert!(core::mem::offset_of!(bac_Call, r#flags) == 4);
const _: () = assert!(core::mem::offset_of!(bac_Call, r#cid) == 8);
const _: () = assert!(core::mem::offset_of!(bac_Call, r#rets) == 12);
impl Default for bac_Call {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
const _: () = assert!(core::mem::size_of::<bac_Call>() == 16);
const _: () = assert!(core::mem::align_of::<bac_Call>() == 4);
#[repr(C, align(8))]
#[derive(Clone, Copy)]
pub struct bac_Stats {
    pub r#efficiency: [bac_Efficiency_Stat; 20],
}
const _: () = assert!(core::mem::offset_of!(bac_Stats, r#efficiency) == 0);
impl Default for bac_Stats {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
const _: () = assert!(core::mem::size_of::<bac_Stats>() == 320);
const _: () = assert!(core::mem::align_of::<bac_Stats>() == 8);
pub type bac_Efficiency_Stat_Kind = isize;
pub const bac_Efficiency_Stat_Kind_graph_waste: bac_Efficiency_Stat_Kind = 0;
pub const bac_Efficiency_Stat_Kind_late_schedule_rounds: bac_Efficiency_Stat_Kind = 1;
pub const bac_Efficiency_Stat_Kind_ifg_rounds: bac_Efficiency_Stat_Kind = 2;
pub const bac_Efficiency_Stat_Kind_regalloc_rounds: bac_Efficiency_Stat_Kind = 3;
pub const bac_Efficiency_Stat_Kind_regalloc_memory_overhead: bac_Efficiency_Stat_Kind = 4;
pub const bac_Efficiency_Stat_Kind_regalloc_wasted_lrgs: bac_Efficiency_Stat_Kind = 5;
pub const bac_Efficiency_Stat_Kind_peephole_rounds: bac_Efficiency_Stat_Kind = 6;
pub const bac_Efficiency_Stat_Kind_splits_inserted: bac_Efficiency_Stat_Kind = 7;
pub const bac_Efficiency_Stat_Kind_pressure_splits_inserted: bac_Efficiency_Stat_Kind = 8;
pub const bac_Efficiency_Stat_Kind_fail_count_ratio: bac_Efficiency_Stat_Kind = 9;
pub const bac_Efficiency_Stat_Kind_kill_splits_inserted: bac_Efficiency_Stat_Kind = 10;
pub const bac_Efficiency_Stat_Kind_conflict_splits_inserted: bac_Efficiency_Stat_Kind = 11;
pub const bac_Efficiency_Stat_Kind_clones: bac_Efficiency_Stat_Kind = 12;
pub const bac_Efficiency_Stat_Kind_inlines: bac_Efficiency_Stat_Kind = 13;
pub const bac_Efficiency_Stat_Kind_duplicated_nodes: bac_Efficiency_Stat_Kind = 14;
pub const bac_Efficiency_Stat_Kind_deleted_nodes: bac_Efficiency_Stat_Kind = 15;
pub const bac_Efficiency_Stat_Kind_immediate_deletes: bac_Efficiency_Stat_Kind = 16;
pub const bac_Efficiency_Stat_Kind_redundant_peep: bac_Efficiency_Stat_Kind = 17;
pub const bac_Efficiency_Stat_Kind_sroad_locals: bac_Efficiency_Stat_Kind = 18;
pub const bac_Efficiency_Stat_Kind_sroa_slot_mismatch: bac_Efficiency_Stat_Kind = 19;
const _: () = assert!(core::mem::size_of::<bac_Efficiency_Stat_Kind>() == 8);
const _: () = assert!(core::mem::align_of::<bac_Efficiency_Stat_Kind>() == 8);
pub type bac_Un_Op = u16;
pub const bac_Un_Op_Cast: bac_Un_Op = 62;
pub const bac_Un_Op_Neg: bac_Un_Op = 60;
pub const bac_Un_Op_Simd_Extract_Lsbs: bac_Un_Op = 67;
pub const bac_Un_Op_Simd_Reduce_Add_Bisect: bac_Un_Op = 68;
pub const bac_Un_Op_U_Conv: bac_Un_Op = 64;
pub const bac_Un_Op_Splat: bac_Un_Op = 65;
pub const bac_Un_Op_Not: bac_Un_Op = 61;
pub const bac_Un_Op_Ctz: bac_Un_Op = 66;
pub const bac_Un_Op_Conv: bac_Un_Op = 63;
const _: () = assert!(core::mem::size_of::<bac_Un_Op>() == 2);
const _: () = assert!(core::mem::align_of::<bac_Un_Op>() == 2);
#[repr(C, align(8))]
#[derive(Clone, Copy)]
pub struct bac_Peep_Ctx {
    pub r#prc: *mut bac_Proc,
}
const _: () = assert!(core::mem::offset_of!(bac_Peep_Ctx, r#prc) == 0);
impl Default for bac_Peep_Ctx {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
const _: () = assert!(core::mem::size_of::<bac_Peep_Ctx>() == 8);
const _: () = assert!(core::mem::align_of::<bac_Peep_Ctx>() == 8);
#[repr(C, align(8))]
#[derive(Clone, Copy)]
pub struct runtime_Allocator {
    pub r#procedure: runtime_Allocator_Proc,
    pub r#data: *mut core::ffi::c_void,
}
const _: () = assert!(core::mem::offset_of!(runtime_Allocator, r#procedure) == 0);
const _: () = assert!(core::mem::offset_of!(runtime_Allocator, r#data) == 8);
impl Default for runtime_Allocator {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
const _: () = assert!(core::mem::size_of::<runtime_Allocator>() == 16);
const _: () = assert!(core::mem::align_of::<runtime_Allocator>() == 8);
#[repr(C, align(4))]
#[derive(Clone, Copy)]
pub struct bac_Node {
    pub r#tag: bac_Tag,
    pub r#spec: bac_Node_spec,
    pub r#gvn_group: bac_Node_gvn_group,
    pub r#input_idx: u32,
    pub r#input_count: u16,
    pub r#input_cap: u16,
    pub r#output_idx: u32,
    pub r#output_count: u16,
    pub r#output_cap: u16,
    pub r#extra: [u32; 0],
}
const _: () = assert!(core::mem::offset_of!(bac_Node, r#tag) == 0);
const _: () = assert!(core::mem::offset_of!(bac_Node, r#spec) == 20);
const _: () = assert!(core::mem::offset_of!(bac_Node, r#gvn_group) == 24);
const _: () = assert!(core::mem::offset_of!(bac_Node, r#input_idx) == 28);
const _: () = assert!(core::mem::offset_of!(bac_Node, r#input_count) == 32);
const _: () = assert!(core::mem::offset_of!(bac_Node, r#input_cap) == 34);
const _: () = assert!(core::mem::offset_of!(bac_Node, r#output_idx) == 36);
const _: () = assert!(core::mem::offset_of!(bac_Node, r#output_count) == 40);
const _: () = assert!(core::mem::offset_of!(bac_Node, r#output_cap) == 42);
const _: () = assert!(core::mem::offset_of!(bac_Node, r#extra) == 44);
impl Default for bac_Node {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
const _: () = assert!(core::mem::size_of::<bac_Node>() == 44);
const _: () = assert!(core::mem::align_of::<bac_Node>() == 4);
#[repr(C, align(8))]
#[derive(Clone, Copy)]
pub struct bac_Expanded_Node {
    pub r#node: *mut bac_Node,
    pub r#inps: Slice<bac_Node_ID>,
    pub r#outs: Slice<bac_Node_Output>,
}
const _: () = assert!(core::mem::offset_of!(bac_Expanded_Node, r#node) == 0);
const _: () = assert!(core::mem::offset_of!(bac_Expanded_Node, r#inps) == 8);
const _: () = assert!(core::mem::offset_of!(bac_Expanded_Node, r#outs) == 24);
impl Default for bac_Expanded_Node {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
const _: () = assert!(core::mem::size_of::<bac_Expanded_Node>() == 40);
const _: () = assert!(core::mem::align_of::<bac_Expanded_Node>() == 8);
pub type bac_Node_Type = u16;
pub const bac_Node_Type_Nil: bac_Node_Type = 0;
pub const bac_Node_Type_Entry: bac_Node_Type = 1;
pub const bac_Node_Type_Then: bac_Node_Type = 2;
pub const bac_Node_Type_Else: bac_Node_Type = 3;
pub const bac_Node_Type_Region: bac_Node_Type = 4;
pub const bac_Node_Type_Loop: bac_Node_Type = 5;
pub const bac_Node_Type_Call_End: bac_Node_Type = 6;
pub const bac_Node_Type_End: bac_Node_Type = 7;
pub const bac_Node_Type_Dbg_Sym_Decl: bac_Node_Type = 8;
pub const bac_Node_Type_Dbg_Sym_Update: bac_Node_Type = 9;
pub const bac_Node_Type_Dbg_Scope: bac_Node_Type = 10;
pub const bac_Node_Type_If: bac_Node_Type = 11;
pub const bac_Node_Type_Jump: bac_Node_Type = 12;
pub const bac_Node_Type_Trap: bac_Node_Type = 13;
pub const bac_Node_Type_Call: bac_Node_Type = 14;
pub const bac_Node_Type_Always: bac_Node_Type = 15;
pub const bac_Node_Type_Return: bac_Node_Type = 16;
pub const bac_Node_Type_Poison: bac_Node_Type = 17;
pub const bac_Node_Type_Mem: bac_Node_Type = 18;
pub const bac_Node_Type_Split_Mem: bac_Node_Type = 19;
pub const bac_Node_Type_Merge_Mem: bac_Node_Type = 20;
pub const bac_Node_Type_Sym: bac_Node_Type = 21;
pub const bac_Node_Type_Local: bac_Node_Type = 22;
pub const bac_Node_Type_Global: bac_Node_Type = 23;
pub const bac_Node_Type_Param: bac_Node_Type = 24;
pub const bac_Node_Type_Ret: bac_Node_Type = 25;
pub const bac_Node_Type_Phi: bac_Node_Type = 26;
pub const bac_Node_Type_CInt: bac_Node_Type = 27;
pub const bac_Node_Type_Add: bac_Node_Type = 28;
pub const bac_Node_Type_Sub: bac_Node_Type = 29;
pub const bac_Node_Type_And: bac_Node_Type = 30;
pub const bac_Node_Type_Or: bac_Node_Type = 31;
pub const bac_Node_Type_Xor: bac_Node_Type = 32;
pub const bac_Node_Type_Eq: bac_Node_Type = 33;
pub const bac_Node_Type_Ne: bac_Node_Type = 34;
pub const bac_Node_Type_Le: bac_Node_Type = 35;
pub const bac_Node_Type_Lt: bac_Node_Type = 36;
pub const bac_Node_Type_Gt: bac_Node_Type = 37;
pub const bac_Node_Type_Ge: bac_Node_Type = 38;
pub const bac_Node_Type_U_Lt: bac_Node_Type = 39;
pub const bac_Node_Type_U_Gt: bac_Node_Type = 40;
pub const bac_Node_Type_U_Le: bac_Node_Type = 41;
pub const bac_Node_Type_U_Ge: bac_Node_Type = 42;
pub const bac_Node_Type_Shl: bac_Node_Type = 43;
pub const bac_Node_Type_Shr: bac_Node_Type = 44;
pub const bac_Node_Type_U_Shr: bac_Node_Type = 45;
pub const bac_Node_Type_Mul: bac_Node_Type = 46;
pub const bac_Node_Type_Div: bac_Node_Type = 47;
pub const bac_Node_Type_U_Div: bac_Node_Type = 48;
pub const bac_Node_Type_Rem: bac_Node_Type = 49;
pub const bac_Node_Type_U_Rem: bac_Node_Type = 50;
pub const bac_Node_Type_And_Not: bac_Node_Type = 51;
pub const bac_Node_Type_Split: bac_Node_Type = 52;
pub const bac_Node_Type_Local_Addr: bac_Node_Type = 53;
pub const bac_Node_Type_Global_Addr: bac_Node_Type = 54;
pub const bac_Node_Type_Proc_Addr: bac_Node_Type = 55;
pub const bac_Node_Type_Copy: bac_Node_Type = 56;
pub const bac_Node_Type_Set: bac_Node_Type = 57;
pub const bac_Node_Type_Store: bac_Node_Type = 58;
pub const bac_Node_Type_Load: bac_Node_Type = 59;
pub const bac_Node_Type_Neg: bac_Node_Type = 60;
pub const bac_Node_Type_Not: bac_Node_Type = 61;
pub const bac_Node_Type_Cast: bac_Node_Type = 62;
pub const bac_Node_Type_Conv: bac_Node_Type = 63;
pub const bac_Node_Type_U_Conv: bac_Node_Type = 64;
pub const bac_Node_Type_Splat: bac_Node_Type = 65;
pub const bac_Node_Type_Ctz: bac_Node_Type = 66;
pub const bac_Node_Type_Simd_Extract_Lsbs: bac_Node_Type = 67;
pub const bac_Node_Type_Simd_Reduce_Add_Bisect: bac_Node_Type = 68;
const _: () = assert!(core::mem::size_of::<bac_Node_Type>() == 2);
const _: () = assert!(core::mem::align_of::<bac_Node_Type>() == 2);
#[repr(C, align(8))]
#[derive(Clone, Copy)]
pub struct bac_Stencil {
    pub r#mem: Slice<u8>,
    pub r#meta: bac_Proc_Meta,
}
const _: () = assert!(core::mem::offset_of!(bac_Stencil, r#mem) == 0);
const _: () = assert!(core::mem::offset_of!(bac_Stencil, r#meta) == 16);
impl Default for bac_Stencil {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
const _: () = assert!(core::mem::size_of::<bac_Stencil>() == 112);
const _: () = assert!(core::mem::align_of::<bac_Stencil>() == 8);
#[repr(C, align(8))]
#[derive(Clone, Copy)]
pub struct bac_Schedule {
    pub r#bbs: DynamicArray<bac_Basic_Block>,
}
const _: () = assert!(core::mem::offset_of!(bac_Schedule, r#bbs) == 0);
impl Default for bac_Schedule {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
const _: () = assert!(core::mem::size_of::<bac_Schedule>() == 40);
const _: () = assert!(core::mem::align_of::<bac_Schedule>() == 8);
pub type bac_schedule_graph_purpose = isize;
pub const bac_schedule_graph_purpose_for_regalloc: bac_schedule_graph_purpose = 0;
pub const bac_schedule_graph_purpose_for_loopopt: bac_schedule_graph_purpose = 1;
const _: () = assert!(core::mem::size_of::<bac_schedule_graph_purpose>() == 8);
const _: () = assert!(core::mem::align_of::<bac_schedule_graph_purpose>() == 8);
#[repr(C, align(4))]
#[derive(Clone, Copy)]
pub struct bac_Sloc {
    pub bytes: [u8; 8],
}
impl bac_Sloc {
    pub fn r#file(self) -> u64 {
        let mut b = [0; 8];
        b[..8].copy_from_slice(&self.bytes);
        (u64::from_le_bytes(b) >> 0) & 1048575
    }
    pub fn set_file(&mut self, value: u64) {
        assert!(value <= 1048575);
        let mut b = [0; 8];
        b[..8].copy_from_slice(&self.bytes);
        let bits = (u64::from_le_bytes(b) & !(1048575u64 << 0)) | (value << 0);
        self.bytes.copy_from_slice(&bits.to_le_bytes()[..8]);
    }
    pub fn r#line(self) -> u64 {
        let mut b = [0; 8];
        b[..8].copy_from_slice(&self.bytes);
        (u64::from_le_bytes(b) >> 20) & 1048575
    }
    pub fn set_line(&mut self, value: u64) {
        assert!(value <= 1048575);
        let mut b = [0; 8];
        b[..8].copy_from_slice(&self.bytes);
        let bits = (u64::from_le_bytes(b) & !(1048575u64 << 20)) | (value << 20);
        self.bytes.copy_from_slice(&bits.to_le_bytes()[..8]);
    }
    pub fn r#col(self) -> u64 {
        let mut b = [0; 8];
        b[..8].copy_from_slice(&self.bytes);
        (u64::from_le_bytes(b) >> 40) & 65535
    }
    pub fn set_col(&mut self, value: u64) {
        assert!(value <= 65535);
        let mut b = [0; 8];
        b[..8].copy_from_slice(&self.bytes);
        let bits = (u64::from_le_bytes(b) & !(65535u64 << 40)) | (value << 40);
        self.bytes.copy_from_slice(&bits.to_le_bytes()[..8]);
    }
    pub fn r#range(self) -> u64 {
        let mut b = [0; 8];
        b[..8].copy_from_slice(&self.bytes);
        (u64::from_le_bytes(b) >> 56) & 255
    }
    pub fn set_range(&mut self, value: u64) {
        assert!(value <= 255);
        let mut b = [0; 8];
        b[..8].copy_from_slice(&self.bytes);
        let bits = (u64::from_le_bytes(b) & !(255u64 << 56)) | (value << 56);
        self.bytes.copy_from_slice(&bits.to_le_bytes()[..8]);
    }
}
impl Default for bac_Sloc {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
const _: () = assert!(core::mem::size_of::<bac_Sloc>() == 8);
const _: () = assert!(core::mem::align_of::<bac_Sloc>() == 4);
#[repr(C, align(4))]
#[derive(Clone, Copy)]
pub struct bac_Sym_Ref {
    pub r#type: bac_Sym_Ref_Type,
    pub r#id: u32,
    pub r#node: bac_Node_ID,
}
const _: () = assert!(core::mem::offset_of!(bac_Sym_Ref, r#type) == 0);
const _: () = assert!(core::mem::offset_of!(bac_Sym_Ref, r#id) == 4);
const _: () = assert!(core::mem::offset_of!(bac_Sym_Ref, r#node) == 8);
impl Default for bac_Sym_Ref {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
const _: () = assert!(core::mem::size_of::<bac_Sym_Ref>() == 12);
const _: () = assert!(core::mem::align_of::<bac_Sym_Ref>() == 4);
#[repr(C, align(8))]
#[derive(Clone, Copy)]
pub struct bac_Dbg_Data {
    pub r#syms: DynamicArray<bac_Dbg_Data_Sym>,
}
const _: () = assert!(core::mem::offset_of!(bac_Dbg_Data, r#syms) == 0);
impl Default for bac_Dbg_Data {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
const _: () = assert!(core::mem::size_of::<bac_Dbg_Data>() == 40);
const _: () = assert!(core::mem::align_of::<bac_Dbg_Data>() == 8);
#[repr(C, align(8))]
#[derive(Clone, Copy)]
pub struct bac_Node_Spec {
    pub r#node_extra_sizes: Slice<u8>,
    pub r#inheritance_table: Slice<u16>,
    pub r#node_flags: Slice<bac_Node_Spec_node_flags>,
    pub r#node_extra_types: Slice<usize>,
    pub r#node_kind: usize,
    pub r#regalloc: bac_Regalloc_Spec,
    pub r#codegen: bac_Codegen_Spec,
}
const _: () = assert!(core::mem::offset_of!(bac_Node_Spec, r#node_extra_sizes) == 0);
const _: () = assert!(core::mem::offset_of!(bac_Node_Spec, r#inheritance_table) == 16);
const _: () = assert!(core::mem::offset_of!(bac_Node_Spec, r#node_flags) == 32);
const _: () = assert!(core::mem::offset_of!(bac_Node_Spec, r#node_extra_types) == 48);
const _: () = assert!(core::mem::offset_of!(bac_Node_Spec, r#node_kind) == 64);
const _: () = assert!(core::mem::offset_of!(bac_Node_Spec, r#regalloc) == 72);
const _: () = assert!(core::mem::offset_of!(bac_Node_Spec, r#codegen) == 136);
impl Default for bac_Node_Spec {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
const _: () = assert!(core::mem::size_of::<bac_Node_Spec>() == 176);
const _: () = assert!(core::mem::align_of::<bac_Node_Spec>() == 8);
#[repr(C, align(8))]
#[derive(Clone, Copy)]
pub struct bac_Call_Conv {
    pub r#callee_saved: Slice<Slice<bac_Reg>>,
    pub r#caller_saved: Slice<Slice<bac_Reg>>,
    pub r#args: Slice<Slice<bac_Reg>>,
    pub r#rets: Slice<Slice<bac_Reg>>,
    pub r#red_zone_size: i32,
    pub r#is_syscall: bool,
    pub r#cfi_spec: bac_Cfi_Spec,
    pub r#stack_pointer: bac_Reg,
}
const _: () = assert!(core::mem::offset_of!(bac_Call_Conv, r#callee_saved) == 0);
const _: () = assert!(core::mem::offset_of!(bac_Call_Conv, r#caller_saved) == 16);
const _: () = assert!(core::mem::offset_of!(bac_Call_Conv, r#args) == 32);
const _: () = assert!(core::mem::offset_of!(bac_Call_Conv, r#rets) == 48);
const _: () = assert!(core::mem::offset_of!(bac_Call_Conv, r#red_zone_size) == 64);
const _: () = assert!(core::mem::offset_of!(bac_Call_Conv, r#is_syscall) == 68);
const _: () = assert!(core::mem::offset_of!(bac_Call_Conv, r#cfi_spec) == 72);
const _: () = assert!(core::mem::offset_of!(bac_Call_Conv, r#stack_pointer) == 88);
impl Default for bac_Call_Conv {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
const _: () = assert!(core::mem::size_of::<bac_Call_Conv>() == 96);
const _: () = assert!(core::mem::align_of::<bac_Call_Conv>() == 8);
#[repr(C, align(8))]
#[derive(Clone, Copy)]
pub struct bac_Regalloc {
    pub r#spec: *mut bac_Regalloc_Spec,
    pub r#cc: *mut bac_Call_Conv,
    pub r#rms: bac_RM_Interner,
    pub r#param_specs: Slice<bac_Param_Spec>,
}
const _: () = assert!(core::mem::offset_of!(bac_Regalloc, r#spec) == 0);
const _: () = assert!(core::mem::offset_of!(bac_Regalloc, r#cc) == 8);
const _: () = assert!(core::mem::offset_of!(bac_Regalloc, r#rms) == 16);
const _: () = assert!(core::mem::offset_of!(bac_Regalloc, r#param_specs) == 56);
impl Default for bac_Regalloc {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
const _: () = assert!(core::mem::size_of::<bac_Regalloc>() == 72);
const _: () = assert!(core::mem::align_of::<bac_Regalloc>() == 8);
pub type bac_Regalloc_Mode = isize;
pub const bac_Regalloc_Mode_with_scan: bac_Regalloc_Mode = 0;
pub const bac_Regalloc_Mode_with_coloring: bac_Regalloc_Mode = 1;
const _: () = assert!(core::mem::size_of::<bac_Regalloc_Mode>() == 8);
const _: () = assert!(core::mem::align_of::<bac_Regalloc_Mode>() == 8);
#[repr(C, align(8))]
#[derive(Clone, Copy)]
pub struct bac_Regalloc_Output {
    pub r#allocs: Slice<bac_Reg>,
    pub r#temp_stack_slot: bac_Reg_Kind,
    pub r#computed: bool,
}
const _: () = assert!(core::mem::offset_of!(bac_Regalloc_Output, r#allocs) == 0);
const _: () = assert!(core::mem::offset_of!(bac_Regalloc_Output, r#temp_stack_slot) == 16);
const _: () = assert!(core::mem::offset_of!(bac_Regalloc_Output, r#computed) == 18);
impl Default for bac_Regalloc_Output {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
const _: () = assert!(core::mem::size_of::<bac_Regalloc_Output>() == 24);
const _: () = assert!(core::mem::align_of::<bac_Regalloc_Output>() == 8);
#[repr(C, align(8))]
#[derive(Clone, Copy)]
pub struct bac_ssa_Param_Gen {
    pub r#vls: DynamicArray<bac_Node_ID>,
    pub r#spill_start: isize,
}
const _: () = assert!(core::mem::offset_of!(bac_ssa_Param_Gen, r#vls) == 0);
const _: () = assert!(core::mem::offset_of!(bac_ssa_Param_Gen, r#spill_start) == 40);
impl Default for bac_ssa_Param_Gen {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
const _: () = assert!(core::mem::size_of::<bac_ssa_Param_Gen>() == 48);
const _: () = assert!(core::mem::align_of::<bac_ssa_Param_Gen>() == 8);
#[repr(C, align(4))]
#[derive(Clone, Copy)]
pub struct bac_Param_Spec {
    pub r#dt: bac_Node_Datatype,
    pub r#size: i32,
}
const _: () = assert!(core::mem::offset_of!(bac_Param_Spec, r#dt) == 0);
const _: () = assert!(core::mem::offset_of!(bac_Param_Spec, r#size) == 4);
impl Default for bac_Param_Spec {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
const _: () = assert!(core::mem::size_of::<bac_Param_Spec>() == 8);
const _: () = assert!(core::mem::align_of::<bac_Param_Spec>() == 4);
#[repr(C, align(8))]
#[derive(Clone, Copy)]
pub struct bac_ssa_Abi_Param {
    pub r#dt: FixedCapDynArray<2, bac_Node_Datatype>,
    pub r#size: isize,
    pub r#real_size: isize,
    pub r#spilled: bool,
    pub r#scalar: bool,
    pub r#copied: bool,
}
const _: () = assert!(core::mem::offset_of!(bac_ssa_Abi_Param, r#dt) == 0);
const _: () = assert!(core::mem::offset_of!(bac_ssa_Abi_Param, r#size) == 16);
const _: () = assert!(core::mem::offset_of!(bac_ssa_Abi_Param, r#real_size) == 24);
const _: () = assert!(core::mem::offset_of!(bac_ssa_Abi_Param, r#spilled) == 32);
const _: () = assert!(core::mem::offset_of!(bac_ssa_Abi_Param, r#scalar) == 33);
const _: () = assert!(core::mem::offset_of!(bac_ssa_Abi_Param, r#copied) == 34);
impl Default for bac_ssa_Abi_Param {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
const _: () = assert!(core::mem::size_of::<bac_ssa_Abi_Param>() == 40);
const _: () = assert!(core::mem::align_of::<bac_ssa_Abi_Param>() == 8);
#[repr(C, align(4))]
#[derive(Clone, Copy)]
pub struct bac_ssa_Block_State {
    pub r#end_scope: bac_Node_ID,
}
const _: () = assert!(core::mem::offset_of!(bac_ssa_Block_State, r#end_scope) == 0);
impl Default for bac_ssa_Block_State {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
const _: () = assert!(core::mem::size_of::<bac_ssa_Block_State>() == 4);
const _: () = assert!(core::mem::align_of::<bac_ssa_Block_State>() == 4);
#[repr(C, align(8))]
#[derive(Clone, Copy)]
pub struct bac_Codegen_Emit_Ctx {
    pub r#prc: *mut bac_Proc,
    pub r#schedule: *mut bac_Schedule,
    pub r#dbg_data: *mut bac_Dbg_Data,
    pub r#abi: *mut bac_Call_Conv,
    pub r#buf: bac_Codegen_Emit_Buf,
    pub r#emit_got_imports: bool,
    pub r#lib_calls: bac_Lib_Calls,
    pub r#regalloc_mode: bac_Regalloc_Mode,
    pub r#ra_out: bac_Regalloc_Output,
    pub r#param_specs: Slice<bac_Param_Spec>,
    pub r#stack_param_offset: Slice<DynamicArray<i32>>,
    pub r#spill_slot_base: Slice<i32>,
    pub r#spill_slot_size: Slice<i32>,
    pub r#instr_offsets: Slice<u32>,
    pub r#code_start: usize,
    pub r#constants_start: usize,
    pub r#last_off: usize,
    pub r#sloc: bac_Sloc,
}
const _: () = assert!(core::mem::offset_of!(bac_Codegen_Emit_Ctx, r#prc) == 0);
const _: () = assert!(core::mem::offset_of!(bac_Codegen_Emit_Ctx, r#schedule) == 8);
const _: () = assert!(core::mem::offset_of!(bac_Codegen_Emit_Ctx, r#dbg_data) == 16);
const _: () = assert!(core::mem::offset_of!(bac_Codegen_Emit_Ctx, r#abi) == 24);
const _: () = assert!(core::mem::offset_of!(bac_Codegen_Emit_Ctx, r#buf) == 32);
const _: () = assert!(core::mem::offset_of!(bac_Codegen_Emit_Ctx, r#emit_got_imports) == 80);
const _: () = assert!(core::mem::offset_of!(bac_Codegen_Emit_Ctx, r#lib_calls) == 84);
const _: () = assert!(core::mem::offset_of!(bac_Codegen_Emit_Ctx, r#regalloc_mode) == 96);
const _: () = assert!(core::mem::offset_of!(bac_Codegen_Emit_Ctx, r#ra_out) == 104);
const _: () = assert!(core::mem::offset_of!(bac_Codegen_Emit_Ctx, r#param_specs) == 128);
const _: () = assert!(core::mem::offset_of!(bac_Codegen_Emit_Ctx, r#stack_param_offset) == 144);
const _: () = assert!(core::mem::offset_of!(bac_Codegen_Emit_Ctx, r#spill_slot_base) == 160);
const _: () = assert!(core::mem::offset_of!(bac_Codegen_Emit_Ctx, r#spill_slot_size) == 176);
const _: () = assert!(core::mem::offset_of!(bac_Codegen_Emit_Ctx, r#instr_offsets) == 192);
const _: () = assert!(core::mem::offset_of!(bac_Codegen_Emit_Ctx, r#code_start) == 208);
const _: () = assert!(core::mem::offset_of!(bac_Codegen_Emit_Ctx, r#constants_start) == 216);
const _: () = assert!(core::mem::offset_of!(bac_Codegen_Emit_Ctx, r#last_off) == 224);
const _: () = assert!(core::mem::offset_of!(bac_Codegen_Emit_Ctx, r#sloc) == 232);
impl Default for bac_Codegen_Emit_Ctx {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
const _: () = assert!(core::mem::size_of::<bac_Codegen_Emit_Ctx>() == 240);
const _: () = assert!(core::mem::align_of::<bac_Codegen_Emit_Ctx>() == 8);
#[repr(C, align(8))]
#[derive(Clone, Copy)]
pub struct bac_Codegen_Output {
    pub r#emit: bac_Codegen_Emit_Output,
    pub r#bufs: bac_Codegen_Output_Bufs,
}
const _: () = assert!(core::mem::offset_of!(bac_Codegen_Output, r#emit) == 0);
const _: () = assert!(core::mem::offset_of!(bac_Codegen_Output, r#bufs) == 0);
impl Default for bac_Codegen_Output {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
const _: () = assert!(core::mem::size_of::<bac_Codegen_Output>() == 96);
const _: () = assert!(core::mem::align_of::<bac_Codegen_Output>() == 8);
#[repr(C, align(4))]
#[derive(Clone, Copy)]
pub struct bac_ssa_If_State {
    pub r#if_: bac_Node_ID,
    pub r#branch: bac_ssa_If_State_branch,
}
const _: () = assert!(core::mem::offset_of!(bac_ssa_If_State, r#if_) == 0);
const _: () = assert!(core::mem::offset_of!(bac_ssa_If_State, r#branch) == 4);
impl Default for bac_ssa_If_State {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
const _: () = assert!(core::mem::size_of::<bac_ssa_If_State>() == 8);
const _: () = assert!(core::mem::align_of::<bac_ssa_If_State>() == 4);
#[repr(C, align(4))]
#[derive(Clone, Copy)]
pub struct bac_ssa_Loop_State {
    pub r#scope: bac_Node_ID,
    pub r#scopes: [bac_Node_ID; 2],
}
const _: () = assert!(core::mem::offset_of!(bac_ssa_Loop_State, r#scope) == 0);
const _: () = assert!(core::mem::offset_of!(bac_ssa_Loop_State, r#scopes) == 4);
impl Default for bac_ssa_Loop_State {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
const _: () = assert!(core::mem::size_of::<bac_ssa_Loop_State>() == 12);
const _: () = assert!(core::mem::align_of::<bac_ssa_Loop_State>() == 4);
pub type bac_ssa_Loop_Control = isize;
pub const bac_ssa_Loop_Control_Break: bac_ssa_Loop_Control = 0;
pub const bac_ssa_Loop_Control_Continue: bac_ssa_Loop_Control = 1;
const _: () = assert!(core::mem::size_of::<bac_ssa_Loop_Control>() == 8);
const _: () = assert!(core::mem::align_of::<bac_ssa_Loop_Control>() == 8);
#[repr(C, align(8))]
#[derive(Clone, Copy)]
pub struct arna_Allocator {
    pub r#ptr: *mut u8,
    pub r#pos: usize,
    pub r#commited: usize,
    pub r#reserved: usize,
}
const _: () = assert!(core::mem::offset_of!(arna_Allocator, r#ptr) == 0);
const _: () = assert!(core::mem::offset_of!(arna_Allocator, r#pos) == 8);
const _: () = assert!(core::mem::offset_of!(arna_Allocator, r#commited) == 16);
const _: () = assert!(core::mem::offset_of!(arna_Allocator, r#reserved) == 24);
impl Default for arna_Allocator {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
const _: () = assert!(core::mem::size_of::<arna_Allocator>() == 32);
const _: () = assert!(core::mem::align_of::<arna_Allocator>() == 8);
pub type arna_Temps = [arna_Allocator; 2];
const _: () = assert!(core::mem::size_of::<arna_Temps>() == 64);
const _: () = assert!(core::mem::align_of::<arna_Temps>() == 8);
#[repr(C, align(8))]
#[derive(Clone, Copy)]
pub struct bac_Worklist {
    pub r#queue: container_queue_Queue__T_Node_ID_,
    pub r#in_queue: bit_arr_Bit_Set,
}
const _: () = assert!(core::mem::offset_of!(bac_Worklist, r#queue) == 0);
const _: () = assert!(core::mem::offset_of!(bac_Worklist, r#in_queue) == 56);
impl Default for bac_Worklist {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
const _: () = assert!(core::mem::size_of::<bac_Worklist>() == 72);
const _: () = assert!(core::mem::align_of::<bac_Worklist>() == 8);
#[repr(C, align(8))]
#[derive(Clone, Copy)]
pub struct bac_Proc_Meta {
    pub r#last_pass_spec: *mut bac_Node_Spec,
    pub r#interner: bac_Interner,
    pub r#weight: isize,
    pub r#waste: isize,
    pub r#gvn: u32,
    pub r#gdn: u32,
    pub r#stable_id: u32,
    pub r#min_idepth: u32,
    pub r#max_idepth: u32,
    pub r#has_dbg: bool,
    pub r#pinned: bac_Proc_Meta_pinned,
    pub r#cached: bac_Proc_Meta_cached,
}
const _: () = assert!(core::mem::offset_of!(bac_Proc_Meta, r#last_pass_spec) == 0);
const _: () = assert!(core::mem::offset_of!(bac_Proc_Meta, r#interner) == 8);
const _: () = assert!(core::mem::offset_of!(bac_Proc_Meta, r#weight) == 40);
const _: () = assert!(core::mem::offset_of!(bac_Proc_Meta, r#waste) == 48);
const _: () = assert!(core::mem::offset_of!(bac_Proc_Meta, r#gvn) == 56);
const _: () = assert!(core::mem::offset_of!(bac_Proc_Meta, r#gdn) == 60);
const _: () = assert!(core::mem::offset_of!(bac_Proc_Meta, r#stable_id) == 64);
const _: () = assert!(core::mem::offset_of!(bac_Proc_Meta, r#min_idepth) == 68);
const _: () = assert!(core::mem::offset_of!(bac_Proc_Meta, r#max_idepth) == 72);
const _: () = assert!(core::mem::offset_of!(bac_Proc_Meta, r#has_dbg) == 76);
const _: () = assert!(core::mem::offset_of!(bac_Proc_Meta, r#pinned) == 80);
const _: () = assert!(core::mem::offset_of!(bac_Proc_Meta, r#cached) == 88);
impl Default for bac_Proc_Meta {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
const _: () = assert!(core::mem::size_of::<bac_Proc_Meta>() == 96);
const _: () = assert!(core::mem::align_of::<bac_Proc_Meta>() == 8);
pub type bac_Proc_computed_passes = u8;
const _: () = assert!(core::mem::size_of::<bac_Proc_computed_passes>() == 1);
const _: () = assert!(core::mem::align_of::<bac_Proc_computed_passes>() == 1);
pub type bac_Proc_opt_flags = u8;
const _: () = assert!(core::mem::size_of::<bac_Proc_opt_flags>() == 1);
const _: () = assert!(core::mem::align_of::<bac_Proc_opt_flags>() == 1);
#[repr(C, align(8))]
#[derive(Clone, Copy)]
pub struct bac_Lattice {
    pub r#min: i64,
    pub r#max: i64,
    pub r#meta: bac_Lattice_meta,
}
const _: () = assert!(core::mem::offset_of!(bac_Lattice, r#min) == 0);
const _: () = assert!(core::mem::offset_of!(bac_Lattice, r#max) == 8);
const _: () = assert!(core::mem::offset_of!(bac_Lattice, r#meta) == 16);
impl Default for bac_Lattice {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
const _: () = assert!(core::mem::size_of::<bac_Lattice>() == 24);
const _: () = assert!(core::mem::align_of::<bac_Lattice>() == 8);
#[repr(C, align(4))]
#[derive(Clone, Copy)]
pub struct bac_Cfg {
    pub r#idepth: u32,
}
const _: () = assert!(core::mem::offset_of!(bac_Cfg, r#idepth) == 0);
impl Default for bac_Cfg {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
const _: () = assert!(core::mem::size_of::<bac_Cfg>() == 4);
const _: () = assert!(core::mem::align_of::<bac_Cfg>() == 4);
#[repr(C, align(4))]
#[derive(Clone, Copy)]
pub struct bac_Call_flags {
    pub bytes: [u8; 4],
}
impl bac_Call_flags {
    pub fn r#ccid(self) -> u64 {
        let mut b = [0; 8];
        b[..4].copy_from_slice(&self.bytes);
        (u64::from_le_bytes(b) >> 0) & 67108863
    }
    pub fn set_ccid(&mut self, value: u64) {
        assert!(value <= 67108863);
        let mut b = [0; 8];
        b[..4].copy_from_slice(&self.bytes);
        let bits = (u64::from_le_bytes(b) & !(67108863u64 << 0)) | (value << 0);
        self.bytes.copy_from_slice(&bits.to_le_bytes()[..4]);
    }
    pub fn r#ret_count(self) -> u64 {
        let mut b = [0; 8];
        b[..4].copy_from_slice(&self.bytes);
        (u64::from_le_bytes(b) >> 26) & 15
    }
    pub fn set_ret_count(&mut self, value: u64) {
        assert!(value <= 15);
        let mut b = [0; 8];
        b[..4].copy_from_slice(&self.bytes);
        let bits = (u64::from_le_bytes(b) & !(15u64 << 26)) | (value << 26);
        self.bytes.copy_from_slice(&bits.to_le_bytes()[..4]);
    }
    pub fn r#imported(self) -> u64 {
        let mut b = [0; 8];
        b[..4].copy_from_slice(&self.bytes);
        (u64::from_le_bytes(b) >> 30) & 1
    }
    pub fn set_imported(&mut self, value: u64) {
        assert!(value <= 1);
        let mut b = [0; 8];
        b[..4].copy_from_slice(&self.bytes);
        let bits = (u64::from_le_bytes(b) & !(1u64 << 30)) | (value << 30);
        self.bytes.copy_from_slice(&bits.to_le_bytes()[..4]);
    }
}
impl Default for bac_Call_flags {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
const _: () = assert!(core::mem::size_of::<bac_Call_flags>() == 4);
const _: () = assert!(core::mem::align_of::<bac_Call_flags>() == 4);
#[repr(C, align(8))]
#[derive(Clone, Copy)]
pub struct bac_Efficiency_Stat {
    pub r#total: isize,
    pub r#ideal: isize,
}
const _: () = assert!(core::mem::offset_of!(bac_Efficiency_Stat, r#total) == 0);
const _: () = assert!(core::mem::offset_of!(bac_Efficiency_Stat, r#ideal) == 8);
impl Default for bac_Efficiency_Stat {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
const _: () = assert!(core::mem::size_of::<bac_Efficiency_Stat>() == 16);
const _: () = assert!(core::mem::align_of::<bac_Efficiency_Stat>() == 8);
pub type runtime_Allocator_Proc = *mut core::ffi::c_void;
const _: () = assert!(core::mem::size_of::<runtime_Allocator_Proc>() == 8);
const _: () = assert!(core::mem::align_of::<runtime_Allocator_Proc>() == 8);
#[repr(C, packed(4))]
#[derive(Clone, Copy)]
pub struct bac_Tag {
    pub r#name: [String; 1],
    pub r#stable_id: [u32; 1],
}
const _: () = assert!(core::mem::offset_of!(bac_Tag, r#name) == 0);
const _: () = assert!(core::mem::offset_of!(bac_Tag, r#stable_id) == 16);
impl Default for bac_Tag {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
const _: () = assert!(core::mem::size_of::<bac_Tag>() == 20);
const _: () = assert!(core::mem::align_of::<bac_Tag>() == 4);
#[repr(C, align(4))]
#[derive(Clone, Copy)]
pub struct bac_Node_spec {
    pub r#type: bac_Node_spec_type,
    pub r#meta: bac_Node_spec_meta,
}
const _: () = assert!(core::mem::offset_of!(bac_Node_spec, r#type) == 0);
const _: () = assert!(core::mem::offset_of!(bac_Node_spec, r#meta) == 2);
impl Default for bac_Node_spec {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
const _: () = assert!(core::mem::size_of::<bac_Node_spec>() == 4);
const _: () = assert!(core::mem::align_of::<bac_Node_spec>() == 4);
#[repr(C, align(4))]
#[derive(Clone, Copy)]
pub struct bac_Node_gvn_group {
    pub bytes: [u8; 4],
}
impl bac_Node_gvn_group {
    pub fn r#gvn(self) -> u64 {
        let mut b = [0; 8];
        b[..4].copy_from_slice(&self.bytes);
        (u64::from_le_bytes(b) >> 0) & 67108863
    }
    pub fn set_gvn(&mut self, value: u64) {
        assert!(value <= 67108863);
        let mut b = [0; 8];
        b[..4].copy_from_slice(&self.bytes);
        let bits = (u64::from_le_bytes(b) & !(67108863u64 << 0)) | (value << 0);
        self.bytes.copy_from_slice(&bits.to_le_bytes()[..4]);
    }
    pub fn r#scan_split(self) -> u64 {
        let mut b = [0; 8];
        b[..4].copy_from_slice(&self.bytes);
        (u64::from_le_bytes(b) >> 26) & 1
    }
    pub fn set_scan_split(&mut self, value: u64) {
        assert!(value <= 1);
        let mut b = [0; 8];
        b[..4].copy_from_slice(&self.bytes);
        let bits = (u64::from_le_bytes(b) & !(1u64 << 26)) | (value << 26);
        self.bytes.copy_from_slice(&bits.to_le_bytes()[..4]);
    }
    pub fn r#extra_dwords(self) -> u64 {
        let mut b = [0; 8];
        b[..4].copy_from_slice(&self.bytes);
        (u64::from_le_bytes(b) >> 27) & 15
    }
    pub fn set_extra_dwords(&mut self, value: u64) {
        assert!(value <= 15);
        let mut b = [0; 8];
        b[..4].copy_from_slice(&self.bytes);
        let bits = (u64::from_le_bytes(b) & !(15u64 << 27)) | (value << 27);
        self.bytes.copy_from_slice(&bits.to_le_bytes()[..4]);
    }
}
impl Default for bac_Node_gvn_group {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
const _: () = assert!(core::mem::size_of::<bac_Node_gvn_group>() == 4);
const _: () = assert!(core::mem::align_of::<bac_Node_gvn_group>() == 4);
#[repr(C, align(4))]
#[derive(Clone, Copy)]
pub struct bac_Node_Output {
    pub bytes: [u8; 4],
}
impl bac_Node_Output {
    pub fn r#id(self) -> u64 {
        let mut b = [0; 8];
        b[..4].copy_from_slice(&self.bytes);
        (u64::from_le_bytes(b) >> 0) & 4194303
    }
    pub fn set_id(&mut self, value: u64) {
        assert!(value <= 4194303);
        let mut b = [0; 8];
        b[..4].copy_from_slice(&self.bytes);
        let bits = (u64::from_le_bytes(b) & !(4194303u64 << 0)) | (value << 0);
        self.bytes.copy_from_slice(&bits.to_le_bytes()[..4]);
    }
    pub fn r#idx(self) -> u64 {
        let mut b = [0; 8];
        b[..4].copy_from_slice(&self.bytes);
        (u64::from_le_bytes(b) >> 22) & 1023
    }
    pub fn set_idx(&mut self, value: u64) {
        assert!(value <= 1023);
        let mut b = [0; 8];
        b[..4].copy_from_slice(&self.bytes);
        let bits = (u64::from_le_bytes(b) & !(1023u64 << 22)) | (value << 22);
        self.bytes.copy_from_slice(&bits.to_le_bytes()[..4]);
    }
}
impl Default for bac_Node_Output {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
const _: () = assert!(core::mem::size_of::<bac_Node_Output>() == 4);
const _: () = assert!(core::mem::align_of::<bac_Node_Output>() == 4);
#[repr(C, align(8))]
#[derive(Clone, Copy)]
pub struct bac_Basic_Block {
    pub r#head: bac_Node_ID,
    pub r#tail: bac_Node_ID,
    pub r#instrs: DynamicArray<bac_Node_ID>,
    pub r#offset: u32,
    pub r#loop_tree: *mut bac_Loop_Tree,
}
const _: () = assert!(core::mem::offset_of!(bac_Basic_Block, r#head) == 0);
const _: () = assert!(core::mem::offset_of!(bac_Basic_Block, r#tail) == 4);
const _: () = assert!(core::mem::offset_of!(bac_Basic_Block, r#instrs) == 8);
const _: () = assert!(core::mem::offset_of!(bac_Basic_Block, r#offset) == 48);
const _: () = assert!(core::mem::offset_of!(bac_Basic_Block, r#loop_tree) == 56);
impl Default for bac_Basic_Block {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
const _: () = assert!(core::mem::size_of::<bac_Basic_Block>() == 64);
const _: () = assert!(core::mem::align_of::<bac_Basic_Block>() == 8);
pub type bac_Sym_Ref_Type = u32;
pub const bac_Sym_Ref_Type_Func: bac_Sym_Ref_Type = 14;
const _: () = assert!(core::mem::size_of::<bac_Sym_Ref_Type>() == 4);
const _: () = assert!(core::mem::align_of::<bac_Sym_Ref_Type>() == 4);
#[repr(C, align(8))]
#[derive(Clone, Copy)]
pub struct bac_Dbg_Data_Sym {
    pub r#inner: bac_Dbg_Sym,
    pub r#defs: DynamicArray<bac_Dbg_Data_Def>,
}
const _: () = assert!(core::mem::offset_of!(bac_Dbg_Data_Sym, r#inner) == 0);
const _: () = assert!(core::mem::offset_of!(bac_Dbg_Data_Sym, r#defs) == 24);
impl Default for bac_Dbg_Data_Sym {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
const _: () = assert!(core::mem::size_of::<bac_Dbg_Data_Sym>() == 64);
const _: () = assert!(core::mem::align_of::<bac_Dbg_Data_Sym>() == 8);
pub type bac_Node_Spec_node_flags = u8;
const _: () = assert!(core::mem::size_of::<bac_Node_Spec_node_flags>() == 1);
const _: () = assert!(core::mem::align_of::<bac_Node_Spec_node_flags>() == 1);
#[repr(C, align(8))]
#[derive(Clone, Copy)]
pub struct bac_Regalloc_Spec {
    pub r#datatype_to_reg_kind: [bac_Reg_Kind; 11],
    pub r#spill_boundary: Slice<isize>,
    pub r#call_clobbers: Slice<Slice<i64>>,
    pub r#collect_meta: *mut core::ffi::c_void,
}
const _: () = assert!(core::mem::offset_of!(bac_Regalloc_Spec, r#datatype_to_reg_kind) == 0);
const _: () = assert!(core::mem::offset_of!(bac_Regalloc_Spec, r#spill_boundary) == 24);
const _: () = assert!(core::mem::offset_of!(bac_Regalloc_Spec, r#call_clobbers) == 40);
const _: () = assert!(core::mem::offset_of!(bac_Regalloc_Spec, r#collect_meta) == 56);
impl Default for bac_Regalloc_Spec {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
const _: () = assert!(core::mem::size_of::<bac_Regalloc_Spec>() == 64);
const _: () = assert!(core::mem::align_of::<bac_Regalloc_Spec>() == 8);
#[repr(C, align(8))]
#[derive(Clone, Copy)]
pub struct bac_Codegen_Spec {
    pub r#emit_function: *mut core::ffi::c_void,
    pub r#sccp_compute: bac_Sccp_Compute_Fn,
    pub r#peep: bac_Peep_Fn,
    pub r#post_schedule_peep: bac_PS_Peep_Fn,
    pub r#pre_regalloc_hook: bac_Pre_Regalloc_Hook,
}
const _: () = assert!(core::mem::offset_of!(bac_Codegen_Spec, r#emit_function) == 0);
const _: () = assert!(core::mem::offset_of!(bac_Codegen_Spec, r#sccp_compute) == 8);
const _: () = assert!(core::mem::offset_of!(bac_Codegen_Spec, r#peep) == 16);
const _: () = assert!(core::mem::offset_of!(bac_Codegen_Spec, r#post_schedule_peep) == 24);
const _: () = assert!(core::mem::offset_of!(bac_Codegen_Spec, r#pre_regalloc_hook) == 32);
impl Default for bac_Codegen_Spec {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
const _: () = assert!(core::mem::size_of::<bac_Codegen_Spec>() == 40);
const _: () = assert!(core::mem::align_of::<bac_Codegen_Spec>() == 8);
#[repr(C, align(2))]
#[derive(Clone, Copy)]
pub struct bac_Reg {
    pub bytes: [u8; 2],
}
impl bac_Reg {
    pub fn r#index(self) -> u64 {
        let mut b = [0; 8];
        b[..2].copy_from_slice(&self.bytes);
        (u64::from_le_bytes(b) >> 0) & 4095
    }
    pub fn set_index(&mut self, value: u64) {
        assert!(value <= 4095);
        let mut b = [0; 8];
        b[..2].copy_from_slice(&self.bytes);
        let bits = (u64::from_le_bytes(b) & !(4095u64 << 0)) | (value << 0);
        self.bytes.copy_from_slice(&bits.to_le_bytes()[..2]);
    }
    pub fn r#kind(self) -> u64 {
        let mut b = [0; 8];
        b[..2].copy_from_slice(&self.bytes);
        (u64::from_le_bytes(b) >> 12) & 15
    }
    pub fn set_kind(&mut self, value: u64) {
        assert!(value <= 15);
        let mut b = [0; 8];
        b[..2].copy_from_slice(&self.bytes);
        let bits = (u64::from_le_bytes(b) & !(15u64 << 12)) | (value << 12);
        self.bytes.copy_from_slice(&bits.to_le_bytes()[..2]);
    }
}
impl Default for bac_Reg {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
const _: () = assert!(core::mem::size_of::<bac_Reg>() == 2);
const _: () = assert!(core::mem::align_of::<bac_Reg>() == 2);
#[repr(C, align(4))]
#[derive(Clone, Copy)]
pub struct bac_Cfi_Spec {
    pub r#cfa_reg: u8,
    pub r#return_addr_reg: u8,
    pub r#initial_cfa_offset: u32,
    pub r#code_align: u32,
    pub r#data_align: i32,
}
const _: () = assert!(core::mem::offset_of!(bac_Cfi_Spec, r#cfa_reg) == 0);
const _: () = assert!(core::mem::offset_of!(bac_Cfi_Spec, r#return_addr_reg) == 1);
const _: () = assert!(core::mem::offset_of!(bac_Cfi_Spec, r#initial_cfa_offset) == 4);
const _: () = assert!(core::mem::offset_of!(bac_Cfi_Spec, r#code_align) == 8);
const _: () = assert!(core::mem::offset_of!(bac_Cfi_Spec, r#data_align) == 12);
impl Default for bac_Cfi_Spec {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
const _: () = assert!(core::mem::size_of::<bac_Cfi_Spec>() == 16);
const _: () = assert!(core::mem::align_of::<bac_Cfi_Spec>() == 4);
#[repr(C, align(8))]
#[derive(Clone, Copy)]
pub struct bac_RM_Interner {
    pub r#slots: Slice<bac_RM_Interner_slots>,
    pub r#lens: Slice<isize>,
    pub r#mask_len: u32,
}
const _: () = assert!(core::mem::offset_of!(bac_RM_Interner, r#slots) == 0);
const _: () = assert!(core::mem::offset_of!(bac_RM_Interner, r#lens) == 16);
const _: () = assert!(core::mem::offset_of!(bac_RM_Interner, r#mask_len) == 32);
impl Default for bac_RM_Interner {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
const _: () = assert!(core::mem::size_of::<bac_RM_Interner>() == 40);
const _: () = assert!(core::mem::align_of::<bac_RM_Interner>() == 8);
pub type bac_Reg_Kind = u16;
const _: () = assert!(core::mem::size_of::<bac_Reg_Kind>() == 2);
const _: () = assert!(core::mem::align_of::<bac_Reg_Kind>() == 2);
#[repr(C, align(8))]
#[derive(Clone, Copy)]
pub struct bac_Codegen_Emit_Buf {
    pub r#code: *mut arna_Allocator,
    pub r#constants: *mut arna_Allocator,
    pub r#relocs: *mut arna_Allocator,
    pub r#slocs: *mut arna_Allocator,
    pub r#cfi: *mut arna_Allocator,
    pub r#dbg_locs: *mut arna_Allocator,
}
const _: () = assert!(core::mem::offset_of!(bac_Codegen_Emit_Buf, r#code) == 0);
const _: () = assert!(core::mem::offset_of!(bac_Codegen_Emit_Buf, r#constants) == 8);
const _: () = assert!(core::mem::offset_of!(bac_Codegen_Emit_Buf, r#relocs) == 16);
const _: () = assert!(core::mem::offset_of!(bac_Codegen_Emit_Buf, r#slocs) == 24);
const _: () = assert!(core::mem::offset_of!(bac_Codegen_Emit_Buf, r#cfi) == 32);
const _: () = assert!(core::mem::offset_of!(bac_Codegen_Emit_Buf, r#dbg_locs) == 40);
impl Default for bac_Codegen_Emit_Buf {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
const _: () = assert!(core::mem::size_of::<bac_Codegen_Emit_Buf>() == 48);
const _: () = assert!(core::mem::align_of::<bac_Codegen_Emit_Buf>() == 8);
#[repr(C, align(4))]
#[derive(Clone, Copy)]
pub struct bac_Lib_Calls {
    pub r#copy: bac_Lib_Call,
    pub r#set: bac_Lib_Call,
}
const _: () = assert!(core::mem::offset_of!(bac_Lib_Calls, r#copy) == 0);
const _: () = assert!(core::mem::offset_of!(bac_Lib_Calls, r#set) == 4);
impl Default for bac_Lib_Calls {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
const _: () = assert!(core::mem::size_of::<bac_Lib_Calls>() == 8);
const _: () = assert!(core::mem::align_of::<bac_Lib_Calls>() == 4);
#[repr(C, align(1))]
#[derive(Clone, Copy)]
pub struct bac_Codegen_Emit_Output {}
impl Default for bac_Codegen_Emit_Output {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
const _: () = assert!(core::mem::size_of::<bac_Codegen_Emit_Output>() == 0);
const _: () = assert!(core::mem::align_of::<bac_Codegen_Emit_Output>() == 1);
#[repr(C, align(8))]
#[derive(Clone, Copy)]
pub struct bac_Codegen_Output_Bufs {
    pub r#code: Slice<u8>,
    pub r#constants: Slice<u8>,
    pub r#relocs: Slice<bac_Reloc>,
    pub r#slocs: Slice<bac_Sloc>,
    pub r#cfi: Slice<bac_Cfi_Op>,
    pub r#dbg_locs: Slice<bac_Dbg_Location>,
}
const _: () = assert!(core::mem::offset_of!(bac_Codegen_Output_Bufs, r#code) == 0);
const _: () = assert!(core::mem::offset_of!(bac_Codegen_Output_Bufs, r#constants) == 16);
const _: () = assert!(core::mem::offset_of!(bac_Codegen_Output_Bufs, r#relocs) == 32);
const _: () = assert!(core::mem::offset_of!(bac_Codegen_Output_Bufs, r#slocs) == 48);
const _: () = assert!(core::mem::offset_of!(bac_Codegen_Output_Bufs, r#cfi) == 64);
const _: () = assert!(core::mem::offset_of!(bac_Codegen_Output_Bufs, r#dbg_locs) == 80);
impl Default for bac_Codegen_Output_Bufs {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
const _: () = assert!(core::mem::size_of::<bac_Codegen_Output_Bufs>() == 96);
const _: () = assert!(core::mem::align_of::<bac_Codegen_Output_Bufs>() == 8);
#[repr(C, align(4))]
#[derive(Clone, Copy)]
pub union bac_ssa_If_State_branch {
    pub r#else_scope: bac_Node_ID,
    pub r#then_scope: bac_Node_ID,
}
const _: () = assert!(core::mem::offset_of!(bac_ssa_If_State_branch, r#else_scope) == 0);
const _: () = assert!(core::mem::offset_of!(bac_ssa_If_State_branch, r#then_scope) == 0);
impl Default for bac_ssa_If_State_branch {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
const _: () = assert!(core::mem::size_of::<bac_ssa_If_State_branch>() == 4);
const _: () = assert!(core::mem::align_of::<bac_ssa_If_State_branch>() == 4);
#[repr(C, align(8))]
#[derive(Clone, Copy)]
pub struct container_queue_Queue__T_Node_ID_ {
    pub r#data: DynamicArray<bac_Node_ID>,
    pub r#len: usize,
    pub r#offset: usize,
}
const _: () = assert!(core::mem::offset_of!(container_queue_Queue__T_Node_ID_, r#data) == 0);
const _: () = assert!(core::mem::offset_of!(container_queue_Queue__T_Node_ID_, r#len) == 40);
const _: () = assert!(core::mem::offset_of!(container_queue_Queue__T_Node_ID_, r#offset) == 48);
impl Default for container_queue_Queue__T_Node_ID_ {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
const _: () = assert!(core::mem::size_of::<container_queue_Queue__T_Node_ID_>() == 56);
const _: () = assert!(core::mem::align_of::<container_queue_Queue__T_Node_ID_>() == 8);
#[repr(C, align(8))]
#[derive(Clone, Copy)]
pub struct bit_arr_Bit_Set {
    pub r#masks: *mut isize,
    pub r#bit_length: isize,
}
const _: () = assert!(core::mem::offset_of!(bit_arr_Bit_Set, r#masks) == 0);
const _: () = assert!(core::mem::offset_of!(bit_arr_Bit_Set, r#bit_length) == 8);
impl Default for bit_arr_Bit_Set {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
const _: () = assert!(core::mem::size_of::<bit_arr_Bit_Set>() == 16);
const _: () = assert!(core::mem::align_of::<bit_arr_Bit_Set>() == 8);
#[repr(C, align(8))]
#[derive(Clone, Copy)]
pub struct bac_Interner {
    pub r#hash_idx: usize,
    pub r#node_idx: usize,
    pub r#len: isize,
    pub r#cap: isize,
}
const _: () = assert!(core::mem::offset_of!(bac_Interner, r#hash_idx) == 0);
const _: () = assert!(core::mem::offset_of!(bac_Interner, r#node_idx) == 8);
const _: () = assert!(core::mem::offset_of!(bac_Interner, r#len) == 16);
const _: () = assert!(core::mem::offset_of!(bac_Interner, r#cap) == 24);
impl Default for bac_Interner {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
const _: () = assert!(core::mem::size_of::<bac_Interner>() == 32);
const _: () = assert!(core::mem::align_of::<bac_Interner>() == 8);
#[repr(C, align(4))]
#[derive(Clone, Copy)]
pub struct bac_Proc_Meta_pinned {
    pub r#entry: bac_Node_ID,
    pub r#end: bac_Node_ID,
}
const _: () = assert!(core::mem::offset_of!(bac_Proc_Meta_pinned, r#entry) == 0);
const _: () = assert!(core::mem::offset_of!(bac_Proc_Meta_pinned, r#end) == 4);
impl Default for bac_Proc_Meta_pinned {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
const _: () = assert!(core::mem::size_of::<bac_Proc_Meta_pinned>() == 8);
const _: () = assert!(core::mem::align_of::<bac_Proc_Meta_pinned>() == 4);
#[repr(C, align(4))]
#[derive(Clone, Copy)]
pub struct bac_Proc_Meta_cached {
    pub r#cmem: bac_Node_ID,
}
const _: () = assert!(core::mem::offset_of!(bac_Proc_Meta_cached, r#cmem) == 0);
impl Default for bac_Proc_Meta_cached {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
const _: () = assert!(core::mem::size_of::<bac_Proc_Meta_cached>() == 4);
const _: () = assert!(core::mem::align_of::<bac_Proc_Meta_cached>() == 4);
#[repr(C, align(8))]
#[derive(Clone, Copy)]
pub struct bac_Lattice_meta {
    pub bytes: [u8; 8],
}
impl bac_Lattice_meta {
    pub fn r#type(self) -> u64 {
        let mut b = [0; 8];
        b[..8].copy_from_slice(&self.bytes);
        (u64::from_le_bytes(b) >> 0) & 15
    }
    pub fn set_type(&mut self, value: u64) {
        assert!(value <= 15);
        let mut b = [0; 8];
        b[..8].copy_from_slice(&self.bytes);
        let bits = (u64::from_le_bytes(b) & !(15u64 << 0)) | (value << 0);
        self.bytes.copy_from_slice(&bits.to_le_bytes()[..8]);
    }
    pub fn r#is_not_nan(self) -> u64 {
        let mut b = [0; 8];
        b[..8].copy_from_slice(&self.bytes);
        (u64::from_le_bytes(b) >> 4) & 1
    }
    pub fn set_is_not_nan(&mut self, value: u64) {
        assert!(value <= 1);
        let mut b = [0; 8];
        b[..8].copy_from_slice(&self.bytes);
        let bits = (u64::from_le_bytes(b) & !(1u64 << 4)) | (value << 4);
        self.bytes.copy_from_slice(&bits.to_le_bytes()[..8]);
    }
    pub fn r#is_not_ninf(self) -> u64 {
        let mut b = [0; 8];
        b[..8].copy_from_slice(&self.bytes);
        (u64::from_le_bytes(b) >> 5) & 1
    }
    pub fn set_is_not_ninf(&mut self, value: u64) {
        assert!(value <= 1);
        let mut b = [0; 8];
        b[..8].copy_from_slice(&self.bytes);
        let bits = (u64::from_le_bytes(b) & !(1u64 << 5)) | (value << 5);
        self.bytes.copy_from_slice(&bits.to_le_bytes()[..8]);
    }
    pub fn r#is_not_pinf(self) -> u64 {
        let mut b = [0; 8];
        b[..8].copy_from_slice(&self.bytes);
        (u64::from_le_bytes(b) >> 6) & 1
    }
    pub fn set_is_not_pinf(&mut self, value: u64) {
        assert!(value <= 1);
        let mut b = [0; 8];
        b[..8].copy_from_slice(&self.bytes);
        let bits = (u64::from_le_bytes(b) & !(1u64 << 6)) | (value << 6);
        self.bytes.copy_from_slice(&bits.to_le_bytes()[..8]);
    }
    pub fn r#is_not_zero(self) -> u64 {
        let mut b = [0; 8];
        b[..8].copy_from_slice(&self.bytes);
        (u64::from_le_bytes(b) >> 7) & 1
    }
    pub fn set_is_not_zero(&mut self, value: u64) {
        assert!(value <= 1);
        let mut b = [0; 8];
        b[..8].copy_from_slice(&self.bytes);
        let bits = (u64::from_le_bytes(b) & !(1u64 << 7)) | (value << 7);
        self.bytes.copy_from_slice(&bits.to_le_bytes()[..8]);
    }
    pub fn r#is_nan(self) -> u64 {
        let mut b = [0; 8];
        b[..8].copy_from_slice(&self.bytes);
        (u64::from_le_bytes(b) >> 8) & 1
    }
    pub fn set_is_nan(&mut self, value: u64) {
        assert!(value <= 1);
        let mut b = [0; 8];
        b[..8].copy_from_slice(&self.bytes);
        let bits = (u64::from_le_bytes(b) & !(1u64 << 8)) | (value << 8);
        self.bytes.copy_from_slice(&bits.to_le_bytes()[..8]);
    }
    pub fn r#dead(self) -> u64 {
        let mut b = [0; 8];
        b[..8].copy_from_slice(&self.bytes);
        (u64::from_le_bytes(b) >> 9) & 1
    }
    pub fn set_dead(&mut self, value: u64) {
        assert!(value <= 1);
        let mut b = [0; 8];
        b[..8].copy_from_slice(&self.bytes);
        let bits = (u64::from_le_bytes(b) & !(1u64 << 9)) | (value << 9);
        self.bytes.copy_from_slice(&bits.to_le_bytes()[..8]);
    }
    pub fn r#widens(self) -> u64 {
        let mut b = [0; 8];
        b[..8].copy_from_slice(&self.bytes);
        (u64::from_le_bytes(b) >> 10) & 7
    }
    pub fn set_widens(&mut self, value: u64) {
        assert!(value <= 7);
        let mut b = [0; 8];
        b[..8].copy_from_slice(&self.bytes);
        let bits = (u64::from_le_bytes(b) & !(7u64 << 10)) | (value << 10);
        self.bytes.copy_from_slice(&bits.to_le_bytes()[..8]);
    }
}
impl Default for bac_Lattice_meta {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
const _: () = assert!(core::mem::size_of::<bac_Lattice_meta>() == 8);
const _: () = assert!(core::mem::align_of::<bac_Lattice_meta>() == 8);
#[repr(C, align(2))]
#[derive(Clone, Copy)]
pub union bac_Node_spec_type {
    pub r#itype: bac_Node_Type,
    pub r#rtype: u16,
}
const _: () = assert!(core::mem::offset_of!(bac_Node_spec_type, r#itype) == 0);
const _: () = assert!(core::mem::offset_of!(bac_Node_spec_type, r#rtype) == 0);
impl Default for bac_Node_spec_type {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
const _: () = assert!(core::mem::size_of::<bac_Node_spec_type>() == 2);
const _: () = assert!(core::mem::align_of::<bac_Node_spec_type>() == 2);
#[repr(C, align(2))]
#[derive(Clone, Copy)]
pub struct bac_Node_spec_meta {
    pub bytes: [u8; 2],
}
impl bac_Node_spec_meta {
    pub fn r#dt(self) -> u64 {
        let mut b = [0; 8];
        b[..2].copy_from_slice(&self.bytes);
        (u64::from_le_bytes(b) >> 0) & 15
    }
    pub fn set_dt(&mut self, value: u64) {
        assert!(value <= 15);
        let mut b = [0; 8];
        b[..2].copy_from_slice(&self.bytes);
        let bits = (u64::from_le_bytes(b) & !(15u64 << 0)) | (value << 0);
        self.bytes.copy_from_slice(&bits.to_le_bytes()[..2]);
    }
    pub fn r#is_store(self) -> u64 {
        let mut b = [0; 8];
        b[..2].copy_from_slice(&self.bytes);
        (u64::from_le_bytes(b) >> 4) & 1
    }
    pub fn set_is_store(&mut self, value: u64) {
        assert!(value <= 1);
        let mut b = [0; 8];
        b[..2].copy_from_slice(&self.bytes);
        let bits = (u64::from_le_bytes(b) & !(1u64 << 4)) | (value << 4);
        self.bytes.copy_from_slice(&bits.to_le_bytes()[..2]);
    }
    pub fn r#is_load(self) -> u64 {
        let mut b = [0; 8];
        b[..2].copy_from_slice(&self.bytes);
        (u64::from_le_bytes(b) >> 5) & 1
    }
    pub fn set_is_load(&mut self, value: u64) {
        assert!(value <= 1);
        let mut b = [0; 8];
        b[..2].copy_from_slice(&self.bytes);
        let bits = (u64::from_le_bytes(b) & !(1u64 << 5)) | (value << 5);
        self.bytes.copy_from_slice(&bits.to_le_bytes()[..2]);
    }
    pub fn r#mem_alignment_pow(self) -> u64 {
        let mut b = [0; 8];
        b[..2].copy_from_slice(&self.bytes);
        (u64::from_le_bytes(b) >> 6) & 7
    }
    pub fn set_mem_alignment_pow(&mut self, value: u64) {
        assert!(value <= 7);
        let mut b = [0; 8];
        b[..2].copy_from_slice(&self.bytes);
        let bits = (u64::from_le_bytes(b) & !(7u64 << 6)) | (value << 6);
        self.bytes.copy_from_slice(&bits.to_le_bytes()[..2]);
    }
    pub fn r#lane(self) -> u64 {
        let mut b = [0; 8];
        b[..2].copy_from_slice(&self.bytes);
        (u64::from_le_bytes(b) >> 9) & 7
    }
    pub fn set_lane(&mut self, value: u64) {
        assert!(value <= 7);
        let mut b = [0; 8];
        b[..2].copy_from_slice(&self.bytes);
        let bits = (u64::from_le_bytes(b) & !(7u64 << 9)) | (value << 9);
        self.bytes.copy_from_slice(&bits.to_le_bytes()[..2]);
    }
}
impl Default for bac_Node_spec_meta {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
const _: () = assert!(core::mem::size_of::<bac_Node_spec_meta>() == 2);
const _: () = assert!(core::mem::align_of::<bac_Node_spec_meta>() == 2);
#[repr(C, align(8))]
#[derive(Clone, Copy)]
pub struct bac_Loop_Tree {
    pub r#parent: *mut bac_Loop_Tree,
    pub r#depth: u32,
    pub r#infinite: bool,
    pub r#already_always: bool,
}
const _: () = assert!(core::mem::offset_of!(bac_Loop_Tree, r#parent) == 0);
const _: () = assert!(core::mem::offset_of!(bac_Loop_Tree, r#depth) == 8);
const _: () = assert!(core::mem::offset_of!(bac_Loop_Tree, r#infinite) == 12);
const _: () = assert!(core::mem::offset_of!(bac_Loop_Tree, r#already_always) == 13);
impl Default for bac_Loop_Tree {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
const _: () = assert!(core::mem::size_of::<bac_Loop_Tree>() == 16);
const _: () = assert!(core::mem::align_of::<bac_Loop_Tree>() == 8);
#[repr(C, align(8))]
#[derive(Clone, Copy)]
pub struct bac_Dbg_Sym {
    pub r#name: String,
    pub r#type: u64,
}
const _: () = assert!(core::mem::offset_of!(bac_Dbg_Sym, r#name) == 0);
const _: () = assert!(core::mem::offset_of!(bac_Dbg_Sym, r#type) == 16);
impl Default for bac_Dbg_Sym {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
const _: () = assert!(core::mem::size_of::<bac_Dbg_Sym>() == 24);
const _: () = assert!(core::mem::align_of::<bac_Dbg_Sym>() == 8);
#[repr(C, align(4))]
#[derive(Clone, Copy)]
pub struct bac_Dbg_Data_Def {
    pub r#node: bac_Node_ID,
}
const _: () = assert!(core::mem::offset_of!(bac_Dbg_Data_Def, r#node) == 0);
impl Default for bac_Dbg_Data_Def {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
const _: () = assert!(core::mem::size_of::<bac_Dbg_Data_Def>() == 4);
const _: () = assert!(core::mem::align_of::<bac_Dbg_Data_Def>() == 4);
pub type bac_Sccp_Compute_Fn = *mut core::ffi::c_void;
const _: () = assert!(core::mem::size_of::<bac_Sccp_Compute_Fn>() == 8);
const _: () = assert!(core::mem::align_of::<bac_Sccp_Compute_Fn>() == 8);
pub type bac_Peep_Fn = *mut core::ffi::c_void;
const _: () = assert!(core::mem::size_of::<bac_Peep_Fn>() == 8);
const _: () = assert!(core::mem::align_of::<bac_Peep_Fn>() == 8);
pub type bac_PS_Peep_Fn = *mut core::ffi::c_void;
const _: () = assert!(core::mem::size_of::<bac_PS_Peep_Fn>() == 8);
const _: () = assert!(core::mem::align_of::<bac_PS_Peep_Fn>() == 8);
pub type bac_Pre_Regalloc_Hook = *mut core::ffi::c_void;
const _: () = assert!(core::mem::size_of::<bac_Pre_Regalloc_Hook>() == 8);
const _: () = assert!(core::mem::align_of::<bac_Pre_Regalloc_Hook>() == 8);
#[repr(C, align(8))]
#[derive(Clone, Copy)]
pub struct bac_RM_Interner_slots {
    pub r#hash: *mut u8,
    pub r#id: *mut *mut i64,
    pub r#___len: isize,
}
const _: () = assert!(core::mem::offset_of!(bac_RM_Interner_slots, r#hash) == 0);
const _: () = assert!(core::mem::offset_of!(bac_RM_Interner_slots, r#id) == 8);
const _: () = assert!(core::mem::offset_of!(bac_RM_Interner_slots, r#___len) == 16);
impl Default for bac_RM_Interner_slots {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
const _: () = assert!(core::mem::size_of::<bac_RM_Interner_slots>() == 24);
const _: () = assert!(core::mem::align_of::<bac_RM_Interner_slots>() == 8);
#[repr(C, align(4))]
#[derive(Clone, Copy)]
pub struct bac_Lib_Call {
    pub bytes: [u8; 4],
}
impl bac_Lib_Call {
    pub fn r#id(self) -> u64 {
        let mut b = [0; 8];
        b[..4].copy_from_slice(&self.bytes);
        (u64::from_le_bytes(b) >> 0) & 2147483647
    }
    pub fn set_id(&mut self, value: u64) {
        assert!(value <= 2147483647);
        let mut b = [0; 8];
        b[..4].copy_from_slice(&self.bytes);
        let bits = (u64::from_le_bytes(b) & !(2147483647u64 << 0)) | (value << 0);
        self.bytes.copy_from_slice(&bits.to_le_bytes()[..4]);
    }
    pub fn r#absolute(self) -> u64 {
        let mut b = [0; 8];
        b[..4].copy_from_slice(&self.bytes);
        (u64::from_le_bytes(b) >> 31) & 1
    }
    pub fn set_absolute(&mut self, value: u64) {
        assert!(value <= 1);
        let mut b = [0; 8];
        b[..4].copy_from_slice(&self.bytes);
        let bits = (u64::from_le_bytes(b) & !(1u64 << 31)) | (value << 31);
        self.bytes.copy_from_slice(&bits.to_le_bytes()[..4]);
    }
}
impl Default for bac_Lib_Call {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
const _: () = assert!(core::mem::size_of::<bac_Lib_Call>() == 4);
const _: () = assert!(core::mem::align_of::<bac_Lib_Call>() == 4);
#[repr(C, align(4))]
#[derive(Clone, Copy)]
pub struct bac_Reloc {
    pub r#offset: u32,
    pub r#field_1: bac_Reloc_field_1,
}
const _: () = assert!(core::mem::offset_of!(bac_Reloc, r#offset) == 0);
const _: () = assert!(core::mem::offset_of!(bac_Reloc, r#field_1) == 4);
impl Default for bac_Reloc {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
const _: () = assert!(core::mem::size_of::<bac_Reloc>() == 8);
const _: () = assert!(core::mem::align_of::<bac_Reloc>() == 4);
#[repr(C, align(4))]
#[derive(Clone, Copy)]
pub struct bac_Cfi_Op {
    pub r#offset: u32,
    pub r#arg: u32,
    pub r#kind: bac_Cfi_Kind,
    pub r#reg: u8,
}
const _: () = assert!(core::mem::offset_of!(bac_Cfi_Op, r#offset) == 0);
const _: () = assert!(core::mem::offset_of!(bac_Cfi_Op, r#arg) == 4);
const _: () = assert!(core::mem::offset_of!(bac_Cfi_Op, r#kind) == 8);
const _: () = assert!(core::mem::offset_of!(bac_Cfi_Op, r#reg) == 9);
impl Default for bac_Cfi_Op {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
const _: () = assert!(core::mem::size_of::<bac_Cfi_Op>() == 12);
const _: () = assert!(core::mem::align_of::<bac_Cfi_Op>() == 4);
#[repr(C, align(8))]
#[derive(Clone, Copy)]
pub struct bac_Dbg_Location {
    pub r#sym: bac_Dbg_Sym,
    pub r#start: u32,
    pub r#end: u32,
    pub r#symbol: u32,
    pub r#offset: i32,
    pub r#reg: bac_Reg,
    pub r#kind: bac_Dbg_Location_Kind,
}
const _: () = assert!(core::mem::offset_of!(bac_Dbg_Location, r#sym) == 0);
const _: () = assert!(core::mem::offset_of!(bac_Dbg_Location, r#start) == 24);
const _: () = assert!(core::mem::offset_of!(bac_Dbg_Location, r#end) == 28);
const _: () = assert!(core::mem::offset_of!(bac_Dbg_Location, r#symbol) == 32);
const _: () = assert!(core::mem::offset_of!(bac_Dbg_Location, r#offset) == 36);
const _: () = assert!(core::mem::offset_of!(bac_Dbg_Location, r#reg) == 40);
const _: () = assert!(core::mem::offset_of!(bac_Dbg_Location, r#kind) == 42);
impl Default for bac_Dbg_Location {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
const _: () = assert!(core::mem::size_of::<bac_Dbg_Location>() == 48);
const _: () = assert!(core::mem::align_of::<bac_Dbg_Location>() == 8);
#[repr(C, align(4))]
#[derive(Clone, Copy)]
pub struct bac_Reloc_field_1 {
    pub bytes: [u8; 4],
}
impl bac_Reloc_field_1 {
    pub fn r#kind(self) -> u64 {
        let mut b = [0; 8];
        b[..4].copy_from_slice(&self.bytes);
        (u64::from_le_bytes(b) >> 0) & 3
    }
    pub fn set_kind(&mut self, value: u64) {
        assert!(value <= 3);
        let mut b = [0; 8];
        b[..4].copy_from_slice(&self.bytes);
        let bits = (u64::from_le_bytes(b) & !(3u64 << 0)) | (value << 0);
        self.bytes.copy_from_slice(&bits.to_le_bytes()[..4]);
    }
    pub fn r#size(self) -> u64 {
        let mut b = [0; 8];
        b[..4].copy_from_slice(&self.bytes);
        (u64::from_le_bytes(b) >> 2) & 3
    }
    pub fn set_size(&mut self, value: u64) {
        assert!(value <= 3);
        let mut b = [0; 8];
        b[..4].copy_from_slice(&self.bytes);
        let bits = (u64::from_le_bytes(b) & !(3u64 << 2)) | (value << 2);
        self.bytes.copy_from_slice(&bits.to_le_bytes()[..4]);
    }
    pub fn r#scale_pow(self) -> u64 {
        let mut b = [0; 8];
        b[..4].copy_from_slice(&self.bytes);
        (u64::from_le_bytes(b) >> 4) & 3
    }
    pub fn set_scale_pow(&mut self, value: u64) {
        assert!(value <= 3);
        let mut b = [0; 8];
        b[..4].copy_from_slice(&self.bytes);
        let bits = (u64::from_le_bytes(b) & !(3u64 << 4)) | (value << 4);
        self.bytes.copy_from_slice(&bits.to_le_bytes()[..4]);
    }
    pub fn r#id(self) -> u64 {
        let mut b = [0; 8];
        b[..4].copy_from_slice(&self.bytes);
        (u64::from_le_bytes(b) >> 6) & 67108863
    }
    pub fn set_id(&mut self, value: u64) {
        assert!(value <= 67108863);
        let mut b = [0; 8];
        b[..4].copy_from_slice(&self.bytes);
        let bits = (u64::from_le_bytes(b) & !(67108863u64 << 6)) | (value << 6);
        self.bytes.copy_from_slice(&bits.to_le_bytes()[..4]);
    }
}
impl Default for bac_Reloc_field_1 {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}
const _: () = assert!(core::mem::size_of::<bac_Reloc_field_1>() == 4);
const _: () = assert!(core::mem::align_of::<bac_Reloc_field_1>() == 4);
pub type bac_Cfi_Kind = u8;
pub const bac_Cfi_Kind_Def_Cfa_Offset: bac_Cfi_Kind = 0;
pub const bac_Cfi_Kind_Save_Reg: bac_Cfi_Kind = 1;
pub const bac_Cfi_Kind_Restore_Reg: bac_Cfi_Kind = 2;
pub const bac_Cfi_Kind_Remember_State: bac_Cfi_Kind = 3;
pub const bac_Cfi_Kind_Restore_State: bac_Cfi_Kind = 4;
const _: () = assert!(core::mem::size_of::<bac_Cfi_Kind>() == 1);
const _: () = assert!(core::mem::align_of::<bac_Cfi_Kind>() == 1);
pub type bac_Dbg_Location_Kind = u8;
pub const bac_Dbg_Location_Kind_Register: bac_Dbg_Location_Kind = 0;
pub const bac_Dbg_Location_Kind_Register_Offset: bac_Dbg_Location_Kind = 1;
const _: () = assert!(core::mem::size_of::<bac_Dbg_Location_Kind>() == 1);
const _: () = assert!(core::mem::align_of::<bac_Dbg_Location_Kind>() == 1);