// GENERATED BY ISLE. DO NOT EDIT!
//
// Generated automatically from the instruction-selection DSL code in:
// - src/prelude.isle
// - src/prelude_lower.isle
// - src/isa/pulley_shared/inst.isle
// - src/isa/pulley_shared/lower.isle
// - <OUT_DIR>/numerics.isle
// - <OUT_DIR>/pulley_gen.isle
// - <OUT_DIR>/clif_lower.isle

use super::*;  // Pulls in all external types.
use core::marker::PhantomData;

/// Context during lowering: an implementation of this trait
/// must be provided with all external constructors and extractors.
/// A mutable borrow is passed along through all lowering logic.
pub trait Context {
    fn unit(&mut self, ) -> Unit;
    fn def_inst(&mut self, arg0: Value) -> Option<Inst>;
    fn value_type(&mut self, arg0: Value) -> Type;
    fn u32_nonnegative(&mut self, arg0: u32) -> Option<u32>;
    fn offset32(&mut self, arg0: Offset32) -> i32;
    fn checked_add_with_type(&mut self, arg0: Type, arg1: u64, arg2: u64) -> Option<u64>;
    fn add_overflows_with_type(&mut self, arg0: Type, arg1: u64, arg2: u64) -> bool;
    fn imm64_sdiv(&mut self, arg0: Type, arg1: Imm64, arg2: Imm64) -> Option<Imm64>;
    fn imm64_udiv(&mut self, arg0: Type, arg1: Imm64, arg2: Imm64) -> Option<Imm64>;
    fn imm64_srem(&mut self, arg0: Type, arg1: Imm64, arg2: Imm64) -> Option<Imm64>;
    fn imm64_urem(&mut self, arg0: Type, arg1: Imm64, arg2: Imm64) -> Option<Imm64>;
    fn imm64_add(&mut self, arg0: Type, arg1: Imm64, arg2: Imm64) -> Imm64;
    fn imm64_sub(&mut self, arg0: Type, arg1: Imm64, arg2: Imm64) -> Imm64;
    fn imm64_mul(&mut self, arg0: Type, arg1: Imm64, arg2: Imm64) -> Imm64;
    fn imm64_and(&mut self, arg0: Type, arg1: Imm64, arg2: Imm64) -> Imm64;
    fn imm64_or(&mut self, arg0: Type, arg1: Imm64, arg2: Imm64) -> Imm64;
    fn imm64_xor(&mut self, arg0: Type, arg1: Imm64, arg2: Imm64) -> Imm64;
    fn imm64_not(&mut self, arg0: Type, arg1: Imm64) -> Imm64;
    fn imm64_neg(&mut self, arg0: Type, arg1: Imm64) -> Imm64;
    fn imm64_abs(&mut self, arg0: Type, arg1: Imm64) -> Option<Imm64>;
    fn imm64_ilog2(&mut self, arg0: Type, arg1: Imm64) -> Option<Imm64>;
    fn imm64_umin(&mut self, arg0: Type, arg1: Imm64, arg2: Imm64) -> Imm64;
    fn imm64_umax(&mut self, arg0: Type, arg1: Imm64, arg2: Imm64) -> Imm64;
    fn imm64_smin(&mut self, arg0: Type, arg1: Imm64, arg2: Imm64) -> Imm64;
    fn imm64_smax(&mut self, arg0: Type, arg1: Imm64, arg2: Imm64) -> Imm64;
    fn imm64_shl(&mut self, arg0: Type, arg1: Imm64, arg2: Imm64) -> Imm64;
    fn imm64_ushr(&mut self, arg0: Type, arg1: Imm64, arg2: Imm64) -> Imm64;
    fn imm64_sshr(&mut self, arg0: Type, arg1: Imm64, arg2: Imm64) -> Imm64;
    fn imm64_rotl(&mut self, arg0: Type, arg1: Imm64, arg2: Imm64) -> Imm64;
    fn imm64_rotr(&mut self, arg0: Type, arg1: Imm64, arg2: Imm64) -> Imm64;
    fn i64_sextend_u64(&mut self, arg0: Type, arg1: u64) -> i64;
    fn i64_sextend_imm64(&mut self, arg0: Type, arg1: Imm64) -> i64;
    fn u64_uextend_imm64(&mut self, arg0: Type, arg1: Imm64) -> u64;
    fn imm64_icmp(&mut self, arg0: Type, arg1: &IntCC, arg2: Imm64, arg3: Imm64) -> Imm64;
    fn imm64_clz(&mut self, arg0: Type, arg1: Imm64) -> Imm64;
    fn imm64_ctz(&mut self, arg0: Type, arg1: Imm64) -> Imm64;
    fn u128_replicated_u64(&mut self, arg0: u128) -> Option<u64>;
    fn u64_replicated_u32(&mut self, arg0: u64) -> Option<u32>;
    fn u32_replicated_u16(&mut self, arg0: u32) -> Option<u16>;
    fn u16_replicated_u8(&mut self, arg0: u16) -> Option<u8>;
    fn u128_low_bits(&mut self, arg0: u128) -> u64;
    fn u128_high_bits(&mut self, arg0: u128) -> u64;
    fn f16_min(&mut self, arg0: Ieee16, arg1: Ieee16) -> Option<Ieee16>;
    fn f16_max(&mut self, arg0: Ieee16, arg1: Ieee16) -> Option<Ieee16>;
    fn f16_neg(&mut self, arg0: Ieee16) -> Ieee16;
    fn f16_abs(&mut self, arg0: Ieee16) -> Ieee16;
    fn f16_copysign(&mut self, arg0: Ieee16, arg1: Ieee16) -> Ieee16;
    fn f32_add(&mut self, arg0: Ieee32, arg1: Ieee32) -> Option<Ieee32>;
    fn f32_sub(&mut self, arg0: Ieee32, arg1: Ieee32) -> Option<Ieee32>;
    fn f32_mul(&mut self, arg0: Ieee32, arg1: Ieee32) -> Option<Ieee32>;
    fn f32_div(&mut self, arg0: Ieee32, arg1: Ieee32) -> Option<Ieee32>;
    fn f32_sqrt(&mut self, arg0: Ieee32) -> Option<Ieee32>;
    fn f32_ceil(&mut self, arg0: Ieee32) -> Option<Ieee32>;
    fn f32_floor(&mut self, arg0: Ieee32) -> Option<Ieee32>;
    fn f32_trunc(&mut self, arg0: Ieee32) -> Option<Ieee32>;
    fn f32_nearest(&mut self, arg0: Ieee32) -> Option<Ieee32>;
    fn f32_min(&mut self, arg0: Ieee32, arg1: Ieee32) -> Option<Ieee32>;
    fn f32_max(&mut self, arg0: Ieee32, arg1: Ieee32) -> Option<Ieee32>;
    fn f32_neg(&mut self, arg0: Ieee32) -> Ieee32;
    fn f32_abs(&mut self, arg0: Ieee32) -> Ieee32;
    fn f32_copysign(&mut self, arg0: Ieee32, arg1: Ieee32) -> Ieee32;
    fn f64_add(&mut self, arg0: Ieee64, arg1: Ieee64) -> Option<Ieee64>;
    fn f64_sub(&mut self, arg0: Ieee64, arg1: Ieee64) -> Option<Ieee64>;
    fn f64_mul(&mut self, arg0: Ieee64, arg1: Ieee64) -> Option<Ieee64>;
    fn f64_div(&mut self, arg0: Ieee64, arg1: Ieee64) -> Option<Ieee64>;
    fn f64_sqrt(&mut self, arg0: Ieee64) -> Option<Ieee64>;
    fn f64_ceil(&mut self, arg0: Ieee64) -> Option<Ieee64>;
    fn f64_floor(&mut self, arg0: Ieee64) -> Option<Ieee64>;
    fn f64_trunc(&mut self, arg0: Ieee64) -> Option<Ieee64>;
    fn f64_nearest(&mut self, arg0: Ieee64) -> Option<Ieee64>;
    fn f64_min(&mut self, arg0: Ieee64, arg1: Ieee64) -> Option<Ieee64>;
    fn f64_max(&mut self, arg0: Ieee64, arg1: Ieee64) -> Option<Ieee64>;
    fn f64_neg(&mut self, arg0: Ieee64) -> Ieee64;
    fn f64_abs(&mut self, arg0: Ieee64) -> Ieee64;
    fn f64_copysign(&mut self, arg0: Ieee64, arg1: Ieee64) -> Ieee64;
    fn f128_min(&mut self, arg0: Ieee128, arg1: Ieee128) -> Option<Ieee128>;
    fn f128_max(&mut self, arg0: Ieee128, arg1: Ieee128) -> Option<Ieee128>;
    fn f128_neg(&mut self, arg0: Ieee128) -> Ieee128;
    fn f128_abs(&mut self, arg0: Ieee128) -> Ieee128;
    fn f128_copysign(&mut self, arg0: Ieee128, arg1: Ieee128) -> Ieee128;
    fn ty_umin(&mut self, arg0: Type) -> u64;
    fn ty_umax(&mut self, arg0: Type) -> u64;
    fn ty_smin(&mut self, arg0: Type) -> u64;
    fn ty_smax(&mut self, arg0: Type) -> u64;
    fn ty_bits(&mut self, arg0: Type) -> u8;
    fn ty_bits_u16(&mut self, arg0: Type) -> u16;
    fn ty_bits_u64(&mut self, arg0: Type) -> u64;
    fn ty_mask(&mut self, arg0: Type) -> u64;
    fn ty_lane_mask(&mut self, arg0: Type) -> u64;
    fn ty_lane_count(&mut self, arg0: Type) -> u64;
    fn ty_bytes(&mut self, arg0: Type) -> u16;
    fn lane_type(&mut self, arg0: Type) -> Type;
    fn ty_half_lanes(&mut self, arg0: Type) -> Option<Type>;
    fn ty_half_width(&mut self, arg0: Type) -> Option<Type>;
    fn ty_equal(&mut self, arg0: Type, arg1: Type) -> bool;
    fn mem_flags_trusted(&mut self, ) -> MemFlags;
    fn mem_flags_data(&mut self, arg0: MemFlags) -> Option<MemFlagsData>;
    fn mem_flags_intern(&mut self, arg0: MemFlagsData) -> MemFlags;
    fn mem_flags_trusted_data(&mut self, ) -> MemFlagsData;
    fn little_or_native_endian(&mut self, arg0: MemFlags) -> Option<MemFlagsData>;
    fn intcc_swap_args(&mut self, arg0: &IntCC) -> IntCC;
    fn intcc_complement(&mut self, arg0: &IntCC) -> IntCC;
    fn intcc_without_eq(&mut self, arg0: &IntCC) -> IntCC;
    fn floatcc_swap_args(&mut self, arg0: &FloatCC) -> FloatCC;
    fn floatcc_complement(&mut self, arg0: &FloatCC) -> FloatCC;
    fn floatcc_unordered(&mut self, arg0: &FloatCC) -> bool;
    fn fits_in_16(&mut self, arg0: Type) -> Option<Type>;
    fn fits_in_32(&mut self, arg0: Type) -> Option<Type>;
    fn lane_fits_in_32(&mut self, arg0: Type) -> Option<Type>;
    fn fits_in_64(&mut self, arg0: Type) -> Option<Type>;
    fn ty_16(&mut self, arg0: Type) -> Option<Type>;
    fn ty_32(&mut self, arg0: Type) -> Option<Type>;
    fn ty_64(&mut self, arg0: Type) -> Option<Type>;
    fn ty_128(&mut self, arg0: Type) -> Option<Type>;
    fn ty_int_ref_scalar_64_extract(&mut self, arg0: Type) -> Option<Type>;
    fn ty_int_ref_scalar_64(&mut self, arg0: Type) -> Option<Type>;
    fn ty_32_or_64(&mut self, arg0: Type) -> Option<Type>;
    fn ty_8_or_16(&mut self, arg0: Type) -> Option<Type>;
    fn ty_16_or_32(&mut self, arg0: Type) -> Option<Type>;
    fn int_fits_in_32(&mut self, arg0: Type) -> Option<Type>;
    fn ty_int_ref_64(&mut self, arg0: Type) -> Option<Type>;
    fn ty_int_ref_16_to_64(&mut self, arg0: Type) -> Option<Type>;
    fn ty_int(&mut self, arg0: Type) -> Option<Type>;
    fn ty_scalar(&mut self, arg0: Type) -> Option<Type>;
    fn ty_scalar_float(&mut self, arg0: Type) -> Option<Type>;
    fn ty_float_or_vec(&mut self, arg0: Type) -> Option<Type>;
    fn ty_vector_float(&mut self, arg0: Type) -> Option<Type>;
    fn ty_vector_not_float(&mut self, arg0: Type) -> Option<Type>;
    fn ty_vec64(&mut self, arg0: Type) -> Option<Type>;
    fn ty_vec64_ctor(&mut self, arg0: Type) -> Option<Type>;
    fn ty_vec128(&mut self, arg0: Type) -> Option<Type>;
    fn ty_int_vec128(&mut self, arg0: Type) -> Option<Type>;
    fn ty_dyn_vec64(&mut self, arg0: Type) -> Option<Type>;
    fn ty_dyn_vec128(&mut self, arg0: Type) -> Option<Type>;
    fn ty_vec64_int(&mut self, arg0: Type) -> Option<Type>;
    fn ty_vec128_int(&mut self, arg0: Type) -> Option<Type>;
    fn ty_addr64(&mut self, arg0: Type) -> Option<Type>;
    fn not_vec32x2(&mut self, arg0: Type) -> Option<Type>;
    fn not_i64x2(&mut self, arg0: Type) -> Option<()>;
    fn u8_from_uimm8(&mut self, arg0: Uimm8) -> u8;
    fn u64_from_bool(&mut self, arg0: bool) -> u64;
    fn u64_from_imm64(&mut self, arg0: Imm64) -> u64;
    fn nonzero_u64_from_imm64(&mut self, arg0: Imm64) -> Option<u64>;
    fn imm64_power_of_two(&mut self, arg0: Imm64) -> Option<u64>;
    fn imm64(&mut self, arg0: u64) -> Imm64;
    fn imm64_masked(&mut self, arg0: Type, arg1: u64) -> Imm64;
    fn u16_from_ieee16(&mut self, arg0: Ieee16) -> u16;
    fn u32_from_ieee32(&mut self, arg0: Ieee32) -> u32;
    fn u64_from_ieee64(&mut self, arg0: Ieee64) -> u64;
    fn multi_lane(&mut self, arg0: Type) -> Option<(u32, u32)>;
    fn dynamic_lane(&mut self, arg0: Type) -> Option<(u32, u32)>;
    fn ty_dyn64_int(&mut self, arg0: Type) -> Option<Type>;
    fn ty_dyn128_int(&mut self, arg0: Type) -> Option<Type>;
    fn offset32_to_i32(&mut self, arg0: Offset32) -> i32;
    fn i32_to_offset32(&mut self, arg0: i32) -> Offset32;
    fn intcc_unsigned(&mut self, arg0: &IntCC) -> IntCC;
    fn signed_cond_code(&mut self, arg0: &IntCC) -> Option<IntCC>;
    fn unsigned_cond_code(&mut self, arg0: &IntCC) -> Option<IntCC>;
    fn trap_code_division_by_zero(&mut self, ) -> TrapCode;
    fn trap_code_integer_overflow(&mut self, ) -> TrapCode;
    fn trap_code_bad_conversion_to_integer(&mut self, ) -> TrapCode;
    fn value_reg(&mut self, arg0: Reg) -> ValueRegs;
    fn writable_value_reg(&mut self, arg0: WritableReg) -> WritableValueRegs;
    fn value_regs(&mut self, arg0: Reg, arg1: Reg) -> ValueRegs;
    fn writable_value_regs(&mut self, arg0: WritableReg, arg1: WritableReg) -> WritableValueRegs;
    fn value_regs_invalid(&mut self, ) -> ValueRegs;
    fn output_none(&mut self, ) -> InstOutput;
    fn output(&mut self, arg0: ValueRegs) -> InstOutput;
    fn output_pair(&mut self, arg0: ValueRegs, arg1: ValueRegs) -> InstOutput;
    fn output_vec(&mut self, arg0: &ValueRegsVec) -> InstOutput;
    fn temp_writable_reg(&mut self, arg0: Type) -> WritableReg;
    fn is_valid_reg(&mut self, arg0: Reg) -> bool;
    fn invalid_reg(&mut self, ) -> Reg;
    fn mark_value_used(&mut self, arg0: Value) -> Unit;
    fn put_in_reg(&mut self, arg0: Value) -> Reg;
    fn put_in_regs(&mut self, arg0: Value) -> ValueRegs;
    fn put_in_regs_vec(&mut self, arg0: ValueSlice) -> ValueRegsVec;
    fn value_regs_get(&mut self, arg0: ValueRegs, arg1: usize) -> Reg;
    fn value_regs_len(&mut self, arg0: ValueRegs) -> usize;
    fn preg_to_reg(&mut self, arg0: PReg) -> Reg;
    fn single_target(&mut self, arg0: &MachLabelSlice) -> Option<MachLabel>;
    fn two_targets(&mut self, arg0: &MachLabelSlice) -> Option<(MachLabel, MachLabel)>;
    fn jump_table_targets(&mut self, arg0: &MachLabelSlice) -> Option<(MachLabel, BoxVecMachLabel)>;
    fn jump_table_size(&mut self, arg0: &BoxVecMachLabel) -> u32;
    fn value_list_slice(&mut self, arg0: ValueList) -> ValueSlice;
    fn value_slice_empty(&mut self, arg0: ValueSlice) -> Option<()>;
    fn value_slice_unwrap(&mut self, arg0: ValueSlice) -> Option<(Value, ValueSlice)>;
    fn value_slice_len(&mut self, arg0: ValueSlice) -> usize;
    fn value_slice_get(&mut self, arg0: ValueSlice, arg1: usize) -> Value;
    fn writable_reg_to_reg(&mut self, arg0: WritableReg) -> Reg;
    fn inst_results(&mut self, arg0: Inst) -> ValueSlice;
    fn value_is_unused(&mut self, arg0: Value) -> bool;
    fn first_result(&mut self, arg0: Inst) -> Option<Value>;
    fn inst_data_value(&mut self, arg0: Inst) -> (Type, InstructionData);
    fn i64_from_iconst(&mut self, arg0: Value) -> Option<i64>;
    fn zero_value(&mut self, arg0: Value) -> Option<Value>;
    fn is_sinkable_inst(&mut self, arg0: Value) -> Option<Inst>;
    fn maybe_uextend(&mut self, arg0: Value) -> Option<Value>;
    fn uimm8(&mut self, arg0: Imm64) -> Option<u8>;
    fn block_exn_successor_label(&mut self, arg0: &Block, arg1: u64) -> MachLabel;
    fn emit(&mut self, arg0: &MInst) -> Unit;
    fn sink_inst(&mut self, arg0: Inst) -> Unit;
    fn emit_u64_le_const(&mut self, arg0: u64) -> VCodeConstant;
    fn emit_u64_be_const(&mut self, arg0: u64) -> VCodeConstant;
    fn emit_u128_le_const(&mut self, arg0: u128) -> VCodeConstant;
    fn emit_u128_be_const(&mut self, arg0: u128) -> VCodeConstant;
    fn const_to_vconst(&mut self, arg0: Constant) -> VCodeConstant;
    fn tls_model(&mut self, arg0: Type) -> TlsModel;
    fn tls_model_is_elf_gd(&mut self, ) -> Option<Unit>;
    fn tls_model_is_macho(&mut self, ) -> Option<Unit>;
    fn tls_model_is_coff(&mut self, ) -> Option<Unit>;
    fn preserve_frame_pointers(&mut self, ) -> Option<Unit>;
    fn stack_switch_model(&mut self, ) -> Option<StackSwitchModel>;
    fn box_external_name(&mut self, arg0: ExternalName) -> BoxExternalName;
    fn func_ref_data(&mut self, arg0: FuncRef) -> (SigRef, ExternalName, RelocDistance, bool);
    fn exception_sig(&mut self, arg0: ExceptionTable) -> SigRef;
    fn symbol_value_data(&mut self, arg0: GlobalValue) -> Option<(ExternalName, RelocDistance, i64)>;
    fn vec_mask_from_immediate(&mut self, arg0: Immediate) -> Option<VecMask>;
    fn u128_from_immediate(&mut self, arg0: Immediate) -> Option<u128>;
    fn vconst_from_immediate(&mut self, arg0: Immediate) -> Option<VCodeConstant>;
    fn u128_from_constant(&mut self, arg0: Constant) -> Option<u128>;
    fn u64_from_constant(&mut self, arg0: Constant) -> Option<u64>;
    fn shuffle64_from_imm(&mut self, arg0: Immediate) -> Option<(u8, u8)>;
    fn shuffle32_from_imm(&mut self, arg0: Immediate) -> Option<(u8, u8, u8, u8)>;
    fn shuffle16_from_imm(&mut self, arg0: Immediate) -> Option<(u8, u8, u8, u8, u8, u8, u8, u8)>;
    fn only_writable_reg(&mut self, arg0: WritableValueRegs) -> Option<WritableReg>;
    fn writable_regs_get(&mut self, arg0: WritableValueRegs, arg1: usize) -> WritableReg;
    fn abi_sig(&mut self, arg0: SigRef) -> Sig;
    fn abi_num_args(&mut self, arg0: Sig) -> usize;
    fn abi_get_arg(&mut self, arg0: Sig, arg1: usize) -> ABIArg;
    fn abi_num_rets(&mut self, arg0: Sig) -> usize;
    fn abi_get_ret(&mut self, arg0: Sig, arg1: usize) -> ABIArg;
    fn abi_ret_arg(&mut self, arg0: Sig) -> Option<ABIArg>;
    fn abi_no_ret_arg(&mut self, arg0: Sig) -> Option<()>;
    fn abi_unwrap_ret_area_ptr(&mut self, ) -> Reg;
    fn abi_stackslot_addr(&mut self, arg0: WritableReg, arg1: StackSlot, arg2: Offset32) -> MInst;
    fn abi_stackslot_offset_into_slot_region(&mut self, arg0: StackSlot, arg1: Offset32, arg2: Offset32) -> i32;
    fn abi_dynamic_stackslot_addr(&mut self, arg0: WritableReg, arg1: DynamicStackSlot) -> MInst;
    fn abi_arg_only_slot(&mut self, arg0: &ABIArg) -> Option<ABIArgSlot>;
    fn abi_arg_implicit_pointer(&mut self, arg0: &ABIArg) -> Option<(ABIArgSlot, i64, Type)>;
    fn real_reg_to_reg(&mut self, arg0: RealReg) -> Reg;
    fn real_reg_to_writable_reg(&mut self, arg0: RealReg) -> WritableReg;
    fn gen_move(&mut self, arg0: Type, arg1: WritableReg, arg2: Reg) -> MInst;
    fn gen_return(&mut self, arg0: &ValueRegsVec) -> Unit;
    fn gen_call_output(&mut self, arg0: SigRef) -> ValueRegsVec;
    fn gen_call_args(&mut self, arg0: Sig, arg1: &ValueRegsVec) -> CallArgList;
    fn gen_return_call_args(&mut self, arg0: Sig, arg1: &ValueRegsVec) -> CallArgList;
    fn gen_call_rets(&mut self, arg0: Sig, arg1: &ValueRegsVec) -> CallRetList;
    fn gen_try_call_rets(&mut self, arg0: Sig) -> CallRetList;
    fn gen_patchable_call_rets(&mut self, ) -> CallRetList;
    fn try_call_info(&mut self, arg0: ExceptionTable, arg1: &MachLabelSlice) -> OptionTryCallInfo;
    fn try_call_none(&mut self, ) -> OptionTryCallInfo;
    fn safe_divisor_from_imm64(&mut self, arg0: Type, arg1: Imm64) -> Option<u64>;
    fn cond_invert(&mut self, arg0: &Cond) -> Cond;
    fn endianness(&mut self, arg0: MemFlagsData) -> Endianness;
    fn is_native_endianness(&mut self, arg0: &Endianness) -> bool;
    fn pointer_width(&mut self, ) -> PointerWidth;
    fn memflags_nontrapping(&mut self, arg0: MemFlagsData) -> bool;
    fn memflags_trapping(&mut self, arg0: MemFlagsData) -> Option<TrapCode>;
    fn memflags_is_wasm(&mut self, arg0: MemFlagsData) -> bool;
    fn g32_offset(&mut self, arg0: i32, arg1: Type, arg2: u64) -> Option<u16>;
    fn xreg_new(&mut self, arg0: Reg) -> XReg;
    fn writable_xreg_new(&mut self, arg0: WritableReg) -> WritableXReg;
    fn writable_xreg_to_xreg(&mut self, arg0: WritableXReg) -> XReg;
    fn writable_xreg_to_writable_reg(&mut self, arg0: WritableXReg) -> WritableReg;
    fn xreg_to_reg(&mut self, arg0: XReg) -> Reg;
    fn freg_new(&mut self, arg0: Reg) -> FReg;
    fn writable_freg_new(&mut self, arg0: WritableReg) -> WritableFReg;
    fn writable_freg_to_freg(&mut self, arg0: WritableFReg) -> FReg;
    fn writable_freg_to_writable_reg(&mut self, arg0: WritableFReg) -> WritableReg;
    fn freg_to_reg(&mut self, arg0: FReg) -> Reg;
    fn vreg_new(&mut self, arg0: Reg) -> VReg;
    fn writable_vreg_new(&mut self, arg0: WritableReg) -> WritableVReg;
    fn writable_vreg_to_vreg(&mut self, arg0: WritableVReg) -> VReg;
    fn writable_vreg_to_writable_reg(&mut self, arg0: WritableVReg) -> WritableReg;
    fn vreg_to_reg(&mut self, arg0: VReg) -> Reg;
    fn sp_reg(&mut self, ) -> XReg;
    fn gen_call_info(&mut self, arg0: Sig, arg1: ExternalName, arg2: CallArgList, arg3: CallRetList, arg4: OptionTryCallInfo, arg5: bool) -> BoxCallInfo;
    fn gen_call_ind_info(&mut self, arg0: Sig, arg1: Reg, arg2: CallArgList, arg3: CallRetList, arg4: OptionTryCallInfo) -> BoxCallIndInfo;
    fn gen_call_host_info(&mut self, arg0: Sig, arg1: ExternalName, arg2: CallArgList, arg3: CallRetList, arg4: OptionTryCallInfo) -> BoxCallIndirectHostInfo;
    fn gen_return_call_info(&mut self, arg0: Sig, arg1: ExternalName, arg2: CallArgList) -> BoxReturnCallInfo;
    fn gen_return_call_ind_info(&mut self, arg0: Sig, arg1: Reg, arg2: CallArgList) -> BoxReturnCallIndInfo;
    fn u6_from_u8(&mut self, arg0: u8) -> Option<U6>;
    fn i8_eq(&mut self, arg0: i8, arg1: i8) -> bool;
    fn i8_ne(&mut self, arg0: i8, arg1: i8) -> bool;
    fn i8_lt(&mut self, arg0: i8, arg1: i8) -> bool;
    fn i8_lt_eq(&mut self, arg0: i8, arg1: i8) -> bool;
    fn i8_gt(&mut self, arg0: i8, arg1: i8) -> bool;
    fn i8_gt_eq(&mut self, arg0: i8, arg1: i8) -> bool;
    fn i8_checked_add(&mut self, arg0: i8, arg1: i8) -> Option<i8>;
    fn i8_wrapping_add(&mut self, arg0: i8, arg1: i8) -> i8;
    fn i8_add(&mut self, arg0: i8, arg1: i8) -> i8;
    fn i8_checked_sub(&mut self, arg0: i8, arg1: i8) -> Option<i8>;
    fn i8_wrapping_sub(&mut self, arg0: i8, arg1: i8) -> i8;
    fn i8_sub(&mut self, arg0: i8, arg1: i8) -> i8;
    fn i8_checked_mul(&mut self, arg0: i8, arg1: i8) -> Option<i8>;
    fn i8_wrapping_mul(&mut self, arg0: i8, arg1: i8) -> i8;
    fn i8_mul(&mut self, arg0: i8, arg1: i8) -> i8;
    fn i8_checked_div(&mut self, arg0: i8, arg1: i8) -> Option<i8>;
    fn i8_wrapping_div(&mut self, arg0: i8, arg1: i8) -> i8;
    fn i8_div(&mut self, arg0: i8, arg1: i8) -> i8;
    fn i8_checked_rem(&mut self, arg0: i8, arg1: i8) -> Option<i8>;
    fn i8_rem(&mut self, arg0: i8, arg1: i8) -> i8;
    fn i8_and(&mut self, arg0: i8, arg1: i8) -> i8;
    fn i8_or(&mut self, arg0: i8, arg1: i8) -> i8;
    fn i8_xor(&mut self, arg0: i8, arg1: i8) -> i8;
    fn i8_not(&mut self, arg0: i8) -> i8;
    fn i8_checked_shl(&mut self, arg0: i8, arg1: u32) -> Option<i8>;
    fn i8_wrapping_shl(&mut self, arg0: i8, arg1: u32) -> i8;
    fn i8_shl(&mut self, arg0: i8, arg1: u32) -> i8;
    fn i8_checked_shr(&mut self, arg0: i8, arg1: u32) -> Option<i8>;
    fn i8_wrapping_shr(&mut self, arg0: i8, arg1: u32) -> i8;
    fn i8_shr(&mut self, arg0: i8, arg1: u32) -> i8;
    fn i8_rotl(&mut self, arg0: i8, arg1: u32) -> i8;
    fn i8_rotr(&mut self, arg0: i8, arg1: u32) -> i8;
    fn i8_is_zero(&mut self, arg0: i8) -> bool;
    fn i8_matches_zero(&mut self, arg0: i8) -> Option<bool>;
    fn i8_is_non_zero(&mut self, arg0: i8) -> bool;
    fn i8_matches_non_zero(&mut self, arg0: i8) -> Option<bool>;
    fn i8_is_odd(&mut self, arg0: i8) -> bool;
    fn i8_matches_odd(&mut self, arg0: i8) -> Option<bool>;
    fn i8_is_even(&mut self, arg0: i8) -> bool;
    fn i8_matches_even(&mut self, arg0: i8) -> Option<bool>;
    fn i8_checked_ilog2(&mut self, arg0: i8) -> Option<u32>;
    fn i8_ilog2(&mut self, arg0: i8) -> u32;
    fn i8_trailing_zeros(&mut self, arg0: i8) -> u32;
    fn i8_trailing_ones(&mut self, arg0: i8) -> u32;
    fn i8_leading_zeros(&mut self, arg0: i8) -> u32;
    fn i8_leading_ones(&mut self, arg0: i8) -> u32;
    fn i8_checked_neg(&mut self, arg0: i8) -> Option<i8>;
    fn i8_wrapping_neg(&mut self, arg0: i8) -> i8;
    fn i8_neg(&mut self, arg0: i8) -> i8;
    fn u8_eq(&mut self, arg0: u8, arg1: u8) -> bool;
    fn u8_ne(&mut self, arg0: u8, arg1: u8) -> bool;
    fn u8_lt(&mut self, arg0: u8, arg1: u8) -> bool;
    fn u8_lt_eq(&mut self, arg0: u8, arg1: u8) -> bool;
    fn u8_gt(&mut self, arg0: u8, arg1: u8) -> bool;
    fn u8_gt_eq(&mut self, arg0: u8, arg1: u8) -> bool;
    fn u8_checked_add(&mut self, arg0: u8, arg1: u8) -> Option<u8>;
    fn u8_wrapping_add(&mut self, arg0: u8, arg1: u8) -> u8;
    fn u8_add(&mut self, arg0: u8, arg1: u8) -> u8;
    fn u8_checked_sub(&mut self, arg0: u8, arg1: u8) -> Option<u8>;
    fn u8_wrapping_sub(&mut self, arg0: u8, arg1: u8) -> u8;
    fn u8_sub(&mut self, arg0: u8, arg1: u8) -> u8;
    fn u8_checked_mul(&mut self, arg0: u8, arg1: u8) -> Option<u8>;
    fn u8_wrapping_mul(&mut self, arg0: u8, arg1: u8) -> u8;
    fn u8_mul(&mut self, arg0: u8, arg1: u8) -> u8;
    fn u8_checked_div(&mut self, arg0: u8, arg1: u8) -> Option<u8>;
    fn u8_wrapping_div(&mut self, arg0: u8, arg1: u8) -> u8;
    fn u8_div(&mut self, arg0: u8, arg1: u8) -> u8;
    fn u8_checked_rem(&mut self, arg0: u8, arg1: u8) -> Option<u8>;
    fn u8_rem(&mut self, arg0: u8, arg1: u8) -> u8;
    fn u8_and(&mut self, arg0: u8, arg1: u8) -> u8;
    fn u8_or(&mut self, arg0: u8, arg1: u8) -> u8;
    fn u8_xor(&mut self, arg0: u8, arg1: u8) -> u8;
    fn u8_not(&mut self, arg0: u8) -> u8;
    fn u8_checked_shl(&mut self, arg0: u8, arg1: u32) -> Option<u8>;
    fn u8_wrapping_shl(&mut self, arg0: u8, arg1: u32) -> u8;
    fn u8_shl(&mut self, arg0: u8, arg1: u32) -> u8;
    fn u8_checked_shr(&mut self, arg0: u8, arg1: u32) -> Option<u8>;
    fn u8_wrapping_shr(&mut self, arg0: u8, arg1: u32) -> u8;
    fn u8_shr(&mut self, arg0: u8, arg1: u32) -> u8;
    fn u8_rotl(&mut self, arg0: u8, arg1: u32) -> u8;
    fn u8_rotr(&mut self, arg0: u8, arg1: u32) -> u8;
    fn u8_is_zero(&mut self, arg0: u8) -> bool;
    fn u8_matches_zero(&mut self, arg0: u8) -> Option<bool>;
    fn u8_is_non_zero(&mut self, arg0: u8) -> bool;
    fn u8_matches_non_zero(&mut self, arg0: u8) -> Option<bool>;
    fn u8_is_odd(&mut self, arg0: u8) -> bool;
    fn u8_matches_odd(&mut self, arg0: u8) -> Option<bool>;
    fn u8_is_even(&mut self, arg0: u8) -> bool;
    fn u8_matches_even(&mut self, arg0: u8) -> Option<bool>;
    fn u8_checked_ilog2(&mut self, arg0: u8) -> Option<u32>;
    fn u8_ilog2(&mut self, arg0: u8) -> u32;
    fn u8_trailing_zeros(&mut self, arg0: u8) -> u32;
    fn u8_trailing_ones(&mut self, arg0: u8) -> u32;
    fn u8_leading_zeros(&mut self, arg0: u8) -> u32;
    fn u8_leading_ones(&mut self, arg0: u8) -> u32;
    fn u8_is_power_of_two(&mut self, arg0: u8) -> bool;
    fn u8_matches_power_of_two(&mut self, arg0: u8) -> Option<bool>;
    fn i16_eq(&mut self, arg0: i16, arg1: i16) -> bool;
    fn i16_ne(&mut self, arg0: i16, arg1: i16) -> bool;
    fn i16_lt(&mut self, arg0: i16, arg1: i16) -> bool;
    fn i16_lt_eq(&mut self, arg0: i16, arg1: i16) -> bool;
    fn i16_gt(&mut self, arg0: i16, arg1: i16) -> bool;
    fn i16_gt_eq(&mut self, arg0: i16, arg1: i16) -> bool;
    fn i16_checked_add(&mut self, arg0: i16, arg1: i16) -> Option<i16>;
    fn i16_wrapping_add(&mut self, arg0: i16, arg1: i16) -> i16;
    fn i16_add(&mut self, arg0: i16, arg1: i16) -> i16;
    fn i16_checked_sub(&mut self, arg0: i16, arg1: i16) -> Option<i16>;
    fn i16_wrapping_sub(&mut self, arg0: i16, arg1: i16) -> i16;
    fn i16_sub(&mut self, arg0: i16, arg1: i16) -> i16;
    fn i16_checked_mul(&mut self, arg0: i16, arg1: i16) -> Option<i16>;
    fn i16_wrapping_mul(&mut self, arg0: i16, arg1: i16) -> i16;
    fn i16_mul(&mut self, arg0: i16, arg1: i16) -> i16;
    fn i16_checked_div(&mut self, arg0: i16, arg1: i16) -> Option<i16>;
    fn i16_wrapping_div(&mut self, arg0: i16, arg1: i16) -> i16;
    fn i16_div(&mut self, arg0: i16, arg1: i16) -> i16;
    fn i16_checked_rem(&mut self, arg0: i16, arg1: i16) -> Option<i16>;
    fn i16_rem(&mut self, arg0: i16, arg1: i16) -> i16;
    fn i16_and(&mut self, arg0: i16, arg1: i16) -> i16;
    fn i16_or(&mut self, arg0: i16, arg1: i16) -> i16;
    fn i16_xor(&mut self, arg0: i16, arg1: i16) -> i16;
    fn i16_not(&mut self, arg0: i16) -> i16;
    fn i16_checked_shl(&mut self, arg0: i16, arg1: u32) -> Option<i16>;
    fn i16_wrapping_shl(&mut self, arg0: i16, arg1: u32) -> i16;
    fn i16_shl(&mut self, arg0: i16, arg1: u32) -> i16;
    fn i16_checked_shr(&mut self, arg0: i16, arg1: u32) -> Option<i16>;
    fn i16_wrapping_shr(&mut self, arg0: i16, arg1: u32) -> i16;
    fn i16_shr(&mut self, arg0: i16, arg1: u32) -> i16;
    fn i16_rotl(&mut self, arg0: i16, arg1: u32) -> i16;
    fn i16_rotr(&mut self, arg0: i16, arg1: u32) -> i16;
    fn i16_is_zero(&mut self, arg0: i16) -> bool;
    fn i16_matches_zero(&mut self, arg0: i16) -> Option<bool>;
    fn i16_is_non_zero(&mut self, arg0: i16) -> bool;
    fn i16_matches_non_zero(&mut self, arg0: i16) -> Option<bool>;
    fn i16_is_odd(&mut self, arg0: i16) -> bool;
    fn i16_matches_odd(&mut self, arg0: i16) -> Option<bool>;
    fn i16_is_even(&mut self, arg0: i16) -> bool;
    fn i16_matches_even(&mut self, arg0: i16) -> Option<bool>;
    fn i16_checked_ilog2(&mut self, arg0: i16) -> Option<u32>;
    fn i16_ilog2(&mut self, arg0: i16) -> u32;
    fn i16_trailing_zeros(&mut self, arg0: i16) -> u32;
    fn i16_trailing_ones(&mut self, arg0: i16) -> u32;
    fn i16_leading_zeros(&mut self, arg0: i16) -> u32;
    fn i16_leading_ones(&mut self, arg0: i16) -> u32;
    fn i16_checked_neg(&mut self, arg0: i16) -> Option<i16>;
    fn i16_wrapping_neg(&mut self, arg0: i16) -> i16;
    fn i16_neg(&mut self, arg0: i16) -> i16;
    fn u16_eq(&mut self, arg0: u16, arg1: u16) -> bool;
    fn u16_ne(&mut self, arg0: u16, arg1: u16) -> bool;
    fn u16_lt(&mut self, arg0: u16, arg1: u16) -> bool;
    fn u16_lt_eq(&mut self, arg0: u16, arg1: u16) -> bool;
    fn u16_gt(&mut self, arg0: u16, arg1: u16) -> bool;
    fn u16_gt_eq(&mut self, arg0: u16, arg1: u16) -> bool;
    fn u16_checked_add(&mut self, arg0: u16, arg1: u16) -> Option<u16>;
    fn u16_wrapping_add(&mut self, arg0: u16, arg1: u16) -> u16;
    fn u16_add(&mut self, arg0: u16, arg1: u16) -> u16;
    fn u16_checked_sub(&mut self, arg0: u16, arg1: u16) -> Option<u16>;
    fn u16_wrapping_sub(&mut self, arg0: u16, arg1: u16) -> u16;
    fn u16_sub(&mut self, arg0: u16, arg1: u16) -> u16;
    fn u16_checked_mul(&mut self, arg0: u16, arg1: u16) -> Option<u16>;
    fn u16_wrapping_mul(&mut self, arg0: u16, arg1: u16) -> u16;
    fn u16_mul(&mut self, arg0: u16, arg1: u16) -> u16;
    fn u16_checked_div(&mut self, arg0: u16, arg1: u16) -> Option<u16>;
    fn u16_wrapping_div(&mut self, arg0: u16, arg1: u16) -> u16;
    fn u16_div(&mut self, arg0: u16, arg1: u16) -> u16;
    fn u16_checked_rem(&mut self, arg0: u16, arg1: u16) -> Option<u16>;
    fn u16_rem(&mut self, arg0: u16, arg1: u16) -> u16;
    fn u16_and(&mut self, arg0: u16, arg1: u16) -> u16;
    fn u16_or(&mut self, arg0: u16, arg1: u16) -> u16;
    fn u16_xor(&mut self, arg0: u16, arg1: u16) -> u16;
    fn u16_not(&mut self, arg0: u16) -> u16;
    fn u16_checked_shl(&mut self, arg0: u16, arg1: u32) -> Option<u16>;
    fn u16_wrapping_shl(&mut self, arg0: u16, arg1: u32) -> u16;
    fn u16_shl(&mut self, arg0: u16, arg1: u32) -> u16;
    fn u16_checked_shr(&mut self, arg0: u16, arg1: u32) -> Option<u16>;
    fn u16_wrapping_shr(&mut self, arg0: u16, arg1: u32) -> u16;
    fn u16_shr(&mut self, arg0: u16, arg1: u32) -> u16;
    fn u16_rotl(&mut self, arg0: u16, arg1: u32) -> u16;
    fn u16_rotr(&mut self, arg0: u16, arg1: u32) -> u16;
    fn u16_is_zero(&mut self, arg0: u16) -> bool;
    fn u16_matches_zero(&mut self, arg0: u16) -> Option<bool>;
    fn u16_is_non_zero(&mut self, arg0: u16) -> bool;
    fn u16_matches_non_zero(&mut self, arg0: u16) -> Option<bool>;
    fn u16_is_odd(&mut self, arg0: u16) -> bool;
    fn u16_matches_odd(&mut self, arg0: u16) -> Option<bool>;
    fn u16_is_even(&mut self, arg0: u16) -> bool;
    fn u16_matches_even(&mut self, arg0: u16) -> Option<bool>;
    fn u16_checked_ilog2(&mut self, arg0: u16) -> Option<u32>;
    fn u16_ilog2(&mut self, arg0: u16) -> u32;
    fn u16_trailing_zeros(&mut self, arg0: u16) -> u32;
    fn u16_trailing_ones(&mut self, arg0: u16) -> u32;
    fn u16_leading_zeros(&mut self, arg0: u16) -> u32;
    fn u16_leading_ones(&mut self, arg0: u16) -> u32;
    fn u16_is_power_of_two(&mut self, arg0: u16) -> bool;
    fn u16_matches_power_of_two(&mut self, arg0: u16) -> Option<bool>;
    fn i32_eq(&mut self, arg0: i32, arg1: i32) -> bool;
    fn i32_ne(&mut self, arg0: i32, arg1: i32) -> bool;
    fn i32_lt(&mut self, arg0: i32, arg1: i32) -> bool;
    fn i32_lt_eq(&mut self, arg0: i32, arg1: i32) -> bool;
    fn i32_gt(&mut self, arg0: i32, arg1: i32) -> bool;
    fn i32_gt_eq(&mut self, arg0: i32, arg1: i32) -> bool;
    fn i32_checked_add(&mut self, arg0: i32, arg1: i32) -> Option<i32>;
    fn i32_wrapping_add(&mut self, arg0: i32, arg1: i32) -> i32;
    fn i32_add(&mut self, arg0: i32, arg1: i32) -> i32;
    fn i32_checked_sub(&mut self, arg0: i32, arg1: i32) -> Option<i32>;
    fn i32_wrapping_sub(&mut self, arg0: i32, arg1: i32) -> i32;
    fn i32_sub(&mut self, arg0: i32, arg1: i32) -> i32;
    fn i32_checked_mul(&mut self, arg0: i32, arg1: i32) -> Option<i32>;
    fn i32_wrapping_mul(&mut self, arg0: i32, arg1: i32) -> i32;
    fn i32_mul(&mut self, arg0: i32, arg1: i32) -> i32;
    fn i32_checked_div(&mut self, arg0: i32, arg1: i32) -> Option<i32>;
    fn i32_wrapping_div(&mut self, arg0: i32, arg1: i32) -> i32;
    fn i32_div(&mut self, arg0: i32, arg1: i32) -> i32;
    fn i32_checked_rem(&mut self, arg0: i32, arg1: i32) -> Option<i32>;
    fn i32_rem(&mut self, arg0: i32, arg1: i32) -> i32;
    fn i32_and(&mut self, arg0: i32, arg1: i32) -> i32;
    fn i32_or(&mut self, arg0: i32, arg1: i32) -> i32;
    fn i32_xor(&mut self, arg0: i32, arg1: i32) -> i32;
    fn i32_not(&mut self, arg0: i32) -> i32;
    fn i32_checked_shl(&mut self, arg0: i32, arg1: u32) -> Option<i32>;
    fn i32_wrapping_shl(&mut self, arg0: i32, arg1: u32) -> i32;
    fn i32_shl(&mut self, arg0: i32, arg1: u32) -> i32;
    fn i32_checked_shr(&mut self, arg0: i32, arg1: u32) -> Option<i32>;
    fn i32_wrapping_shr(&mut self, arg0: i32, arg1: u32) -> i32;
    fn i32_shr(&mut self, arg0: i32, arg1: u32) -> i32;
    fn i32_rotl(&mut self, arg0: i32, arg1: u32) -> i32;
    fn i32_rotr(&mut self, arg0: i32, arg1: u32) -> i32;
    fn i32_is_zero(&mut self, arg0: i32) -> bool;
    fn i32_matches_zero(&mut self, arg0: i32) -> Option<bool>;
    fn i32_is_non_zero(&mut self, arg0: i32) -> bool;
    fn i32_matches_non_zero(&mut self, arg0: i32) -> Option<bool>;
    fn i32_is_odd(&mut self, arg0: i32) -> bool;
    fn i32_matches_odd(&mut self, arg0: i32) -> Option<bool>;
    fn i32_is_even(&mut self, arg0: i32) -> bool;
    fn i32_matches_even(&mut self, arg0: i32) -> Option<bool>;
    fn i32_checked_ilog2(&mut self, arg0: i32) -> Option<u32>;
    fn i32_ilog2(&mut self, arg0: i32) -> u32;
    fn i32_trailing_zeros(&mut self, arg0: i32) -> u32;
    fn i32_trailing_ones(&mut self, arg0: i32) -> u32;
    fn i32_leading_zeros(&mut self, arg0: i32) -> u32;
    fn i32_leading_ones(&mut self, arg0: i32) -> u32;
    fn i32_checked_neg(&mut self, arg0: i32) -> Option<i32>;
    fn i32_wrapping_neg(&mut self, arg0: i32) -> i32;
    fn i32_neg(&mut self, arg0: i32) -> i32;
    fn u32_eq(&mut self, arg0: u32, arg1: u32) -> bool;
    fn u32_ne(&mut self, arg0: u32, arg1: u32) -> bool;
    fn u32_lt(&mut self, arg0: u32, arg1: u32) -> bool;
    fn u32_lt_eq(&mut self, arg0: u32, arg1: u32) -> bool;
    fn u32_gt(&mut self, arg0: u32, arg1: u32) -> bool;
    fn u32_gt_eq(&mut self, arg0: u32, arg1: u32) -> bool;
    fn u32_checked_add(&mut self, arg0: u32, arg1: u32) -> Option<u32>;
    fn u32_wrapping_add(&mut self, arg0: u32, arg1: u32) -> u32;
    fn u32_add(&mut self, arg0: u32, arg1: u32) -> u32;
    fn u32_checked_sub(&mut self, arg0: u32, arg1: u32) -> Option<u32>;
    fn u32_wrapping_sub(&mut self, arg0: u32, arg1: u32) -> u32;
    fn u32_sub(&mut self, arg0: u32, arg1: u32) -> u32;
    fn u32_checked_mul(&mut self, arg0: u32, arg1: u32) -> Option<u32>;
    fn u32_wrapping_mul(&mut self, arg0: u32, arg1: u32) -> u32;
    fn u32_mul(&mut self, arg0: u32, arg1: u32) -> u32;
    fn u32_checked_div(&mut self, arg0: u32, arg1: u32) -> Option<u32>;
    fn u32_wrapping_div(&mut self, arg0: u32, arg1: u32) -> u32;
    fn u32_div(&mut self, arg0: u32, arg1: u32) -> u32;
    fn u32_checked_rem(&mut self, arg0: u32, arg1: u32) -> Option<u32>;
    fn u32_rem(&mut self, arg0: u32, arg1: u32) -> u32;
    fn u32_and(&mut self, arg0: u32, arg1: u32) -> u32;
    fn u32_or(&mut self, arg0: u32, arg1: u32) -> u32;
    fn u32_xor(&mut self, arg0: u32, arg1: u32) -> u32;
    fn u32_not(&mut self, arg0: u32) -> u32;
    fn u32_checked_shl(&mut self, arg0: u32, arg1: u32) -> Option<u32>;
    fn u32_wrapping_shl(&mut self, arg0: u32, arg1: u32) -> u32;
    fn u32_shl(&mut self, arg0: u32, arg1: u32) -> u32;
    fn u32_checked_shr(&mut self, arg0: u32, arg1: u32) -> Option<u32>;
    fn u32_wrapping_shr(&mut self, arg0: u32, arg1: u32) -> u32;
    fn u32_shr(&mut self, arg0: u32, arg1: u32) -> u32;
    fn u32_rotl(&mut self, arg0: u32, arg1: u32) -> u32;
    fn u32_rotr(&mut self, arg0: u32, arg1: u32) -> u32;
    fn u32_is_zero(&mut self, arg0: u32) -> bool;
    fn u32_matches_zero(&mut self, arg0: u32) -> Option<bool>;
    fn u32_is_non_zero(&mut self, arg0: u32) -> bool;
    fn u32_matches_non_zero(&mut self, arg0: u32) -> Option<bool>;
    fn u32_is_odd(&mut self, arg0: u32) -> bool;
    fn u32_matches_odd(&mut self, arg0: u32) -> Option<bool>;
    fn u32_is_even(&mut self, arg0: u32) -> bool;
    fn u32_matches_even(&mut self, arg0: u32) -> Option<bool>;
    fn u32_checked_ilog2(&mut self, arg0: u32) -> Option<u32>;
    fn u32_ilog2(&mut self, arg0: u32) -> u32;
    fn u32_trailing_zeros(&mut self, arg0: u32) -> u32;
    fn u32_trailing_ones(&mut self, arg0: u32) -> u32;
    fn u32_leading_zeros(&mut self, arg0: u32) -> u32;
    fn u32_leading_ones(&mut self, arg0: u32) -> u32;
    fn u32_is_power_of_two(&mut self, arg0: u32) -> bool;
    fn u32_matches_power_of_two(&mut self, arg0: u32) -> Option<bool>;
    fn i64_eq(&mut self, arg0: i64, arg1: i64) -> bool;
    fn i64_ne(&mut self, arg0: i64, arg1: i64) -> bool;
    fn i64_lt(&mut self, arg0: i64, arg1: i64) -> bool;
    fn i64_lt_eq(&mut self, arg0: i64, arg1: i64) -> bool;
    fn i64_gt(&mut self, arg0: i64, arg1: i64) -> bool;
    fn i64_gt_eq(&mut self, arg0: i64, arg1: i64) -> bool;
    fn i64_checked_add(&mut self, arg0: i64, arg1: i64) -> Option<i64>;
    fn i64_wrapping_add(&mut self, arg0: i64, arg1: i64) -> i64;
    fn i64_add(&mut self, arg0: i64, arg1: i64) -> i64;
    fn i64_checked_sub(&mut self, arg0: i64, arg1: i64) -> Option<i64>;
    fn i64_wrapping_sub(&mut self, arg0: i64, arg1: i64) -> i64;
    fn i64_sub(&mut self, arg0: i64, arg1: i64) -> i64;
    fn i64_checked_mul(&mut self, arg0: i64, arg1: i64) -> Option<i64>;
    fn i64_wrapping_mul(&mut self, arg0: i64, arg1: i64) -> i64;
    fn i64_mul(&mut self, arg0: i64, arg1: i64) -> i64;
    fn i64_checked_div(&mut self, arg0: i64, arg1: i64) -> Option<i64>;
    fn i64_wrapping_div(&mut self, arg0: i64, arg1: i64) -> i64;
    fn i64_div(&mut self, arg0: i64, arg1: i64) -> i64;
    fn i64_checked_rem(&mut self, arg0: i64, arg1: i64) -> Option<i64>;
    fn i64_rem(&mut self, arg0: i64, arg1: i64) -> i64;
    fn i64_and(&mut self, arg0: i64, arg1: i64) -> i64;
    fn i64_or(&mut self, arg0: i64, arg1: i64) -> i64;
    fn i64_xor(&mut self, arg0: i64, arg1: i64) -> i64;
    fn i64_not(&mut self, arg0: i64) -> i64;
    fn i64_checked_shl(&mut self, arg0: i64, arg1: u32) -> Option<i64>;
    fn i64_wrapping_shl(&mut self, arg0: i64, arg1: u32) -> i64;
    fn i64_shl(&mut self, arg0: i64, arg1: u32) -> i64;
    fn i64_checked_shr(&mut self, arg0: i64, arg1: u32) -> Option<i64>;
    fn i64_wrapping_shr(&mut self, arg0: i64, arg1: u32) -> i64;
    fn i64_shr(&mut self, arg0: i64, arg1: u32) -> i64;
    fn i64_rotl(&mut self, arg0: i64, arg1: u32) -> i64;
    fn i64_rotr(&mut self, arg0: i64, arg1: u32) -> i64;
    fn i64_is_zero(&mut self, arg0: i64) -> bool;
    fn i64_matches_zero(&mut self, arg0: i64) -> Option<bool>;
    fn i64_is_non_zero(&mut self, arg0: i64) -> bool;
    fn i64_matches_non_zero(&mut self, arg0: i64) -> Option<bool>;
    fn i64_is_odd(&mut self, arg0: i64) -> bool;
    fn i64_matches_odd(&mut self, arg0: i64) -> Option<bool>;
    fn i64_is_even(&mut self, arg0: i64) -> bool;
    fn i64_matches_even(&mut self, arg0: i64) -> Option<bool>;
    fn i64_checked_ilog2(&mut self, arg0: i64) -> Option<u32>;
    fn i64_ilog2(&mut self, arg0: i64) -> u32;
    fn i64_trailing_zeros(&mut self, arg0: i64) -> u32;
    fn i64_trailing_ones(&mut self, arg0: i64) -> u32;
    fn i64_leading_zeros(&mut self, arg0: i64) -> u32;
    fn i64_leading_ones(&mut self, arg0: i64) -> u32;
    fn i64_checked_neg(&mut self, arg0: i64) -> Option<i64>;
    fn i64_wrapping_neg(&mut self, arg0: i64) -> i64;
    fn i64_neg(&mut self, arg0: i64) -> i64;
    fn u64_eq(&mut self, arg0: u64, arg1: u64) -> bool;
    fn u64_ne(&mut self, arg0: u64, arg1: u64) -> bool;
    fn u64_lt(&mut self, arg0: u64, arg1: u64) -> bool;
    fn u64_lt_eq(&mut self, arg0: u64, arg1: u64) -> bool;
    fn u64_gt(&mut self, arg0: u64, arg1: u64) -> bool;
    fn u64_gt_eq(&mut self, arg0: u64, arg1: u64) -> bool;
    fn u64_checked_add(&mut self, arg0: u64, arg1: u64) -> Option<u64>;
    fn u64_wrapping_add(&mut self, arg0: u64, arg1: u64) -> u64;
    fn u64_add(&mut self, arg0: u64, arg1: u64) -> u64;
    fn u64_checked_sub(&mut self, arg0: u64, arg1: u64) -> Option<u64>;
    fn u64_wrapping_sub(&mut self, arg0: u64, arg1: u64) -> u64;
    fn u64_sub(&mut self, arg0: u64, arg1: u64) -> u64;
    fn u64_checked_mul(&mut self, arg0: u64, arg1: u64) -> Option<u64>;
    fn u64_wrapping_mul(&mut self, arg0: u64, arg1: u64) -> u64;
    fn u64_mul(&mut self, arg0: u64, arg1: u64) -> u64;
    fn u64_checked_div(&mut self, arg0: u64, arg1: u64) -> Option<u64>;
    fn u64_wrapping_div(&mut self, arg0: u64, arg1: u64) -> u64;
    fn u64_div(&mut self, arg0: u64, arg1: u64) -> u64;
    fn u64_checked_rem(&mut self, arg0: u64, arg1: u64) -> Option<u64>;
    fn u64_rem(&mut self, arg0: u64, arg1: u64) -> u64;
    fn u64_and(&mut self, arg0: u64, arg1: u64) -> u64;
    fn u64_or(&mut self, arg0: u64, arg1: u64) -> u64;
    fn u64_xor(&mut self, arg0: u64, arg1: u64) -> u64;
    fn u64_not(&mut self, arg0: u64) -> u64;
    fn u64_checked_shl(&mut self, arg0: u64, arg1: u32) -> Option<u64>;
    fn u64_wrapping_shl(&mut self, arg0: u64, arg1: u32) -> u64;
    fn u64_shl(&mut self, arg0: u64, arg1: u32) -> u64;
    fn u64_checked_shr(&mut self, arg0: u64, arg1: u32) -> Option<u64>;
    fn u64_wrapping_shr(&mut self, arg0: u64, arg1: u32) -> u64;
    fn u64_shr(&mut self, arg0: u64, arg1: u32) -> u64;
    fn u64_rotl(&mut self, arg0: u64, arg1: u32) -> u64;
    fn u64_rotr(&mut self, arg0: u64, arg1: u32) -> u64;
    fn u64_is_zero(&mut self, arg0: u64) -> bool;
    fn u64_matches_zero(&mut self, arg0: u64) -> Option<bool>;
    fn u64_is_non_zero(&mut self, arg0: u64) -> bool;
    fn u64_matches_non_zero(&mut self, arg0: u64) -> Option<bool>;
    fn u64_is_odd(&mut self, arg0: u64) -> bool;
    fn u64_matches_odd(&mut self, arg0: u64) -> Option<bool>;
    fn u64_is_even(&mut self, arg0: u64) -> bool;
    fn u64_matches_even(&mut self, arg0: u64) -> Option<bool>;
    fn u64_checked_ilog2(&mut self, arg0: u64) -> Option<u32>;
    fn u64_ilog2(&mut self, arg0: u64) -> u32;
    fn u64_trailing_zeros(&mut self, arg0: u64) -> u32;
    fn u64_trailing_ones(&mut self, arg0: u64) -> u32;
    fn u64_leading_zeros(&mut self, arg0: u64) -> u32;
    fn u64_leading_ones(&mut self, arg0: u64) -> u32;
    fn u64_is_power_of_two(&mut self, arg0: u64) -> bool;
    fn u64_matches_power_of_two(&mut self, arg0: u64) -> Option<bool>;
    fn i128_eq(&mut self, arg0: i128, arg1: i128) -> bool;
    fn i128_ne(&mut self, arg0: i128, arg1: i128) -> bool;
    fn i128_lt(&mut self, arg0: i128, arg1: i128) -> bool;
    fn i128_lt_eq(&mut self, arg0: i128, arg1: i128) -> bool;
    fn i128_gt(&mut self, arg0: i128, arg1: i128) -> bool;
    fn i128_gt_eq(&mut self, arg0: i128, arg1: i128) -> bool;
    fn i128_checked_add(&mut self, arg0: i128, arg1: i128) -> Option<i128>;
    fn i128_wrapping_add(&mut self, arg0: i128, arg1: i128) -> i128;
    fn i128_add(&mut self, arg0: i128, arg1: i128) -> i128;
    fn i128_checked_sub(&mut self, arg0: i128, arg1: i128) -> Option<i128>;
    fn i128_wrapping_sub(&mut self, arg0: i128, arg1: i128) -> i128;
    fn i128_sub(&mut self, arg0: i128, arg1: i128) -> i128;
    fn i128_checked_mul(&mut self, arg0: i128, arg1: i128) -> Option<i128>;
    fn i128_wrapping_mul(&mut self, arg0: i128, arg1: i128) -> i128;
    fn i128_mul(&mut self, arg0: i128, arg1: i128) -> i128;
    fn i128_checked_div(&mut self, arg0: i128, arg1: i128) -> Option<i128>;
    fn i128_wrapping_div(&mut self, arg0: i128, arg1: i128) -> i128;
    fn i128_div(&mut self, arg0: i128, arg1: i128) -> i128;
    fn i128_checked_rem(&mut self, arg0: i128, arg1: i128) -> Option<i128>;
    fn i128_rem(&mut self, arg0: i128, arg1: i128) -> i128;
    fn i128_and(&mut self, arg0: i128, arg1: i128) -> i128;
    fn i128_or(&mut self, arg0: i128, arg1: i128) -> i128;
    fn i128_xor(&mut self, arg0: i128, arg1: i128) -> i128;
    fn i128_not(&mut self, arg0: i128) -> i128;
    fn i128_checked_shl(&mut self, arg0: i128, arg1: u32) -> Option<i128>;
    fn i128_wrapping_shl(&mut self, arg0: i128, arg1: u32) -> i128;
    fn i128_shl(&mut self, arg0: i128, arg1: u32) -> i128;
    fn i128_checked_shr(&mut self, arg0: i128, arg1: u32) -> Option<i128>;
    fn i128_wrapping_shr(&mut self, arg0: i128, arg1: u32) -> i128;
    fn i128_shr(&mut self, arg0: i128, arg1: u32) -> i128;
    fn i128_rotl(&mut self, arg0: i128, arg1: u32) -> i128;
    fn i128_rotr(&mut self, arg0: i128, arg1: u32) -> i128;
    fn i128_is_zero(&mut self, arg0: i128) -> bool;
    fn i128_matches_zero(&mut self, arg0: i128) -> Option<bool>;
    fn i128_is_non_zero(&mut self, arg0: i128) -> bool;
    fn i128_matches_non_zero(&mut self, arg0: i128) -> Option<bool>;
    fn i128_is_odd(&mut self, arg0: i128) -> bool;
    fn i128_matches_odd(&mut self, arg0: i128) -> Option<bool>;
    fn i128_is_even(&mut self, arg0: i128) -> bool;
    fn i128_matches_even(&mut self, arg0: i128) -> Option<bool>;
    fn i128_checked_ilog2(&mut self, arg0: i128) -> Option<u32>;
    fn i128_ilog2(&mut self, arg0: i128) -> u32;
    fn i128_trailing_zeros(&mut self, arg0: i128) -> u32;
    fn i128_trailing_ones(&mut self, arg0: i128) -> u32;
    fn i128_leading_zeros(&mut self, arg0: i128) -> u32;
    fn i128_leading_ones(&mut self, arg0: i128) -> u32;
    fn i128_checked_neg(&mut self, arg0: i128) -> Option<i128>;
    fn i128_wrapping_neg(&mut self, arg0: i128) -> i128;
    fn i128_neg(&mut self, arg0: i128) -> i128;
    fn u128_eq(&mut self, arg0: u128, arg1: u128) -> bool;
    fn u128_ne(&mut self, arg0: u128, arg1: u128) -> bool;
    fn u128_lt(&mut self, arg0: u128, arg1: u128) -> bool;
    fn u128_lt_eq(&mut self, arg0: u128, arg1: u128) -> bool;
    fn u128_gt(&mut self, arg0: u128, arg1: u128) -> bool;
    fn u128_gt_eq(&mut self, arg0: u128, arg1: u128) -> bool;
    fn u128_checked_add(&mut self, arg0: u128, arg1: u128) -> Option<u128>;
    fn u128_wrapping_add(&mut self, arg0: u128, arg1: u128) -> u128;
    fn u128_add(&mut self, arg0: u128, arg1: u128) -> u128;
    fn u128_checked_sub(&mut self, arg0: u128, arg1: u128) -> Option<u128>;
    fn u128_wrapping_sub(&mut self, arg0: u128, arg1: u128) -> u128;
    fn u128_sub(&mut self, arg0: u128, arg1: u128) -> u128;
    fn u128_checked_mul(&mut self, arg0: u128, arg1: u128) -> Option<u128>;
    fn u128_wrapping_mul(&mut self, arg0: u128, arg1: u128) -> u128;
    fn u128_mul(&mut self, arg0: u128, arg1: u128) -> u128;
    fn u128_checked_div(&mut self, arg0: u128, arg1: u128) -> Option<u128>;
    fn u128_wrapping_div(&mut self, arg0: u128, arg1: u128) -> u128;
    fn u128_div(&mut self, arg0: u128, arg1: u128) -> u128;
    fn u128_checked_rem(&mut self, arg0: u128, arg1: u128) -> Option<u128>;
    fn u128_rem(&mut self, arg0: u128, arg1: u128) -> u128;
    fn u128_and(&mut self, arg0: u128, arg1: u128) -> u128;
    fn u128_or(&mut self, arg0: u128, arg1: u128) -> u128;
    fn u128_xor(&mut self, arg0: u128, arg1: u128) -> u128;
    fn u128_not(&mut self, arg0: u128) -> u128;
    fn u128_checked_shl(&mut self, arg0: u128, arg1: u32) -> Option<u128>;
    fn u128_wrapping_shl(&mut self, arg0: u128, arg1: u32) -> u128;
    fn u128_shl(&mut self, arg0: u128, arg1: u32) -> u128;
    fn u128_checked_shr(&mut self, arg0: u128, arg1: u32) -> Option<u128>;
    fn u128_wrapping_shr(&mut self, arg0: u128, arg1: u32) -> u128;
    fn u128_shr(&mut self, arg0: u128, arg1: u32) -> u128;
    fn u128_rotl(&mut self, arg0: u128, arg1: u32) -> u128;
    fn u128_rotr(&mut self, arg0: u128, arg1: u32) -> u128;
    fn u128_is_zero(&mut self, arg0: u128) -> bool;
    fn u128_matches_zero(&mut self, arg0: u128) -> Option<bool>;
    fn u128_is_non_zero(&mut self, arg0: u128) -> bool;
    fn u128_matches_non_zero(&mut self, arg0: u128) -> Option<bool>;
    fn u128_is_odd(&mut self, arg0: u128) -> bool;
    fn u128_matches_odd(&mut self, arg0: u128) -> Option<bool>;
    fn u128_is_even(&mut self, arg0: u128) -> bool;
    fn u128_matches_even(&mut self, arg0: u128) -> Option<bool>;
    fn u128_checked_ilog2(&mut self, arg0: u128) -> Option<u32>;
    fn u128_ilog2(&mut self, arg0: u128) -> u32;
    fn u128_trailing_zeros(&mut self, arg0: u128) -> u32;
    fn u128_trailing_ones(&mut self, arg0: u128) -> u32;
    fn u128_leading_zeros(&mut self, arg0: u128) -> u32;
    fn u128_leading_ones(&mut self, arg0: u128) -> u32;
    fn u128_is_power_of_two(&mut self, arg0: u128) -> bool;
    fn u128_matches_power_of_two(&mut self, arg0: u128) -> Option<bool>;
    fn i8_try_into_u8(&mut self, arg0: i8) -> Option<u8>;
    fn i8_unwrap_into_u8(&mut self, arg0: i8) -> u8;
    fn i8_cast_unsigned(&mut self, arg0: i8) -> u8;
    fn i8_from_u8(&mut self, arg0: i8) -> Option<u8>;
    fn i8_into_i16(&mut self, arg0: i8) -> i16;
    fn i8_from_i16(&mut self, arg0: i8) -> Option<i16>;
    fn i8_try_into_u16(&mut self, arg0: i8) -> Option<u16>;
    fn i8_unwrap_into_u16(&mut self, arg0: i8) -> u16;
    fn i8_from_u16(&mut self, arg0: i8) -> Option<u16>;
    fn i8_into_i32(&mut self, arg0: i8) -> i32;
    fn i8_from_i32(&mut self, arg0: i8) -> Option<i32>;
    fn i8_try_into_u32(&mut self, arg0: i8) -> Option<u32>;
    fn i8_unwrap_into_u32(&mut self, arg0: i8) -> u32;
    fn i8_from_u32(&mut self, arg0: i8) -> Option<u32>;
    fn i8_into_i64(&mut self, arg0: i8) -> i64;
    fn i8_from_i64(&mut self, arg0: i8) -> Option<i64>;
    fn i8_try_into_u64(&mut self, arg0: i8) -> Option<u64>;
    fn i8_unwrap_into_u64(&mut self, arg0: i8) -> u64;
    fn i8_from_u64(&mut self, arg0: i8) -> Option<u64>;
    fn i8_into_i128(&mut self, arg0: i8) -> i128;
    fn i8_from_i128(&mut self, arg0: i8) -> Option<i128>;
    fn i8_try_into_u128(&mut self, arg0: i8) -> Option<u128>;
    fn i8_unwrap_into_u128(&mut self, arg0: i8) -> u128;
    fn i8_from_u128(&mut self, arg0: i8) -> Option<u128>;
    fn u8_try_into_i8(&mut self, arg0: u8) -> Option<i8>;
    fn u8_unwrap_into_i8(&mut self, arg0: u8) -> i8;
    fn u8_cast_signed(&mut self, arg0: u8) -> i8;
    fn u8_from_i8(&mut self, arg0: u8) -> Option<i8>;
    fn u8_into_i16(&mut self, arg0: u8) -> i16;
    fn u8_from_i16(&mut self, arg0: u8) -> Option<i16>;
    fn u8_into_u16(&mut self, arg0: u8) -> u16;
    fn u8_from_u16(&mut self, arg0: u8) -> Option<u16>;
    fn u8_into_i32(&mut self, arg0: u8) -> i32;
    fn u8_from_i32(&mut self, arg0: u8) -> Option<i32>;
    fn u8_into_u32(&mut self, arg0: u8) -> u32;
    fn u8_from_u32(&mut self, arg0: u8) -> Option<u32>;
    fn u8_into_i64(&mut self, arg0: u8) -> i64;
    fn u8_from_i64(&mut self, arg0: u8) -> Option<i64>;
    fn u8_into_u64(&mut self, arg0: u8) -> u64;
    fn u8_from_u64(&mut self, arg0: u8) -> Option<u64>;
    fn u8_into_i128(&mut self, arg0: u8) -> i128;
    fn u8_from_i128(&mut self, arg0: u8) -> Option<i128>;
    fn u8_into_u128(&mut self, arg0: u8) -> u128;
    fn u8_from_u128(&mut self, arg0: u8) -> Option<u128>;
    fn i16_try_into_i8(&mut self, arg0: i16) -> Option<i8>;
    fn i16_unwrap_into_i8(&mut self, arg0: i16) -> i8;
    fn i16_truncate_into_i8(&mut self, arg0: i16) -> i8;
    fn i16_from_i8(&mut self, arg0: i16) -> Option<i8>;
    fn i16_try_into_u8(&mut self, arg0: i16) -> Option<u8>;
    fn i16_unwrap_into_u8(&mut self, arg0: i16) -> u8;
    fn i16_from_u8(&mut self, arg0: i16) -> Option<u8>;
    fn i16_try_into_u16(&mut self, arg0: i16) -> Option<u16>;
    fn i16_unwrap_into_u16(&mut self, arg0: i16) -> u16;
    fn i16_cast_unsigned(&mut self, arg0: i16) -> u16;
    fn i16_from_u16(&mut self, arg0: i16) -> Option<u16>;
    fn i16_into_i32(&mut self, arg0: i16) -> i32;
    fn i16_from_i32(&mut self, arg0: i16) -> Option<i32>;
    fn i16_try_into_u32(&mut self, arg0: i16) -> Option<u32>;
    fn i16_unwrap_into_u32(&mut self, arg0: i16) -> u32;
    fn i16_from_u32(&mut self, arg0: i16) -> Option<u32>;
    fn i16_into_i64(&mut self, arg0: i16) -> i64;
    fn i16_from_i64(&mut self, arg0: i16) -> Option<i64>;
    fn i16_try_into_u64(&mut self, arg0: i16) -> Option<u64>;
    fn i16_unwrap_into_u64(&mut self, arg0: i16) -> u64;
    fn i16_from_u64(&mut self, arg0: i16) -> Option<u64>;
    fn i16_into_i128(&mut self, arg0: i16) -> i128;
    fn i16_from_i128(&mut self, arg0: i16) -> Option<i128>;
    fn i16_try_into_u128(&mut self, arg0: i16) -> Option<u128>;
    fn i16_unwrap_into_u128(&mut self, arg0: i16) -> u128;
    fn i16_from_u128(&mut self, arg0: i16) -> Option<u128>;
    fn u16_try_into_i8(&mut self, arg0: u16) -> Option<i8>;
    fn u16_unwrap_into_i8(&mut self, arg0: u16) -> i8;
    fn u16_from_i8(&mut self, arg0: u16) -> Option<i8>;
    fn u16_try_into_u8(&mut self, arg0: u16) -> Option<u8>;
    fn u16_unwrap_into_u8(&mut self, arg0: u16) -> u8;
    fn u16_truncate_into_u8(&mut self, arg0: u16) -> u8;
    fn u16_from_u8(&mut self, arg0: u16) -> Option<u8>;
    fn u16_try_into_i16(&mut self, arg0: u16) -> Option<i16>;
    fn u16_unwrap_into_i16(&mut self, arg0: u16) -> i16;
    fn u16_cast_signed(&mut self, arg0: u16) -> i16;
    fn u16_from_i16(&mut self, arg0: u16) -> Option<i16>;
    fn u16_into_i32(&mut self, arg0: u16) -> i32;
    fn u16_from_i32(&mut self, arg0: u16) -> Option<i32>;
    fn u16_into_u32(&mut self, arg0: u16) -> u32;
    fn u16_from_u32(&mut self, arg0: u16) -> Option<u32>;
    fn u16_into_i64(&mut self, arg0: u16) -> i64;
    fn u16_from_i64(&mut self, arg0: u16) -> Option<i64>;
    fn u16_into_u64(&mut self, arg0: u16) -> u64;
    fn u16_from_u64(&mut self, arg0: u16) -> Option<u64>;
    fn u16_into_i128(&mut self, arg0: u16) -> i128;
    fn u16_from_i128(&mut self, arg0: u16) -> Option<i128>;
    fn u16_into_u128(&mut self, arg0: u16) -> u128;
    fn u16_from_u128(&mut self, arg0: u16) -> Option<u128>;
    fn i32_try_into_i8(&mut self, arg0: i32) -> Option<i8>;
    fn i32_unwrap_into_i8(&mut self, arg0: i32) -> i8;
    fn i32_truncate_into_i8(&mut self, arg0: i32) -> i8;
    fn i32_from_i8(&mut self, arg0: i32) -> Option<i8>;
    fn i32_try_into_u8(&mut self, arg0: i32) -> Option<u8>;
    fn i32_unwrap_into_u8(&mut self, arg0: i32) -> u8;
    fn i32_from_u8(&mut self, arg0: i32) -> Option<u8>;
    fn i32_try_into_i16(&mut self, arg0: i32) -> Option<i16>;
    fn i32_unwrap_into_i16(&mut self, arg0: i32) -> i16;
    fn i32_truncate_into_i16(&mut self, arg0: i32) -> i16;
    fn i32_from_i16(&mut self, arg0: i32) -> Option<i16>;
    fn i32_try_into_u16(&mut self, arg0: i32) -> Option<u16>;
    fn i32_unwrap_into_u16(&mut self, arg0: i32) -> u16;
    fn i32_from_u16(&mut self, arg0: i32) -> Option<u16>;
    fn i32_try_into_u32(&mut self, arg0: i32) -> Option<u32>;
    fn i32_unwrap_into_u32(&mut self, arg0: i32) -> u32;
    fn i32_cast_unsigned(&mut self, arg0: i32) -> u32;
    fn i32_from_u32(&mut self, arg0: i32) -> Option<u32>;
    fn i32_into_i64(&mut self, arg0: i32) -> i64;
    fn i32_from_i64(&mut self, arg0: i32) -> Option<i64>;
    fn i32_try_into_u64(&mut self, arg0: i32) -> Option<u64>;
    fn i32_unwrap_into_u64(&mut self, arg0: i32) -> u64;
    fn i32_from_u64(&mut self, arg0: i32) -> Option<u64>;
    fn i32_into_i128(&mut self, arg0: i32) -> i128;
    fn i32_from_i128(&mut self, arg0: i32) -> Option<i128>;
    fn i32_try_into_u128(&mut self, arg0: i32) -> Option<u128>;
    fn i32_unwrap_into_u128(&mut self, arg0: i32) -> u128;
    fn i32_from_u128(&mut self, arg0: i32) -> Option<u128>;
    fn u32_try_into_i8(&mut self, arg0: u32) -> Option<i8>;
    fn u32_unwrap_into_i8(&mut self, arg0: u32) -> i8;
    fn u32_from_i8(&mut self, arg0: u32) -> Option<i8>;
    fn u32_try_into_u8(&mut self, arg0: u32) -> Option<u8>;
    fn u32_unwrap_into_u8(&mut self, arg0: u32) -> u8;
    fn u32_truncate_into_u8(&mut self, arg0: u32) -> u8;
    fn u32_from_u8(&mut self, arg0: u32) -> Option<u8>;
    fn u32_try_into_i16(&mut self, arg0: u32) -> Option<i16>;
    fn u32_unwrap_into_i16(&mut self, arg0: u32) -> i16;
    fn u32_from_i16(&mut self, arg0: u32) -> Option<i16>;
    fn u32_try_into_u16(&mut self, arg0: u32) -> Option<u16>;
    fn u32_unwrap_into_u16(&mut self, arg0: u32) -> u16;
    fn u32_truncate_into_u16(&mut self, arg0: u32) -> u16;
    fn u32_from_u16(&mut self, arg0: u32) -> Option<u16>;
    fn u32_try_into_i32(&mut self, arg0: u32) -> Option<i32>;
    fn u32_unwrap_into_i32(&mut self, arg0: u32) -> i32;
    fn u32_cast_signed(&mut self, arg0: u32) -> i32;
    fn u32_from_i32(&mut self, arg0: u32) -> Option<i32>;
    fn u32_into_i64(&mut self, arg0: u32) -> i64;
    fn u32_from_i64(&mut self, arg0: u32) -> Option<i64>;
    fn u32_into_u64(&mut self, arg0: u32) -> u64;
    fn u32_from_u64(&mut self, arg0: u32) -> Option<u64>;
    fn u32_into_i128(&mut self, arg0: u32) -> i128;
    fn u32_from_i128(&mut self, arg0: u32) -> Option<i128>;
    fn u32_into_u128(&mut self, arg0: u32) -> u128;
    fn u32_from_u128(&mut self, arg0: u32) -> Option<u128>;
    fn i64_try_into_i8(&mut self, arg0: i64) -> Option<i8>;
    fn i64_unwrap_into_i8(&mut self, arg0: i64) -> i8;
    fn i64_truncate_into_i8(&mut self, arg0: i64) -> i8;
    fn i64_from_i8(&mut self, arg0: i64) -> Option<i8>;
    fn i64_try_into_u8(&mut self, arg0: i64) -> Option<u8>;
    fn i64_unwrap_into_u8(&mut self, arg0: i64) -> u8;
    fn i64_from_u8(&mut self, arg0: i64) -> Option<u8>;
    fn i64_try_into_i16(&mut self, arg0: i64) -> Option<i16>;
    fn i64_unwrap_into_i16(&mut self, arg0: i64) -> i16;
    fn i64_truncate_into_i16(&mut self, arg0: i64) -> i16;
    fn i64_from_i16(&mut self, arg0: i64) -> Option<i16>;
    fn i64_try_into_u16(&mut self, arg0: i64) -> Option<u16>;
    fn i64_unwrap_into_u16(&mut self, arg0: i64) -> u16;
    fn i64_from_u16(&mut self, arg0: i64) -> Option<u16>;
    fn i64_try_into_i32(&mut self, arg0: i64) -> Option<i32>;
    fn i64_unwrap_into_i32(&mut self, arg0: i64) -> i32;
    fn i64_truncate_into_i32(&mut self, arg0: i64) -> i32;
    fn i64_from_i32(&mut self, arg0: i64) -> Option<i32>;
    fn i64_try_into_u32(&mut self, arg0: i64) -> Option<u32>;
    fn i64_unwrap_into_u32(&mut self, arg0: i64) -> u32;
    fn i64_from_u32(&mut self, arg0: i64) -> Option<u32>;
    fn i64_try_into_u64(&mut self, arg0: i64) -> Option<u64>;
    fn i64_unwrap_into_u64(&mut self, arg0: i64) -> u64;
    fn i64_cast_unsigned(&mut self, arg0: i64) -> u64;
    fn i64_from_u64(&mut self, arg0: i64) -> Option<u64>;
    fn i64_into_i128(&mut self, arg0: i64) -> i128;
    fn i64_from_i128(&mut self, arg0: i64) -> Option<i128>;
    fn i64_try_into_u128(&mut self, arg0: i64) -> Option<u128>;
    fn i64_unwrap_into_u128(&mut self, arg0: i64) -> u128;
    fn i64_from_u128(&mut self, arg0: i64) -> Option<u128>;
    fn u64_try_into_i8(&mut self, arg0: u64) -> Option<i8>;
    fn u64_unwrap_into_i8(&mut self, arg0: u64) -> i8;
    fn u64_from_i8(&mut self, arg0: u64) -> Option<i8>;
    fn u64_try_into_u8(&mut self, arg0: u64) -> Option<u8>;
    fn u64_unwrap_into_u8(&mut self, arg0: u64) -> u8;
    fn u64_truncate_into_u8(&mut self, arg0: u64) -> u8;
    fn u64_from_u8(&mut self, arg0: u64) -> Option<u8>;
    fn u64_try_into_i16(&mut self, arg0: u64) -> Option<i16>;
    fn u64_unwrap_into_i16(&mut self, arg0: u64) -> i16;
    fn u64_from_i16(&mut self, arg0: u64) -> Option<i16>;
    fn u64_try_into_u16(&mut self, arg0: u64) -> Option<u16>;
    fn u64_unwrap_into_u16(&mut self, arg0: u64) -> u16;
    fn u64_truncate_into_u16(&mut self, arg0: u64) -> u16;
    fn u64_from_u16(&mut self, arg0: u64) -> Option<u16>;
    fn u64_try_into_i32(&mut self, arg0: u64) -> Option<i32>;
    fn u64_unwrap_into_i32(&mut self, arg0: u64) -> i32;
    fn u64_from_i32(&mut self, arg0: u64) -> Option<i32>;
    fn u64_try_into_u32(&mut self, arg0: u64) -> Option<u32>;
    fn u64_unwrap_into_u32(&mut self, arg0: u64) -> u32;
    fn u64_truncate_into_u32(&mut self, arg0: u64) -> u32;
    fn u64_from_u32(&mut self, arg0: u64) -> Option<u32>;
    fn u64_try_into_i64(&mut self, arg0: u64) -> Option<i64>;
    fn u64_unwrap_into_i64(&mut self, arg0: u64) -> i64;
    fn u64_cast_signed(&mut self, arg0: u64) -> i64;
    fn u64_from_i64(&mut self, arg0: u64) -> Option<i64>;
    fn u64_into_i128(&mut self, arg0: u64) -> i128;
    fn u64_from_i128(&mut self, arg0: u64) -> Option<i128>;
    fn u64_into_u128(&mut self, arg0: u64) -> u128;
    fn u64_from_u128(&mut self, arg0: u64) -> Option<u128>;
    fn i128_try_into_i8(&mut self, arg0: i128) -> Option<i8>;
    fn i128_unwrap_into_i8(&mut self, arg0: i128) -> i8;
    fn i128_truncate_into_i8(&mut self, arg0: i128) -> i8;
    fn i128_from_i8(&mut self, arg0: i128) -> Option<i8>;
    fn i128_try_into_u8(&mut self, arg0: i128) -> Option<u8>;
    fn i128_unwrap_into_u8(&mut self, arg0: i128) -> u8;
    fn i128_from_u8(&mut self, arg0: i128) -> Option<u8>;
    fn i128_try_into_i16(&mut self, arg0: i128) -> Option<i16>;
    fn i128_unwrap_into_i16(&mut self, arg0: i128) -> i16;
    fn i128_truncate_into_i16(&mut self, arg0: i128) -> i16;
    fn i128_from_i16(&mut self, arg0: i128) -> Option<i16>;
    fn i128_try_into_u16(&mut self, arg0: i128) -> Option<u16>;
    fn i128_unwrap_into_u16(&mut self, arg0: i128) -> u16;
    fn i128_from_u16(&mut self, arg0: i128) -> Option<u16>;
    fn i128_try_into_i32(&mut self, arg0: i128) -> Option<i32>;
    fn i128_unwrap_into_i32(&mut self, arg0: i128) -> i32;
    fn i128_truncate_into_i32(&mut self, arg0: i128) -> i32;
    fn i128_from_i32(&mut self, arg0: i128) -> Option<i32>;
    fn i128_try_into_u32(&mut self, arg0: i128) -> Option<u32>;
    fn i128_unwrap_into_u32(&mut self, arg0: i128) -> u32;
    fn i128_from_u32(&mut self, arg0: i128) -> Option<u32>;
    fn i128_try_into_i64(&mut self, arg0: i128) -> Option<i64>;
    fn i128_unwrap_into_i64(&mut self, arg0: i128) -> i64;
    fn i128_truncate_into_i64(&mut self, arg0: i128) -> i64;
    fn i128_from_i64(&mut self, arg0: i128) -> Option<i64>;
    fn i128_try_into_u64(&mut self, arg0: i128) -> Option<u64>;
    fn i128_unwrap_into_u64(&mut self, arg0: i128) -> u64;
    fn i128_from_u64(&mut self, arg0: i128) -> Option<u64>;
    fn i128_try_into_u128(&mut self, arg0: i128) -> Option<u128>;
    fn i128_unwrap_into_u128(&mut self, arg0: i128) -> u128;
    fn i128_cast_unsigned(&mut self, arg0: i128) -> u128;
    fn i128_from_u128(&mut self, arg0: i128) -> Option<u128>;
    fn u128_try_into_i8(&mut self, arg0: u128) -> Option<i8>;
    fn u128_unwrap_into_i8(&mut self, arg0: u128) -> i8;
    fn u128_from_i8(&mut self, arg0: u128) -> Option<i8>;
    fn u128_try_into_u8(&mut self, arg0: u128) -> Option<u8>;
    fn u128_unwrap_into_u8(&mut self, arg0: u128) -> u8;
    fn u128_truncate_into_u8(&mut self, arg0: u128) -> u8;
    fn u128_from_u8(&mut self, arg0: u128) -> Option<u8>;
    fn u128_try_into_i16(&mut self, arg0: u128) -> Option<i16>;
    fn u128_unwrap_into_i16(&mut self, arg0: u128) -> i16;
    fn u128_from_i16(&mut self, arg0: u128) -> Option<i16>;
    fn u128_try_into_u16(&mut self, arg0: u128) -> Option<u16>;
    fn u128_unwrap_into_u16(&mut self, arg0: u128) -> u16;
    fn u128_truncate_into_u16(&mut self, arg0: u128) -> u16;
    fn u128_from_u16(&mut self, arg0: u128) -> Option<u16>;
    fn u128_try_into_i32(&mut self, arg0: u128) -> Option<i32>;
    fn u128_unwrap_into_i32(&mut self, arg0: u128) -> i32;
    fn u128_from_i32(&mut self, arg0: u128) -> Option<i32>;
    fn u128_try_into_u32(&mut self, arg0: u128) -> Option<u32>;
    fn u128_unwrap_into_u32(&mut self, arg0: u128) -> u32;
    fn u128_truncate_into_u32(&mut self, arg0: u128) -> u32;
    fn u128_from_u32(&mut self, arg0: u128) -> Option<u32>;
    fn u128_try_into_i64(&mut self, arg0: u128) -> Option<i64>;
    fn u128_unwrap_into_i64(&mut self, arg0: u128) -> i64;
    fn u128_from_i64(&mut self, arg0: u128) -> Option<i64>;
    fn u128_try_into_u64(&mut self, arg0: u128) -> Option<u64>;
    fn u128_unwrap_into_u64(&mut self, arg0: u128) -> u64;
    fn u128_truncate_into_u64(&mut self, arg0: u128) -> u64;
    fn u128_from_u64(&mut self, arg0: u128) -> Option<u64>;
    fn u128_try_into_i128(&mut self, arg0: u128) -> Option<i128>;
    fn u128_unwrap_into_i128(&mut self, arg0: u128) -> i128;
    fn u128_cast_signed(&mut self, arg0: u128) -> i128;
    fn u128_from_i128(&mut self, arg0: u128) -> Option<i128>;
    fn unpack_value_array_2(&mut self, arg0: &ValueArray2) -> (Value, Value);
    fn pack_value_array_2(&mut self, arg0: Value, arg1: Value) -> ValueArray2;
    fn unpack_value_array_3(&mut self, arg0: &ValueArray3) -> (Value, Value, Value);
    fn pack_value_array_3(&mut self, arg0: Value, arg1: Value, arg2: Value) -> ValueArray3;
    fn unpack_block_array_2(&mut self, arg0: &BlockArray2) -> (BlockCall, BlockCall);
    fn pack_block_array_2(&mut self, arg0: BlockCall, arg1: BlockCall) -> BlockArray2;
}

pub trait ContextIter {
    type Context;
    type Output;
    fn next(&mut self, ctx: &mut Self::Context) -> Option<Self::Output>;
    fn size_hint(&self) -> (usize, Option<usize>) { (0, None) }
}

pub trait IntoContextIter {
    type Context;
    type Output;
    type IntoIter: ContextIter<Context = Self::Context, Output = Self::Output>;
    fn into_context_iter(self) -> Self::IntoIter;
}

pub trait Length {
    fn len(&self) -> usize;
}

impl<T> Length for alloc::vec::Vec<T> {
    fn len(&self) -> usize {
        alloc::vec::Vec::len(self)
    }
}

pub struct ContextIterWrapper<I, C> {
    iter: I,
    _ctx: core::marker::PhantomData<C>,
}
impl<I: Default, C> Default for ContextIterWrapper<I, C> {
    fn default() -> Self {
        ContextIterWrapper {
            iter: I::default(),
            _ctx: core::marker::PhantomData
        }
    }
}
impl<I, C> core::ops::Deref for ContextIterWrapper<I, C> {
    type Target = I;
    fn deref(&self) -> &I {
        &self.iter
    }
}
impl<I, C> core::ops::DerefMut for ContextIterWrapper<I, C> {
    fn deref_mut(&mut self) -> &mut I {
        &mut self.iter
    }
}
impl<I: Iterator, C: Context> From<I> for ContextIterWrapper<I, C> {
    fn from(iter: I) -> Self {
        Self { iter, _ctx: core::marker::PhantomData }
    }
}
impl<I: Iterator, C: Context> ContextIter for ContextIterWrapper<I, C> {
    type Context = C;
    type Output = I::Item;
    fn next(&mut self, _ctx: &mut Self::Context) -> Option<Self::Output> {
        self.iter.next()
    }
    fn size_hint(&self) -> (usize, Option<usize>) {
        self.iter.size_hint()
    }
}
impl<I: IntoIterator, C: Context> IntoContextIter for ContextIterWrapper<I, C> {
    type Context = C;
    type Output = I::Item;
    type IntoIter = ContextIterWrapper<I::IntoIter, C>;
    fn into_context_iter(self) -> Self::IntoIter {
        ContextIterWrapper {
            iter: self.iter.into_iter(),
            _ctx: core::marker::PhantomData
        }
    }
}
impl<T, E: Extend<T>, C> Extend<T> for ContextIterWrapper<E, C> {
    fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I) {
        self.iter.extend(iter);
    }
}
impl<L: Length, C> Length for ContextIterWrapper<L, C> {
    fn len(&self) -> usize {
        self.iter.len()
    }
}
           

/// Internal type MultiReg: defined at src/prelude_lower.isle line 16.
#[derive(Clone, Debug)]
pub enum MultiReg {
    Empty,
    One {
        a: Reg,
    },
    Two {
        a: Reg,
        b: Reg,
    },
    Three {
        a: Reg,
        b: Reg,
        c: Reg,
    },
    Four {
        a: Reg,
        b: Reg,
        c: Reg,
        d: Reg,
    },
}

/// Internal type SideEffectNoResult: defined at src/prelude_lower.isle line 429.
#[derive(Clone, Debug)]
pub enum SideEffectNoResult {
    Inst {
        inst: MInst,
    },
    Inst2 {
        inst1: MInst,
        inst2: MInst,
    },
    Inst3 {
        inst1: MInst,
        inst2: MInst,
        inst3: MInst,
    },
}

/// Internal type ProducesFlags: defined at src/prelude_lower.isle line 482.
#[derive(Clone, Debug)]
pub enum ProducesFlags {
    AlreadyExistingFlags,
    ProducesFlagsSideEffect {
        inst: MInst,
    },
    ProducesFlagsTwiceSideEffect {
        inst1: MInst,
        inst2: MInst,
    },
    ProducesFlagsReturnsReg {
        inst: MInst,
        result: Reg,
    },
    ProducesFlagsReturnsResultWithConsumer {
        inst: MInst,
        result: Reg,
    },
}

/// Internal type ConsumesAndProducesFlags: defined at src/prelude_lower.isle line 501.
#[derive(Clone, Debug)]
pub enum ConsumesAndProducesFlags {
    SideEffect {
        inst: MInst,
    },
    ReturnsReg {
        inst: MInst,
        result: Reg,
    },
}

/// Internal type ConsumesFlags: defined at src/prelude_lower.isle line 509.
#[derive(Clone, Debug)]
pub enum ConsumesFlags {
    ConsumesFlagsSideEffect {
        inst: MInst,
    },
    ConsumesFlagsSideEffect2 {
        inst1: MInst,
        inst2: MInst,
    },
    ConsumesFlagsReturnsResultWithProducer {
        inst: MInst,
        result: Reg,
    },
    ConsumesFlagsReturnsReg {
        inst: MInst,
        result: Reg,
    },
    ConsumesFlagsTwiceReturnsValueRegs {
        inst1: MInst,
        inst2: MInst,
        result: ValueRegs,
    },
    ConsumesFlagsFourTimesReturnsValueRegs {
        inst1: MInst,
        inst2: MInst,
        inst3: MInst,
        inst4: MInst,
        result: ValueRegs,
    },
}

/// Internal type MInst: defined at src/isa/pulley_shared/inst.isle line 10.
#[derive(Clone, Debug)]
pub enum MInst {
    Args {
        args: VecArgPair,
    },
    Rets {
        rets: VecRetPair,
    },
    DummyUse {
        reg: Reg,
    },
    BrTable {
        idx: XReg,
        default: MachLabel,
        targets: BoxVecMachLabel,
    },
    TrapIf {
        cond: Cond,
        code: TrapCode,
    },
    Nop,
    GetSpecial {
        dst: WritableXReg,
        reg: XReg,
    },
    LoadExtNameNear {
        dst: WritableXReg,
        name: BoxExternalName,
        offset: i64,
    },
    LoadExtNameFar {
        dst: WritableXReg,
        name: BoxExternalName,
        offset: i64,
    },
    Call {
        info: BoxCallInfo,
    },
    IndirectCall {
        info: BoxCallIndInfo,
    },
    ReturnCall {
        info: BoxReturnCallInfo,
    },
    ReturnIndirectCall {
        info: BoxReturnCallIndInfo,
    },
    IndirectCallHost {
        info: BoxCallIndirectHostInfo,
    },
    Jump {
        label: MachLabel,
    },
    BrIf {
        cond: Cond,
        taken: MachLabel,
        not_taken: MachLabel,
    },
    LoadAddr {
        dst: WritableXReg,
        mem: Amode,
    },
    XLoad {
        dst: WritableXReg,
        mem: Amode,
        ty: Type,
        flags: MemFlagsData,
    },
    FLoad {
        dst: WritableFReg,
        mem: Amode,
        ty: Type,
        flags: MemFlagsData,
    },
    VLoad {
        dst: WritableVReg,
        mem: Amode,
        ty: Type,
        flags: MemFlagsData,
    },
    XStore {
        mem: Amode,
        src: XReg,
        ty: Type,
        flags: MemFlagsData,
    },
    FStore {
        mem: Amode,
        src: FReg,
        ty: Type,
        flags: MemFlagsData,
    },
    VStore {
        mem: Amode,
        src: VReg,
        ty: Type,
        flags: MemFlagsData,
    },
    Raw {
        raw: RawInst,
    },
    EmitIsland {
        space_needed: u32,
    },
    LabelAddress {
        dst: WritableXReg,
        label: MachLabel,
    },
    SequencePoint,
}

/// Internal type Cond: defined at src/isa/pulley_shared/inst.isle line 107.
#[derive(Clone, Debug)]
pub enum Cond {
    If32 {
        reg: XReg,
    },
    IfNot32 {
        reg: XReg,
    },
    IfXeq32 {
        src1: XReg,
        src2: XReg,
    },
    IfXneq32 {
        src1: XReg,
        src2: XReg,
    },
    IfXslt32 {
        src1: XReg,
        src2: XReg,
    },
    IfXslteq32 {
        src1: XReg,
        src2: XReg,
    },
    IfXult32 {
        src1: XReg,
        src2: XReg,
    },
    IfXulteq32 {
        src1: XReg,
        src2: XReg,
    },
    IfXeq32I32 {
        src1: XReg,
        src2: i32,
    },
    IfXneq32I32 {
        src1: XReg,
        src2: i32,
    },
    IfXslt32I32 {
        src1: XReg,
        src2: i32,
    },
    IfXslteq32I32 {
        src1: XReg,
        src2: i32,
    },
    IfXult32I32 {
        src1: XReg,
        src2: u32,
    },
    IfXulteq32I32 {
        src1: XReg,
        src2: u32,
    },
    IfXsgt32I32 {
        src1: XReg,
        src2: i32,
    },
    IfXsgteq32I32 {
        src1: XReg,
        src2: i32,
    },
    IfXugt32I32 {
        src1: XReg,
        src2: u32,
    },
    IfXugteq32I32 {
        src1: XReg,
        src2: u32,
    },
    IfXeq64 {
        src1: XReg,
        src2: XReg,
    },
    IfXneq64 {
        src1: XReg,
        src2: XReg,
    },
    IfXslt64 {
        src1: XReg,
        src2: XReg,
    },
    IfXslteq64 {
        src1: XReg,
        src2: XReg,
    },
    IfXult64 {
        src1: XReg,
        src2: XReg,
    },
    IfXulteq64 {
        src1: XReg,
        src2: XReg,
    },
    IfXeq64I32 {
        src1: XReg,
        src2: i32,
    },
    IfXneq64I32 {
        src1: XReg,
        src2: i32,
    },
    IfXslt64I32 {
        src1: XReg,
        src2: i32,
    },
    IfXslteq64I32 {
        src1: XReg,
        src2: i32,
    },
    IfXult64I32 {
        src1: XReg,
        src2: u32,
    },
    IfXulteq64I32 {
        src1: XReg,
        src2: u32,
    },
    IfXsgt64I32 {
        src1: XReg,
        src2: i32,
    },
    IfXsgteq64I32 {
        src1: XReg,
        src2: i32,
    },
    IfXugt64I32 {
        src1: XReg,
        src2: u32,
    },
    IfXugteq64I32 {
        src1: XReg,
        src2: u32,
    },
}

/// Internal type ExtKind: defined at src/isa/pulley_shared/inst.isle line 172.
#[derive(Copy, Clone, PartialEq, Eq, Debug)]
pub enum ExtKind {
    None,
    Sign32,
    Sign64,
    Zero32,
    Zero64,
}

/// Internal type VExtKind: defined at src/isa/pulley_shared/inst.isle line 173.
#[derive(Copy, Clone, PartialEq, Eq, Debug)]
pub enum VExtKind {
    None,
    S8x8,
    U8x8,
    S16x4,
    U16x4,
    S32x2,
    U32x2,
}

/// Internal type ValueOffset: defined at src/isa/pulley_shared/inst.isle line 181.
#[derive(Clone, Debug)]
pub enum ValueOffset {
    Both {
        value: Value,
        offset: i32,
    },
}

/// Internal type Amode: defined at src/isa/pulley_shared/inst.isle line 190.
#[derive(Clone, Debug)]
pub enum Amode {
    SpOffset {
        offset: i32,
    },
    RegOffset {
        base: XReg,
        offset: i32,
    },
    Stack {
        amode: StackAMode,
    },
}

/// Internal type AddrO32: defined at src/isa/pulley_shared/inst.isle line 204.
#[derive(Clone, Debug)]
pub enum AddrO32 {
    Base {
        addr: XReg,
        offset: i32,
    },
}

/// Internal type AddrZ: defined at src/isa/pulley_shared/inst.isle line 217.
#[derive(Clone, Debug)]
pub enum AddrZ {
    Base {
        addr: XReg,
        offset: i32,
    },
}

/// Internal type AddrG32: defined at src/isa/pulley_shared/inst.isle line 230.
#[derive(Clone, Debug)]
pub enum AddrG32 {
    RegisterBound {
        host_heap_base: XReg,
        host_heap_bound: XReg,
        wasm_addr: XReg,
        offset: u16,
    },
}

/// Internal type AddrG32Bne: defined at src/isa/pulley_shared/inst.isle line 239.
#[derive(Clone, Debug)]
pub enum AddrG32Bne {
    BoundNe {
        host_heap_base: XReg,
        host_heap_bound_addr: XReg,
        host_heap_bound_offset: u8,
        wasm_addr: XReg,
        offset: u8,
    },
}

/// Internal type SinkableLoad: defined at src/isa/pulley_shared/inst.isle line 269.
#[derive(Clone, Debug)]
pub enum SinkableLoad {
    Load {
        inst: Inst,
        ty: Type,
        addr: Value,
        offset: u8,
    },
}

/// Internal type SunkLoad: defined at src/isa/pulley_shared/inst.isle line 285.
#[derive(Clone, Debug)]
pub enum SunkLoad {
    Load {
        ty: Type,
        addr: Value,
        offset: u8,
    },
}

/// Internal type G32: defined at src/isa/pulley_shared/inst.isle line 308.
#[derive(Clone, Debug)]
pub enum G32 {
    All {
        heap_base: Value,
        heap_bound: Value,
        wasm_addr: Value,
        offset: u16,
    },
}

/// Internal type G32Bne: defined at src/isa/pulley_shared/inst.isle line 317.
#[derive(Clone, Debug)]
pub enum G32Bne {
    All {
        heap_base: Value,
        heap_bound: SinkableLoad,
        wasm_addr: Value,
        offset: u8,
    },
}

/// Internal type HostOffset: defined at src/isa/pulley_shared/inst.isle line 385.
#[derive(Clone, Debug)]
pub enum HostOffset {
    All {
        a: Value,
        b: i32,
    },
}

/// Internal type OobSelect: defined at src/isa/pulley_shared/inst.isle line 394.
#[derive(Clone, Debug)]
pub enum OobSelect {
    All {
        a: Value,
        b: Value,
        c: Value,
        d: u64,
    },
}

/// Internal type OobCond: defined at src/isa/pulley_shared/inst.isle line 432.
#[derive(Clone, Debug)]
pub enum OobCond {
    All {
        a: Value,
        b: u64,
    },
}

/// Internal type RawInst: defined at <OUT_DIR>/pulley_gen.isle line 0.
#[derive(Clone, Debug)]
pub enum RawInst {
    Nop,
    Ret,
    XJump {
        reg: XReg,
    },
    Xmov {
        dst: WritableXReg,
        src: XReg,
    },
    Xzero {
        dst: WritableXReg,
    },
    Xone {
        dst: WritableXReg,
    },
    Xconst8 {
        dst: WritableXReg,
        imm: i8,
    },
    Xconst16 {
        dst: WritableXReg,
        imm: i16,
    },
    Xconst32 {
        dst: WritableXReg,
        imm: i32,
    },
    Xconst64 {
        dst: WritableXReg,
        imm: i64,
    },
    Xadd32 {
        dst: WritableXReg,
        src1: XReg,
        src2: XReg,
    },
    Xadd32U8 {
        dst: WritableXReg,
        src1: XReg,
        src2: u8,
    },
    Xadd32U32 {
        dst: WritableXReg,
        src1: XReg,
        src2: u32,
    },
    Xadd64 {
        dst: WritableXReg,
        src1: XReg,
        src2: XReg,
    },
    Xadd64U8 {
        dst: WritableXReg,
        src1: XReg,
        src2: u8,
    },
    Xadd64U32 {
        dst: WritableXReg,
        src1: XReg,
        src2: u32,
    },
    Xmadd32 {
        dst: WritableXReg,
        src1: XReg,
        src2: XReg,
        src3: XReg,
    },
    Xmadd64 {
        dst: WritableXReg,
        src1: XReg,
        src2: XReg,
        src3: XReg,
    },
    Xsub32 {
        dst: WritableXReg,
        src1: XReg,
        src2: XReg,
    },
    Xsub32U8 {
        dst: WritableXReg,
        src1: XReg,
        src2: u8,
    },
    Xsub32U32 {
        dst: WritableXReg,
        src1: XReg,
        src2: u32,
    },
    Xsub64 {
        dst: WritableXReg,
        src1: XReg,
        src2: XReg,
    },
    Xsub64U8 {
        dst: WritableXReg,
        src1: XReg,
        src2: u8,
    },
    Xsub64U32 {
        dst: WritableXReg,
        src1: XReg,
        src2: u32,
    },
    XMul32 {
        dst: WritableXReg,
        src1: XReg,
        src2: XReg,
    },
    Xmul32S8 {
        dst: WritableXReg,
        src1: XReg,
        src2: i8,
    },
    Xmul32S32 {
        dst: WritableXReg,
        src1: XReg,
        src2: i32,
    },
    XMul64 {
        dst: WritableXReg,
        src1: XReg,
        src2: XReg,
    },
    Xmul64S8 {
        dst: WritableXReg,
        src1: XReg,
        src2: i8,
    },
    Xmul64S32 {
        dst: WritableXReg,
        src1: XReg,
        src2: i32,
    },
    Xctz32 {
        dst: WritableXReg,
        src: XReg,
    },
    Xctz64 {
        dst: WritableXReg,
        src: XReg,
    },
    Xclz32 {
        dst: WritableXReg,
        src: XReg,
    },
    Xclz64 {
        dst: WritableXReg,
        src: XReg,
    },
    Xpopcnt32 {
        dst: WritableXReg,
        src: XReg,
    },
    Xpopcnt64 {
        dst: WritableXReg,
        src: XReg,
    },
    Xrotl32 {
        dst: WritableXReg,
        src1: XReg,
        src2: XReg,
    },
    Xrotl64 {
        dst: WritableXReg,
        src1: XReg,
        src2: XReg,
    },
    Xrotr32 {
        dst: WritableXReg,
        src1: XReg,
        src2: XReg,
    },
    Xrotr64 {
        dst: WritableXReg,
        src1: XReg,
        src2: XReg,
    },
    Xshl32 {
        dst: WritableXReg,
        src1: XReg,
        src2: XReg,
    },
    Xshr32S {
        dst: WritableXReg,
        src1: XReg,
        src2: XReg,
    },
    Xshr32U {
        dst: WritableXReg,
        src1: XReg,
        src2: XReg,
    },
    Xshl64 {
        dst: WritableXReg,
        src1: XReg,
        src2: XReg,
    },
    Xshr64S {
        dst: WritableXReg,
        src1: XReg,
        src2: XReg,
    },
    Xshr64U {
        dst: WritableXReg,
        src1: XReg,
        src2: XReg,
    },
    Xshl32U6 {
        dst: WritableXReg,
        src1: XReg,
        src2: U6,
    },
    Xshr32SU6 {
        dst: WritableXReg,
        src1: XReg,
        src2: U6,
    },
    Xshr32UU6 {
        dst: WritableXReg,
        src1: XReg,
        src2: U6,
    },
    Xshl64U6 {
        dst: WritableXReg,
        src1: XReg,
        src2: U6,
    },
    Xshr64SU6 {
        dst: WritableXReg,
        src1: XReg,
        src2: U6,
    },
    Xshr64UU6 {
        dst: WritableXReg,
        src1: XReg,
        src2: U6,
    },
    Xneg32 {
        dst: WritableXReg,
        src: XReg,
    },
    Xneg64 {
        dst: WritableXReg,
        src: XReg,
    },
    Xeq64 {
        dst: WritableXReg,
        src1: XReg,
        src2: XReg,
    },
    Xneq64 {
        dst: WritableXReg,
        src1: XReg,
        src2: XReg,
    },
    Xslt64 {
        dst: WritableXReg,
        src1: XReg,
        src2: XReg,
    },
    Xslteq64 {
        dst: WritableXReg,
        src1: XReg,
        src2: XReg,
    },
    Xult64 {
        dst: WritableXReg,
        src1: XReg,
        src2: XReg,
    },
    Xulteq64 {
        dst: WritableXReg,
        src1: XReg,
        src2: XReg,
    },
    Xeq32 {
        dst: WritableXReg,
        src1: XReg,
        src2: XReg,
    },
    Xneq32 {
        dst: WritableXReg,
        src1: XReg,
        src2: XReg,
    },
    Xslt32 {
        dst: WritableXReg,
        src1: XReg,
        src2: XReg,
    },
    Xslteq32 {
        dst: WritableXReg,
        src1: XReg,
        src2: XReg,
    },
    Xult32 {
        dst: WritableXReg,
        src1: XReg,
        src2: XReg,
    },
    Xulteq32 {
        dst: WritableXReg,
        src1: XReg,
        src2: XReg,
    },
    XLoad8U32O32 {
        dst: WritableXReg,
        addr: AddrO32,
    },
    XLoad8S32O32 {
        dst: WritableXReg,
        addr: AddrO32,
    },
    XLoad16LeU32O32 {
        dst: WritableXReg,
        addr: AddrO32,
    },
    XLoad16LeS32O32 {
        dst: WritableXReg,
        addr: AddrO32,
    },
    XLoad32LeO32 {
        dst: WritableXReg,
        addr: AddrO32,
    },
    XLoad64LeO32 {
        dst: WritableXReg,
        addr: AddrO32,
    },
    XStore8O32 {
        addr: AddrO32,
        src: XReg,
    },
    XStore16LeO32 {
        addr: AddrO32,
        src: XReg,
    },
    XStore32LeO32 {
        addr: AddrO32,
        src: XReg,
    },
    XStore64LeO32 {
        addr: AddrO32,
        src: XReg,
    },
    XLoad8U32Z {
        dst: WritableXReg,
        addr: AddrZ,
        code: TrapCode,
    },
    XLoad8S32Z {
        dst: WritableXReg,
        addr: AddrZ,
        code: TrapCode,
    },
    XLoad16LeU32Z {
        dst: WritableXReg,
        addr: AddrZ,
        code: TrapCode,
    },
    XLoad16LeS32Z {
        dst: WritableXReg,
        addr: AddrZ,
        code: TrapCode,
    },
    XLoad32LeZ {
        dst: WritableXReg,
        addr: AddrZ,
        code: TrapCode,
    },
    XLoad64LeZ {
        dst: WritableXReg,
        addr: AddrZ,
        code: TrapCode,
    },
    XStore8Z {
        addr: AddrZ,
        src: XReg,
        code: TrapCode,
    },
    XStore16LeZ {
        addr: AddrZ,
        src: XReg,
        code: TrapCode,
    },
    XStore32LeZ {
        addr: AddrZ,
        src: XReg,
        code: TrapCode,
    },
    XStore64LeZ {
        addr: AddrZ,
        src: XReg,
        code: TrapCode,
    },
    XLoad8U32G32 {
        dst: WritableXReg,
        addr: AddrG32,
    },
    XLoad8S32G32 {
        dst: WritableXReg,
        addr: AddrG32,
    },
    XLoad16LeU32G32 {
        dst: WritableXReg,
        addr: AddrG32,
    },
    XLoad16LeS32G32 {
        dst: WritableXReg,
        addr: AddrG32,
    },
    XLoad32LeG32 {
        dst: WritableXReg,
        addr: AddrG32,
    },
    XLoad64LeG32 {
        dst: WritableXReg,
        addr: AddrG32,
    },
    XStore8G32 {
        addr: AddrG32,
        src: XReg,
    },
    XStore16LeG32 {
        addr: AddrG32,
        src: XReg,
    },
    XStore32LeG32 {
        addr: AddrG32,
        src: XReg,
    },
    XStore64LeG32 {
        addr: AddrG32,
        src: XReg,
    },
    XLoad8U32G32Bne {
        dst: WritableXReg,
        addr: AddrG32Bne,
    },
    XLoad8S32G32Bne {
        dst: WritableXReg,
        addr: AddrG32Bne,
    },
    XLoad16LeU32G32Bne {
        dst: WritableXReg,
        addr: AddrG32Bne,
    },
    XLoad16LeS32G32Bne {
        dst: WritableXReg,
        addr: AddrG32Bne,
    },
    XLoad32LeG32Bne {
        dst: WritableXReg,
        addr: AddrG32Bne,
    },
    XLoad64LeG32Bne {
        dst: WritableXReg,
        addr: AddrG32Bne,
    },
    XStore8G32Bne {
        addr: AddrG32Bne,
        src: XReg,
    },
    XStore16LeG32Bne {
        addr: AddrG32Bne,
        src: XReg,
    },
    XStore32LeG32Bne {
        addr: AddrG32Bne,
        src: XReg,
    },
    XStore64LeG32Bne {
        addr: AddrG32Bne,
        src: XReg,
    },
    PushFrame,
    PopFrame,
    PushFrameSave {
        amt: u16,
        regs: UpperXRegSet,
    },
    PopFrameRestore {
        amt: u16,
        regs: UpperXRegSet,
    },
    StackAlloc32 {
        amt: u32,
    },
    StackFree32 {
        amt: u32,
    },
    Zext8 {
        dst: WritableXReg,
        src: XReg,
    },
    Zext16 {
        dst: WritableXReg,
        src: XReg,
    },
    Zext32 {
        dst: WritableXReg,
        src: XReg,
    },
    Sext8 {
        dst: WritableXReg,
        src: XReg,
    },
    Sext16 {
        dst: WritableXReg,
        src: XReg,
    },
    Sext32 {
        dst: WritableXReg,
        src: XReg,
    },
    XAbs32 {
        dst: WritableXReg,
        src: XReg,
    },
    XAbs64 {
        dst: WritableXReg,
        src: XReg,
    },
    XDiv32S {
        dst: WritableXReg,
        src1: XReg,
        src2: XReg,
    },
    XDiv64S {
        dst: WritableXReg,
        src1: XReg,
        src2: XReg,
    },
    XDiv32U {
        dst: WritableXReg,
        src1: XReg,
        src2: XReg,
    },
    XDiv64U {
        dst: WritableXReg,
        src1: XReg,
        src2: XReg,
    },
    XRem32S {
        dst: WritableXReg,
        src1: XReg,
        src2: XReg,
    },
    XRem64S {
        dst: WritableXReg,
        src1: XReg,
        src2: XReg,
    },
    XRem32U {
        dst: WritableXReg,
        src1: XReg,
        src2: XReg,
    },
    XRem64U {
        dst: WritableXReg,
        src1: XReg,
        src2: XReg,
    },
    XBand32 {
        dst: WritableXReg,
        src1: XReg,
        src2: XReg,
    },
    Xband32S8 {
        dst: WritableXReg,
        src1: XReg,
        src2: i8,
    },
    Xband32S32 {
        dst: WritableXReg,
        src1: XReg,
        src2: i32,
    },
    XBand64 {
        dst: WritableXReg,
        src1: XReg,
        src2: XReg,
    },
    Xband64S8 {
        dst: WritableXReg,
        src1: XReg,
        src2: i8,
    },
    Xband64S32 {
        dst: WritableXReg,
        src1: XReg,
        src2: i32,
    },
    XBor32 {
        dst: WritableXReg,
        src1: XReg,
        src2: XReg,
    },
    Xbor32S8 {
        dst: WritableXReg,
        src1: XReg,
        src2: i8,
    },
    Xbor32S32 {
        dst: WritableXReg,
        src1: XReg,
        src2: i32,
    },
    XBor64 {
        dst: WritableXReg,
        src1: XReg,
        src2: XReg,
    },
    Xbor64S8 {
        dst: WritableXReg,
        src1: XReg,
        src2: i8,
    },
    Xbor64S32 {
        dst: WritableXReg,
        src1: XReg,
        src2: i32,
    },
    XBxor32 {
        dst: WritableXReg,
        src1: XReg,
        src2: XReg,
    },
    Xbxor32S8 {
        dst: WritableXReg,
        src1: XReg,
        src2: i8,
    },
    Xbxor32S32 {
        dst: WritableXReg,
        src1: XReg,
        src2: i32,
    },
    XBxor64 {
        dst: WritableXReg,
        src1: XReg,
        src2: XReg,
    },
    Xbxor64S8 {
        dst: WritableXReg,
        src1: XReg,
        src2: i8,
    },
    Xbxor64S32 {
        dst: WritableXReg,
        src1: XReg,
        src2: i32,
    },
    XBnot32 {
        dst: WritableXReg,
        src: XReg,
    },
    XBnot64 {
        dst: WritableXReg,
        src: XReg,
    },
    Xmin32U {
        dst: WritableXReg,
        src1: XReg,
        src2: XReg,
    },
    Xmin32S {
        dst: WritableXReg,
        src1: XReg,
        src2: XReg,
    },
    Xmax32U {
        dst: WritableXReg,
        src1: XReg,
        src2: XReg,
    },
    Xmax32S {
        dst: WritableXReg,
        src1: XReg,
        src2: XReg,
    },
    Xmin64U {
        dst: WritableXReg,
        src1: XReg,
        src2: XReg,
    },
    Xmin64S {
        dst: WritableXReg,
        src1: XReg,
        src2: XReg,
    },
    Xmax64U {
        dst: WritableXReg,
        src1: XReg,
        src2: XReg,
    },
    Xmax64S {
        dst: WritableXReg,
        src1: XReg,
        src2: XReg,
    },
    XSelect32 {
        dst: WritableXReg,
        cond: XReg,
        if_nonzero: XReg,
        if_zero: XReg,
    },
    XSelect64 {
        dst: WritableXReg,
        cond: XReg,
        if_nonzero: XReg,
        if_zero: XReg,
    },
    Trap {
        code: TrapCode,
    },
    Xpcadd {
        dst: WritableXReg,
        offset: PcRelOffset,
    },
    XmovFp {
        dst: WritableXReg,
    },
    XmovLr {
        dst: WritableXReg,
    },
    Bswap32 {
        dst: WritableXReg,
        src: XReg,
    },
    Bswap64 {
        dst: WritableXReg,
        src: XReg,
    },
    Xadd32UoverflowTrap {
        dst: WritableXReg,
        src1: XReg,
        src2: XReg,
        code: TrapCode,
    },
    Xadd64UoverflowTrap {
        dst: WritableXReg,
        src1: XReg,
        src2: XReg,
        code: TrapCode,
    },
    XMulHi64S {
        dst: WritableXReg,
        src1: XReg,
        src2: XReg,
    },
    XMulHi64U {
        dst: WritableXReg,
        src1: XReg,
        src2: XReg,
    },
    Xbmask32 {
        dst: WritableXReg,
        src: XReg,
    },
    Xbmask64 {
        dst: WritableXReg,
        src: XReg,
    },
    XLoad16BeU32O32 {
        dst: WritableXReg,
        addr: AddrO32,
    },
    XLoad16BeS32O32 {
        dst: WritableXReg,
        addr: AddrO32,
    },
    XLoad32BeO32 {
        dst: WritableXReg,
        addr: AddrO32,
    },
    XLoad64BeO32 {
        dst: WritableXReg,
        addr: AddrO32,
    },
    XStore16BeO32 {
        addr: AddrO32,
        src: XReg,
    },
    XStore32BeO32 {
        addr: AddrO32,
        src: XReg,
    },
    XStore64BeO32 {
        addr: AddrO32,
        src: XReg,
    },
    Fload32BeO32 {
        dst: WritableFReg,
        addr: AddrO32,
    },
    Fload64BeO32 {
        dst: WritableFReg,
        addr: AddrO32,
    },
    Fstore32BeO32 {
        addr: AddrO32,
        src: FReg,
    },
    Fstore64BeO32 {
        addr: AddrO32,
        src: FReg,
    },
    Fload32LeO32 {
        dst: WritableFReg,
        addr: AddrO32,
    },
    Fload64LeO32 {
        dst: WritableFReg,
        addr: AddrO32,
    },
    Fstore32LeO32 {
        addr: AddrO32,
        src: FReg,
    },
    Fstore64LeO32 {
        addr: AddrO32,
        src: FReg,
    },
    Fload32LeZ {
        dst: WritableFReg,
        addr: AddrZ,
        code: TrapCode,
    },
    Fload64LeZ {
        dst: WritableFReg,
        addr: AddrZ,
        code: TrapCode,
    },
    Fstore32LeZ {
        addr: AddrZ,
        src: FReg,
        code: TrapCode,
    },
    Fstore64LeZ {
        addr: AddrZ,
        src: FReg,
        code: TrapCode,
    },
    Fload32LeG32 {
        dst: WritableFReg,
        addr: AddrG32,
    },
    Fload64LeG32 {
        dst: WritableFReg,
        addr: AddrG32,
    },
    Fstore32LeG32 {
        addr: AddrG32,
        src: FReg,
    },
    Fstore64LeG32 {
        addr: AddrG32,
        src: FReg,
    },
    VLoad128O32 {
        dst: WritableVReg,
        addr: AddrO32,
    },
    Vstore128LeO32 {
        addr: AddrO32,
        src: VReg,
    },
    VLoad128LeZ {
        dst: WritableVReg,
        addr: AddrZ,
        code: TrapCode,
    },
    Vstore128LeZ {
        addr: AddrZ,
        src: VReg,
        code: TrapCode,
    },
    VLoad128G32 {
        dst: WritableVReg,
        addr: AddrG32,
    },
    Vstore128LeG32 {
        addr: AddrG32,
        src: VReg,
    },
    Fmov {
        dst: WritableFReg,
        src: FReg,
    },
    Vmov {
        dst: WritableVReg,
        src: VReg,
    },
    BitcastIntFromFloat32 {
        dst: WritableXReg,
        src: FReg,
    },
    BitcastIntFromFloat64 {
        dst: WritableXReg,
        src: FReg,
    },
    BitcastFloatFromInt32 {
        dst: WritableFReg,
        src: XReg,
    },
    BitcastFloatFromInt64 {
        dst: WritableFReg,
        src: XReg,
    },
    FConst32 {
        dst: WritableFReg,
        bits: u32,
    },
    FConst64 {
        dst: WritableFReg,
        bits: u64,
    },
    Feq32 {
        dst: WritableXReg,
        src1: FReg,
        src2: FReg,
    },
    Fneq32 {
        dst: WritableXReg,
        src1: FReg,
        src2: FReg,
    },
    Flt32 {
        dst: WritableXReg,
        src1: FReg,
        src2: FReg,
    },
    Flteq32 {
        dst: WritableXReg,
        src1: FReg,
        src2: FReg,
    },
    Feq64 {
        dst: WritableXReg,
        src1: FReg,
        src2: FReg,
    },
    Fneq64 {
        dst: WritableXReg,
        src1: FReg,
        src2: FReg,
    },
    Flt64 {
        dst: WritableXReg,
        src1: FReg,
        src2: FReg,
    },
    Flteq64 {
        dst: WritableXReg,
        src1: FReg,
        src2: FReg,
    },
    FSelect32 {
        dst: WritableFReg,
        cond: XReg,
        if_nonzero: FReg,
        if_zero: FReg,
    },
    FSelect64 {
        dst: WritableFReg,
        cond: XReg,
        if_nonzero: FReg,
        if_zero: FReg,
    },
    F32FromF64 {
        dst: WritableFReg,
        src: FReg,
    },
    F64FromF32 {
        dst: WritableFReg,
        src: FReg,
    },
    F32FromX32S {
        dst: WritableFReg,
        src: XReg,
    },
    F32FromX32U {
        dst: WritableFReg,
        src: XReg,
    },
    F32FromX64S {
        dst: WritableFReg,
        src: XReg,
    },
    F32FromX64U {
        dst: WritableFReg,
        src: XReg,
    },
    F64FromX32S {
        dst: WritableFReg,
        src: XReg,
    },
    F64FromX32U {
        dst: WritableFReg,
        src: XReg,
    },
    F64FromX64S {
        dst: WritableFReg,
        src: XReg,
    },
    F64FromX64U {
        dst: WritableFReg,
        src: XReg,
    },
    X32FromF32S {
        dst: WritableXReg,
        src: FReg,
    },
    X32FromF32U {
        dst: WritableXReg,
        src: FReg,
    },
    X32FromF64S {
        dst: WritableXReg,
        src: FReg,
    },
    X32FromF64U {
        dst: WritableXReg,
        src: FReg,
    },
    X64FromF32S {
        dst: WritableXReg,
        src: FReg,
    },
    X64FromF32U {
        dst: WritableXReg,
        src: FReg,
    },
    X64FromF64S {
        dst: WritableXReg,
        src: FReg,
    },
    X64FromF64U {
        dst: WritableXReg,
        src: FReg,
    },
    X32FromF32SSat {
        dst: WritableXReg,
        src: FReg,
    },
    X32FromF32USat {
        dst: WritableXReg,
        src: FReg,
    },
    X32FromF64SSat {
        dst: WritableXReg,
        src: FReg,
    },
    X32FromF64USat {
        dst: WritableXReg,
        src: FReg,
    },
    X64FromF32SSat {
        dst: WritableXReg,
        src: FReg,
    },
    X64FromF32USat {
        dst: WritableXReg,
        src: FReg,
    },
    X64FromF64SSat {
        dst: WritableXReg,
        src: FReg,
    },
    X64FromF64USat {
        dst: WritableXReg,
        src: FReg,
    },
    FCopySign32 {
        dst: WritableFReg,
        src1: FReg,
        src2: FReg,
    },
    FCopySign64 {
        dst: WritableFReg,
        src1: FReg,
        src2: FReg,
    },
    Fadd32 {
        dst: WritableFReg,
        src1: FReg,
        src2: FReg,
    },
    Fsub32 {
        dst: WritableFReg,
        src1: FReg,
        src2: FReg,
    },
    Vsubf32x4 {
        dst: WritableVReg,
        src1: VReg,
        src2: VReg,
    },
    Fmul32 {
        dst: WritableFReg,
        src1: FReg,
        src2: FReg,
    },
    Vmulf32x4 {
        dst: WritableVReg,
        src1: VReg,
        src2: VReg,
    },
    Fdiv32 {
        dst: WritableFReg,
        src1: FReg,
        src2: FReg,
    },
    Vdivf32x4 {
        dst: WritableVReg,
        src1: VReg,
        src2: VReg,
    },
    Fmaximum32 {
        dst: WritableFReg,
        src1: FReg,
        src2: FReg,
    },
    Fminimum32 {
        dst: WritableFReg,
        src1: FReg,
        src2: FReg,
    },
    Ftrunc32 {
        dst: WritableFReg,
        src: FReg,
    },
    Vtrunc32x4 {
        dst: WritableVReg,
        src: VReg,
    },
    Vtrunc64x2 {
        dst: WritableVReg,
        src: VReg,
    },
    Ffloor32 {
        dst: WritableFReg,
        src: FReg,
    },
    Vfloor32x4 {
        dst: WritableVReg,
        src: VReg,
    },
    Vfloor64x2 {
        dst: WritableVReg,
        src: VReg,
    },
    Fceil32 {
        dst: WritableFReg,
        src: FReg,
    },
    Vceil32x4 {
        dst: WritableVReg,
        src: VReg,
    },
    Vceil64x2 {
        dst: WritableVReg,
        src: VReg,
    },
    Fnearest32 {
        dst: WritableFReg,
        src: FReg,
    },
    Fsqrt32 {
        dst: WritableFReg,
        src: FReg,
    },
    Vsqrt32x4 {
        dst: WritableVReg,
        src: VReg,
    },
    Vsqrt64x2 {
        dst: WritableVReg,
        src: VReg,
    },
    Fneg32 {
        dst: WritableFReg,
        src: FReg,
    },
    Vnegf32x4 {
        dst: WritableVReg,
        src: VReg,
    },
    Fabs32 {
        dst: WritableFReg,
        src: FReg,
    },
    Fadd64 {
        dst: WritableFReg,
        src1: FReg,
        src2: FReg,
    },
    Fsub64 {
        dst: WritableFReg,
        src1: FReg,
        src2: FReg,
    },
    Fmul64 {
        dst: WritableFReg,
        src1: FReg,
        src2: FReg,
    },
    Fdiv64 {
        dst: WritableFReg,
        src1: FReg,
        src2: FReg,
    },
    VDivF64x2 {
        dst: WritableVReg,
        src1: VReg,
        src2: VReg,
    },
    Fmaximum64 {
        dst: WritableFReg,
        src1: FReg,
        src2: FReg,
    },
    Fminimum64 {
        dst: WritableFReg,
        src1: FReg,
        src2: FReg,
    },
    Ftrunc64 {
        dst: WritableFReg,
        src: FReg,
    },
    Ffloor64 {
        dst: WritableFReg,
        src: FReg,
    },
    Fceil64 {
        dst: WritableFReg,
        src: FReg,
    },
    Fnearest64 {
        dst: WritableFReg,
        src: FReg,
    },
    Vnearest32x4 {
        dst: WritableVReg,
        src: VReg,
    },
    Vnearest64x2 {
        dst: WritableVReg,
        src: VReg,
    },
    Fsqrt64 {
        dst: WritableFReg,
        src: FReg,
    },
    Fneg64 {
        dst: WritableFReg,
        src: FReg,
    },
    Fabs64 {
        dst: WritableFReg,
        src: FReg,
    },
    Vconst128 {
        dst: WritableVReg,
        imm: u128,
    },
    VAddI8x16 {
        dst: WritableVReg,
        src1: VReg,
        src2: VReg,
    },
    VAddI16x8 {
        dst: WritableVReg,
        src1: VReg,
        src2: VReg,
    },
    VAddI32x4 {
        dst: WritableVReg,
        src1: VReg,
        src2: VReg,
    },
    VAddI64x2 {
        dst: WritableVReg,
        src1: VReg,
        src2: VReg,
    },
    VAddF32x4 {
        dst: WritableVReg,
        src1: VReg,
        src2: VReg,
    },
    VAddF64x2 {
        dst: WritableVReg,
        src1: VReg,
        src2: VReg,
    },
    VAddI8x16Sat {
        dst: WritableVReg,
        src1: VReg,
        src2: VReg,
    },
    VAddU8x16Sat {
        dst: WritableVReg,
        src1: VReg,
        src2: VReg,
    },
    VAddI16x8Sat {
        dst: WritableVReg,
        src1: VReg,
        src2: VReg,
    },
    VAddU16x8Sat {
        dst: WritableVReg,
        src1: VReg,
        src2: VReg,
    },
    VAddpairwiseI16x8S {
        dst: WritableVReg,
        src1: VReg,
        src2: VReg,
    },
    VAddpairwiseI32x4S {
        dst: WritableVReg,
        src1: VReg,
        src2: VReg,
    },
    VShlI8x16 {
        dst: WritableVReg,
        src1: VReg,
        src2: XReg,
    },
    VShlI16x8 {
        dst: WritableVReg,
        src1: VReg,
        src2: XReg,
    },
    VShlI32x4 {
        dst: WritableVReg,
        src1: VReg,
        src2: XReg,
    },
    VShlI64x2 {
        dst: WritableVReg,
        src1: VReg,
        src2: XReg,
    },
    VShrI8x16S {
        dst: WritableVReg,
        src1: VReg,
        src2: XReg,
    },
    VShrI16x8S {
        dst: WritableVReg,
        src1: VReg,
        src2: XReg,
    },
    VShrI32x4S {
        dst: WritableVReg,
        src1: VReg,
        src2: XReg,
    },
    VShrI64x2S {
        dst: WritableVReg,
        src1: VReg,
        src2: XReg,
    },
    VShrI8x16U {
        dst: WritableVReg,
        src1: VReg,
        src2: XReg,
    },
    VShrI16x8U {
        dst: WritableVReg,
        src1: VReg,
        src2: XReg,
    },
    VShrI32x4U {
        dst: WritableVReg,
        src1: VReg,
        src2: XReg,
    },
    VShrI64x2U {
        dst: WritableVReg,
        src1: VReg,
        src2: XReg,
    },
    VSplatX8 {
        dst: WritableVReg,
        src: XReg,
    },
    VSplatX16 {
        dst: WritableVReg,
        src: XReg,
    },
    VSplatX32 {
        dst: WritableVReg,
        src: XReg,
    },
    VSplatX64 {
        dst: WritableVReg,
        src: XReg,
    },
    VSplatF32 {
        dst: WritableVReg,
        src: FReg,
    },
    VSplatF64 {
        dst: WritableVReg,
        src: FReg,
    },
    VLoad8x8SZ {
        dst: WritableVReg,
        addr: AddrZ,
        code: TrapCode,
    },
    VLoad8x8UZ {
        dst: WritableVReg,
        addr: AddrZ,
        code: TrapCode,
    },
    VLoad16x4LeSZ {
        dst: WritableVReg,
        addr: AddrZ,
        code: TrapCode,
    },
    VLoad16x4LeUZ {
        dst: WritableVReg,
        addr: AddrZ,
        code: TrapCode,
    },
    VLoad32x2LeSZ {
        dst: WritableVReg,
        addr: AddrZ,
        code: TrapCode,
    },
    VLoad32x2LeUZ {
        dst: WritableVReg,
        addr: AddrZ,
        code: TrapCode,
    },
    VBand128 {
        dst: WritableVReg,
        src1: VReg,
        src2: VReg,
    },
    VBor128 {
        dst: WritableVReg,
        src1: VReg,
        src2: VReg,
    },
    VBxor128 {
        dst: WritableVReg,
        src1: VReg,
        src2: VReg,
    },
    VBnot128 {
        dst: WritableVReg,
        src: VReg,
    },
    VBitselect128 {
        dst: WritableVReg,
        c: VReg,
        x: VReg,
        y: VReg,
    },
    Vbitmask8x16 {
        dst: WritableXReg,
        src: VReg,
    },
    Vbitmask16x8 {
        dst: WritableXReg,
        src: VReg,
    },
    Vbitmask32x4 {
        dst: WritableXReg,
        src: VReg,
    },
    Vbitmask64x2 {
        dst: WritableXReg,
        src: VReg,
    },
    Valltrue8x16 {
        dst: WritableXReg,
        src: VReg,
    },
    Valltrue16x8 {
        dst: WritableXReg,
        src: VReg,
    },
    Valltrue32x4 {
        dst: WritableXReg,
        src: VReg,
    },
    Valltrue64x2 {
        dst: WritableXReg,
        src: VReg,
    },
    Vanytrue8x16 {
        dst: WritableXReg,
        src: VReg,
    },
    Vanytrue16x8 {
        dst: WritableXReg,
        src: VReg,
    },
    Vanytrue32x4 {
        dst: WritableXReg,
        src: VReg,
    },
    Vanytrue64x2 {
        dst: WritableXReg,
        src: VReg,
    },
    VF32x4FromI32x4S {
        dst: WritableVReg,
        src: VReg,
    },
    VF32x4FromI32x4U {
        dst: WritableVReg,
        src: VReg,
    },
    VF64x2FromI64x2S {
        dst: WritableVReg,
        src: VReg,
    },
    VF64x2FromI64x2U {
        dst: WritableVReg,
        src: VReg,
    },
    VI32x4FromF32x4S {
        dst: WritableVReg,
        src: VReg,
    },
    VI32x4FromF32x4U {
        dst: WritableVReg,
        src: VReg,
    },
    VI64x2FromF64x2S {
        dst: WritableVReg,
        src: VReg,
    },
    VI64x2FromF64x2U {
        dst: WritableVReg,
        src: VReg,
    },
    VWidenLow8x16S {
        dst: WritableVReg,
        src: VReg,
    },
    VWidenLow8x16U {
        dst: WritableVReg,
        src: VReg,
    },
    VWidenLow16x8S {
        dst: WritableVReg,
        src: VReg,
    },
    VWidenLow16x8U {
        dst: WritableVReg,
        src: VReg,
    },
    VWidenLow32x4S {
        dst: WritableVReg,
        src: VReg,
    },
    VWidenLow32x4U {
        dst: WritableVReg,
        src: VReg,
    },
    VWidenHigh8x16S {
        dst: WritableVReg,
        src: VReg,
    },
    VWidenHigh8x16U {
        dst: WritableVReg,
        src: VReg,
    },
    VWidenHigh16x8S {
        dst: WritableVReg,
        src: VReg,
    },
    VWidenHigh16x8U {
        dst: WritableVReg,
        src: VReg,
    },
    VWidenHigh32x4S {
        dst: WritableVReg,
        src: VReg,
    },
    VWidenHigh32x4U {
        dst: WritableVReg,
        src: VReg,
    },
    Vnarrow16x8S {
        dst: WritableVReg,
        src1: VReg,
        src2: VReg,
    },
    Vnarrow16x8U {
        dst: WritableVReg,
        src1: VReg,
        src2: VReg,
    },
    Vnarrow32x4S {
        dst: WritableVReg,
        src1: VReg,
        src2: VReg,
    },
    Vnarrow32x4U {
        dst: WritableVReg,
        src1: VReg,
        src2: VReg,
    },
    Vnarrow64x2S {
        dst: WritableVReg,
        src1: VReg,
        src2: VReg,
    },
    Vnarrow64x2U {
        dst: WritableVReg,
        src1: VReg,
        src2: VReg,
    },
    Vunarrow64x2U {
        dst: WritableVReg,
        src1: VReg,
        src2: VReg,
    },
    VFpromoteLow {
        dst: WritableVReg,
        src: VReg,
    },
    VFdemote {
        dst: WritableVReg,
        src: VReg,
    },
    VSubI8x16 {
        dst: WritableVReg,
        src1: VReg,
        src2: VReg,
    },
    VSubI16x8 {
        dst: WritableVReg,
        src1: VReg,
        src2: VReg,
    },
    VSubI32x4 {
        dst: WritableVReg,
        src1: VReg,
        src2: VReg,
    },
    VSubI64x2 {
        dst: WritableVReg,
        src1: VReg,
        src2: VReg,
    },
    VSubF64x2 {
        dst: WritableVReg,
        src1: VReg,
        src2: VReg,
    },
    VSubI8x16Sat {
        dst: WritableVReg,
        src1: VReg,
        src2: VReg,
    },
    VSubU8x16Sat {
        dst: WritableVReg,
        src1: VReg,
        src2: VReg,
    },
    VSubI16x8Sat {
        dst: WritableVReg,
        src1: VReg,
        src2: VReg,
    },
    VSubU16x8Sat {
        dst: WritableVReg,
        src1: VReg,
        src2: VReg,
    },
    VMulI8x16 {
        dst: WritableVReg,
        src1: VReg,
        src2: VReg,
    },
    VMulI16x8 {
        dst: WritableVReg,
        src1: VReg,
        src2: VReg,
    },
    VMulI32x4 {
        dst: WritableVReg,
        src1: VReg,
        src2: VReg,
    },
    VMulI64x2 {
        dst: WritableVReg,
        src1: VReg,
        src2: VReg,
    },
    VMulF64x2 {
        dst: WritableVReg,
        src1: VReg,
        src2: VReg,
    },
    VQmulrsI16x8 {
        dst: WritableVReg,
        src1: VReg,
        src2: VReg,
    },
    VPopcnt8x16 {
        dst: WritableVReg,
        src: VReg,
    },
    XExtractV8x16 {
        dst: WritableXReg,
        src: VReg,
        lane: u8,
    },
    XExtractV16x8 {
        dst: WritableXReg,
        src: VReg,
        lane: u8,
    },
    XExtractV32x4 {
        dst: WritableXReg,
        src: VReg,
        lane: u8,
    },
    XExtractV64x2 {
        dst: WritableXReg,
        src: VReg,
        lane: u8,
    },
    FExtractV32x4 {
        dst: WritableFReg,
        src: VReg,
        lane: u8,
    },
    FExtractV64x2 {
        dst: WritableFReg,
        src: VReg,
        lane: u8,
    },
    VInsertX8 {
        dst: WritableVReg,
        src1: VReg,
        src2: XReg,
        lane: u8,
    },
    VInsertX16 {
        dst: WritableVReg,
        src1: VReg,
        src2: XReg,
        lane: u8,
    },
    VInsertX32 {
        dst: WritableVReg,
        src1: VReg,
        src2: XReg,
        lane: u8,
    },
    VInsertX64 {
        dst: WritableVReg,
        src1: VReg,
        src2: XReg,
        lane: u8,
    },
    VInsertF32 {
        dst: WritableVReg,
        src1: VReg,
        src2: FReg,
        lane: u8,
    },
    VInsertF64 {
        dst: WritableVReg,
        src1: VReg,
        src2: FReg,
        lane: u8,
    },
    Veq8x16 {
        dst: WritableVReg,
        src1: VReg,
        src2: VReg,
    },
    Vneq8x16 {
        dst: WritableVReg,
        src1: VReg,
        src2: VReg,
    },
    Vslt8x16 {
        dst: WritableVReg,
        src1: VReg,
        src2: VReg,
    },
    Vslteq8x16 {
        dst: WritableVReg,
        src1: VReg,
        src2: VReg,
    },
    Vult8x16 {
        dst: WritableVReg,
        src1: VReg,
        src2: VReg,
    },
    Vulteq8x16 {
        dst: WritableVReg,
        src1: VReg,
        src2: VReg,
    },
    Veq16x8 {
        dst: WritableVReg,
        src1: VReg,
        src2: VReg,
    },
    Vneq16x8 {
        dst: WritableVReg,
        src1: VReg,
        src2: VReg,
    },
    Vslt16x8 {
        dst: WritableVReg,
        src1: VReg,
        src2: VReg,
    },
    Vslteq16x8 {
        dst: WritableVReg,
        src1: VReg,
        src2: VReg,
    },
    Vult16x8 {
        dst: WritableVReg,
        src1: VReg,
        src2: VReg,
    },
    Vulteq16x8 {
        dst: WritableVReg,
        src1: VReg,
        src2: VReg,
    },
    Veq32x4 {
        dst: WritableVReg,
        src1: VReg,
        src2: VReg,
    },
    Vneq32x4 {
        dst: WritableVReg,
        src1: VReg,
        src2: VReg,
    },
    Vslt32x4 {
        dst: WritableVReg,
        src1: VReg,
        src2: VReg,
    },
    Vslteq32x4 {
        dst: WritableVReg,
        src1: VReg,
        src2: VReg,
    },
    Vult32x4 {
        dst: WritableVReg,
        src1: VReg,
        src2: VReg,
    },
    Vulteq32x4 {
        dst: WritableVReg,
        src1: VReg,
        src2: VReg,
    },
    Veq64x2 {
        dst: WritableVReg,
        src1: VReg,
        src2: VReg,
    },
    Vneq64x2 {
        dst: WritableVReg,
        src1: VReg,
        src2: VReg,
    },
    Vslt64x2 {
        dst: WritableVReg,
        src1: VReg,
        src2: VReg,
    },
    Vslteq64x2 {
        dst: WritableVReg,
        src1: VReg,
        src2: VReg,
    },
    Vult64x2 {
        dst: WritableVReg,
        src1: VReg,
        src2: VReg,
    },
    Vulteq64x2 {
        dst: WritableVReg,
        src1: VReg,
        src2: VReg,
    },
    Vneg8x16 {
        dst: WritableVReg,
        src: VReg,
    },
    Vneg16x8 {
        dst: WritableVReg,
        src: VReg,
    },
    Vneg32x4 {
        dst: WritableVReg,
        src: VReg,
    },
    Vneg64x2 {
        dst: WritableVReg,
        src: VReg,
    },
    VnegF64x2 {
        dst: WritableVReg,
        src: VReg,
    },
    Vmin8x16S {
        dst: WritableVReg,
        src1: VReg,
        src2: VReg,
    },
    Vmin8x16U {
        dst: WritableVReg,
        src1: VReg,
        src2: VReg,
    },
    Vmin16x8S {
        dst: WritableVReg,
        src1: VReg,
        src2: VReg,
    },
    Vmin16x8U {
        dst: WritableVReg,
        src1: VReg,
        src2: VReg,
    },
    Vmax8x16S {
        dst: WritableVReg,
        src1: VReg,
        src2: VReg,
    },
    Vmax8x16U {
        dst: WritableVReg,
        src1: VReg,
        src2: VReg,
    },
    Vmax16x8S {
        dst: WritableVReg,
        src1: VReg,
        src2: VReg,
    },
    Vmax16x8U {
        dst: WritableVReg,
        src1: VReg,
        src2: VReg,
    },
    Vmin32x4S {
        dst: WritableVReg,
        src1: VReg,
        src2: VReg,
    },
    Vmin32x4U {
        dst: WritableVReg,
        src1: VReg,
        src2: VReg,
    },
    Vmax32x4S {
        dst: WritableVReg,
        src1: VReg,
        src2: VReg,
    },
    Vmax32x4U {
        dst: WritableVReg,
        src1: VReg,
        src2: VReg,
    },
    Vabs8x16 {
        dst: WritableVReg,
        src: VReg,
    },
    Vabs16x8 {
        dst: WritableVReg,
        src: VReg,
    },
    Vabs32x4 {
        dst: WritableVReg,
        src: VReg,
    },
    Vabs64x2 {
        dst: WritableVReg,
        src: VReg,
    },
    Vabsf32x4 {
        dst: WritableVReg,
        src: VReg,
    },
    Vabsf64x2 {
        dst: WritableVReg,
        src: VReg,
    },
    Vmaximumf32x4 {
        dst: WritableVReg,
        src1: VReg,
        src2: VReg,
    },
    Vmaximumf64x2 {
        dst: WritableVReg,
        src1: VReg,
        src2: VReg,
    },
    Vminimumf32x4 {
        dst: WritableVReg,
        src1: VReg,
        src2: VReg,
    },
    Vminimumf64x2 {
        dst: WritableVReg,
        src1: VReg,
        src2: VReg,
    },
    VShuffle {
        dst: WritableVReg,
        src1: VReg,
        src2: VReg,
        mask: u128,
    },
    Vswizzlei8x16 {
        dst: WritableVReg,
        src1: VReg,
        src2: VReg,
    },
    Vavground8x16 {
        dst: WritableVReg,
        src1: VReg,
        src2: VReg,
    },
    Vavground16x8 {
        dst: WritableVReg,
        src1: VReg,
        src2: VReg,
    },
    VeqF32x4 {
        dst: WritableVReg,
        src1: VReg,
        src2: VReg,
    },
    VneqF32x4 {
        dst: WritableVReg,
        src1: VReg,
        src2: VReg,
    },
    VltF32x4 {
        dst: WritableVReg,
        src1: VReg,
        src2: VReg,
    },
    VlteqF32x4 {
        dst: WritableVReg,
        src1: VReg,
        src2: VReg,
    },
    VeqF64x2 {
        dst: WritableVReg,
        src1: VReg,
        src2: VReg,
    },
    VneqF64x2 {
        dst: WritableVReg,
        src1: VReg,
        src2: VReg,
    },
    VltF64x2 {
        dst: WritableVReg,
        src1: VReg,
        src2: VReg,
    },
    VlteqF64x2 {
        dst: WritableVReg,
        src1: VReg,
        src2: VReg,
    },
    Vfma32x4 {
        dst: WritableVReg,
        a: VReg,
        b: VReg,
        c: VReg,
    },
    Vfma64x2 {
        dst: WritableVReg,
        a: VReg,
        b: VReg,
        c: VReg,
    },
    Vselect {
        dst: WritableVReg,
        cond: XReg,
        if_nonzero: VReg,
        if_zero: VReg,
    },
    Xadd128 {
        dst_lo: WritableXReg,
        dst_hi: WritableXReg,
        lhs_lo: XReg,
        lhs_hi: XReg,
        rhs_lo: XReg,
        rhs_hi: XReg,
    },
    Xsub128 {
        dst_lo: WritableXReg,
        dst_hi: WritableXReg,
        lhs_lo: XReg,
        lhs_hi: XReg,
        rhs_lo: XReg,
        rhs_hi: XReg,
    },
    Xwidemul64S {
        dst_lo: WritableXReg,
        dst_hi: WritableXReg,
        lhs: XReg,
        rhs: XReg,
    },
    Xwidemul64U {
        dst_lo: WritableXReg,
        dst_hi: WritableXReg,
        lhs: XReg,
        rhs: XReg,
    },
    XLoad16BeU32Z {
        dst: WritableXReg,
        addr: AddrZ,
        code: TrapCode,
    },
    XLoad16BeS32Z {
        dst: WritableXReg,
        addr: AddrZ,
        code: TrapCode,
    },
    XLoad32BeZ {
        dst: WritableXReg,
        addr: AddrZ,
        code: TrapCode,
    },
    XLoad64BeZ {
        dst: WritableXReg,
        addr: AddrZ,
        code: TrapCode,
    },
    XStore16BeZ {
        addr: AddrZ,
        src: XReg,
        code: TrapCode,
    },
    XStore32BeZ {
        addr: AddrZ,
        src: XReg,
        code: TrapCode,
    },
    XStore64BeZ {
        addr: AddrZ,
        src: XReg,
        code: TrapCode,
    },
    Fload32BeZ {
        dst: WritableFReg,
        addr: AddrZ,
        code: TrapCode,
    },
    Fload64BeZ {
        dst: WritableFReg,
        addr: AddrZ,
        code: TrapCode,
    },
    Fstore32BeZ {
        addr: AddrZ,
        src: FReg,
        code: TrapCode,
    },
    Fstore64BeZ {
        addr: AddrZ,
        src: FReg,
        code: TrapCode,
    },
    VLoad128BeZ {
        dst: WritableVReg,
        addr: AddrZ,
        code: TrapCode,
    },
    Vstore128BeZ {
        addr: AddrZ,
        src: VReg,
        code: TrapCode,
    },
}

// Generated as internal constructor for term ty_shift_mask.
pub fn constructor_ty_shift_mask<C: Context>(
    ctx: &mut C,
    arg0: Type,
) -> u64 {
    let v1 = C::lane_type(ctx, arg0);
    let v2 = C::ty_bits(ctx, v1);
    let v3 = C::u8_into_u64(ctx, v2);
    let v5 = C::u64_sub(ctx, v3, 0x1_u64);
    // Rule at src/prelude.isle line 355.
    return v5;
}

// Generated as internal constructor for term output_reg.
pub fn constructor_output_reg<C: Context>(
    ctx: &mut C,
    arg0: Reg,
) -> InstOutput {
    let v1 = C::value_reg(ctx, arg0);
    let v2 = C::output(ctx, v1);
    // Rule at src/prelude_lower.isle line 81.
    return v2;
}

// Generated as internal constructor for term output_value.
pub fn constructor_output_value<C: Context>(
    ctx: &mut C,
    arg0: Value,
) -> InstOutput {
    let v1 = C::put_in_regs(ctx, arg0);
    let v2 = C::output(ctx, v1);
    // Rule at src/prelude_lower.isle line 85.
    return v2;
}

// Generated as internal constructor for term temp_reg.
pub fn constructor_temp_reg<C: Context>(
    ctx: &mut C,
    arg0: Type,
) -> Reg {
    let v1 = C::temp_writable_reg(ctx, arg0);
    let v2 = C::writable_reg_to_reg(ctx, v1);
    // Rule at src/prelude_lower.isle line 97.
    return v2;
}

// Generated as internal constructor for term lo_reg.
pub fn constructor_lo_reg<C: Context>(
    ctx: &mut C,
    arg0: Value,
) -> Reg {
    let v1 = C::put_in_regs(ctx, arg0);
    let v3 = C::value_regs_get(ctx, v1, 0x0_usize);
    // Rule at src/prelude_lower.isle line 157.
    return v3;
}

// Generated as internal constructor for term multi_reg_to_pair_and_single.
pub fn constructor_multi_reg_to_pair_and_single<C: Context>(
    ctx: &mut C,
    arg0: &MultiReg,
) -> InstOutput {
    if let &MultiReg::Three {
        a: v1,
        b: v2,
        c: v3,
    } = arg0 {
        let v4 = C::value_regs(ctx, v1, v2);
        let v5 = C::value_reg(ctx, v3);
        let v6 = C::output_pair(ctx, v4, v5);
        // Rule at src/prelude_lower.isle line 168.
        return v6;
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "multi_reg_to_pair_and_single", "src/prelude_lower.isle line 167")
}

// Generated as internal constructor for term multi_reg_to_pair.
pub fn constructor_multi_reg_to_pair<C: Context>(
    ctx: &mut C,
    arg0: &MultiReg,
) -> InstOutput {
    if let &MultiReg::Two {
        a: v1,
        b: v2,
    } = arg0 {
        let v3 = C::value_regs(ctx, v1, v2);
        let v4 = C::output(ctx, v3);
        // Rule at src/prelude_lower.isle line 173.
        return v4;
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "multi_reg_to_pair", "src/prelude_lower.isle line 172")
}

// Generated as internal constructor for term multi_reg_to_single.
pub fn constructor_multi_reg_to_single<C: Context>(
    ctx: &mut C,
    arg0: &MultiReg,
) -> InstOutput {
    if let &MultiReg::One {
        a: v1,
    } = arg0 {
        let v2 = C::value_reg(ctx, v1);
        let v3 = C::output(ctx, v2);
        // Rule at src/prelude_lower.isle line 178.
        return v3;
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "multi_reg_to_single", "src/prelude_lower.isle line 177")
}

// Generated as internal constructor for term emit_side_effect.
pub fn constructor_emit_side_effect<C: Context>(
    ctx: &mut C,
    arg0: &SideEffectNoResult,
) -> Unit {
    match arg0 {
        &SideEffectNoResult::Inst {
            inst: ref v1,
        } => {
            let v2 = C::emit(ctx, v1);
            // Rule at src/prelude_lower.isle line 441.
            return v2;
        }
        &SideEffectNoResult::Inst2 {
            inst1: ref v3,
            inst2: ref v4,
        } => {
            let v5 = C::emit(ctx, v3);
            let v6 = C::emit(ctx, v4);
            // Rule at src/prelude_lower.isle line 443.
            return v6;
        }
        &SideEffectNoResult::Inst3 {
            inst1: ref v7,
            inst2: ref v8,
            inst3: ref v9,
        } => {
            let v10 = C::emit(ctx, v7);
            let v11 = C::emit(ctx, v8);
            let v12 = C::emit(ctx, v9);
            // Rule at src/prelude_lower.isle line 446.
            return v12;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "emit_side_effect", "src/prelude_lower.isle line 440")
}

// Generated as internal constructor for term side_effect.
pub fn constructor_side_effect<C: Context>(
    ctx: &mut C,
    arg0: &SideEffectNoResult,
) -> InstOutput {
    let v1 = constructor_emit_side_effect(ctx, arg0);
    let v2 = C::output_none(ctx);
    // Rule at src/prelude_lower.isle line 456.
    return v2;
}

// Generated as internal constructor for term side_effect_concat.
pub fn constructor_side_effect_concat<C: Context>(
    ctx: &mut C,
    arg0: &SideEffectNoResult,
    arg1: &SideEffectNoResult,
) -> SideEffectNoResult {
    match arg0 {
        &SideEffectNoResult::Inst {
            inst: ref v1,
        } => {
            match arg1 {
                &SideEffectNoResult::Inst {
                    inst: ref v3,
                } => {
                    let v4 = SideEffectNoResult::Inst2 {
                        inst1: v1.clone(),
                        inst2: v3.clone(),
                    };
                    // Rule at src/prelude_lower.isle line 461.
                    return v4;
                }
                &SideEffectNoResult::Inst2 {
                    inst1: ref v5,
                    inst2: ref v6,
                } => {
                    let v7 = SideEffectNoResult::Inst3 {
                        inst1: v1.clone(),
                        inst2: v5.clone(),
                        inst3: v6.clone(),
                    };
                    // Rule at src/prelude_lower.isle line 463.
                    return v7;
                }
                _ => {}
            }
        }
        &SideEffectNoResult::Inst2 {
            inst1: ref v8,
            inst2: ref v9,
        } => {
            if let &SideEffectNoResult::Inst {
                inst: ref v3,
            } = arg1 {
                let v10 = SideEffectNoResult::Inst3 {
                    inst1: v8.clone(),
                    inst2: v9.clone(),
                    inst3: v3.clone(),
                };
                // Rule at src/prelude_lower.isle line 465.
                return v10;
            }
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "side_effect_concat", "src/prelude_lower.isle line 460")
}

// Generated as internal constructor for term side_effect_as_invalid.
pub fn constructor_side_effect_as_invalid<C: Context>(
    ctx: &mut C,
    arg0: &SideEffectNoResult,
) -> InstOutput {
    let v1 = constructor_side_effect(ctx, arg0);
    let v2 = C::invalid_reg(ctx);
    let v3 = constructor_output_reg(ctx, v2);
    // Rule at src/prelude_lower.isle line 471.
    return v3;
}

// Generated as internal constructor for term produces_flags_concat.
pub fn constructor_produces_flags_concat<C: Context>(
    ctx: &mut C,
    arg0: &ProducesFlags,
    arg1: &ProducesFlags,
) -> ProducesFlags {
    if let &ProducesFlags::ProducesFlagsSideEffect {
        inst: ref v1,
    } = arg0 {
        if let &ProducesFlags::ProducesFlagsSideEffect {
            inst: ref v3,
        } = arg1 {
            let v4 = ProducesFlags::ProducesFlagsTwiceSideEffect {
                inst1: v1.clone(),
                inst2: v3.clone(),
            };
            // Rule at src/prelude_lower.isle line 497.
            return v4;
        }
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "produces_flags_concat", "src/prelude_lower.isle line 496")
}

// Generated as internal constructor for term produces_flags_get_reg.
pub fn constructor_produces_flags_get_reg<C: Context>(
    ctx: &mut C,
    arg0: &ProducesFlags,
) -> Reg {
    match arg0 {
        &ProducesFlags::ProducesFlagsReturnsReg {
            inst: ref v1,
            result: v2,
        } => {
            // Rule at src/prelude_lower.isle line 527.
            return v2;
        }
        &ProducesFlags::ProducesFlagsReturnsResultWithConsumer {
            inst: ref v3,
            result: v4,
        } => {
            // Rule at src/prelude_lower.isle line 528.
            return v4;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "produces_flags_get_reg", "src/prelude_lower.isle line 526")
}

// Generated as internal constructor for term produces_flags_ignore.
pub fn constructor_produces_flags_ignore<C: Context>(
    ctx: &mut C,
    arg0: &ProducesFlags,
) -> ProducesFlags {
    match arg0 {
        &ProducesFlags::ProducesFlagsReturnsReg {
            inst: ref v1,
            result: v2,
        } => {
            let v3 = ProducesFlags::ProducesFlagsSideEffect {
                inst: v1.clone(),
            };
            // Rule at src/prelude_lower.isle line 533.
            return v3;
        }
        &ProducesFlags::ProducesFlagsReturnsResultWithConsumer {
            inst: ref v4,
            result: v5,
        } => {
            let v6 = ProducesFlags::ProducesFlagsSideEffect {
                inst: v4.clone(),
            };
            // Rule at src/prelude_lower.isle line 535.
            return v6;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "produces_flags_ignore", "src/prelude_lower.isle line 532")
}

// Generated as internal constructor for term consumes_flags_concat.
pub fn constructor_consumes_flags_concat<C: Context>(
    ctx: &mut C,
    arg0: &ConsumesFlags,
    arg1: &ConsumesFlags,
) -> ConsumesFlags {
    match arg0 {
        &ConsumesFlags::ConsumesFlagsSideEffect {
            inst: ref v8,
        } => {
            if let &ConsumesFlags::ConsumesFlagsSideEffect {
                inst: ref v9,
            } = arg1 {
                let v10 = ConsumesFlags::ConsumesFlagsSideEffect2 {
                    inst1: v8.clone(),
                    inst2: v9.clone(),
                };
                // Rule at src/prelude_lower.isle line 548.
                return v10;
            }
        }
        &ConsumesFlags::ConsumesFlagsReturnsReg {
            inst: ref v1,
            result: v2,
        } => {
            if let &ConsumesFlags::ConsumesFlagsReturnsReg {
                inst: ref v4,
                result: v5,
            } = arg1 {
                let v6 = C::value_regs(ctx, v2, v5);
                let v7 = ConsumesFlags::ConsumesFlagsTwiceReturnsValueRegs {
                    inst1: v1.clone(),
                    inst2: v4.clone(),
                    result: v6,
                };
                // Rule at src/prelude_lower.isle line 542.
                return v7;
            }
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "consumes_flags_concat", "src/prelude_lower.isle line 541")
}

// Generated as internal constructor for term consumes_flags_get_reg.
pub fn constructor_consumes_flags_get_reg<C: Context>(
    ctx: &mut C,
    arg0: &ConsumesFlags,
) -> Reg {
    if let &ConsumesFlags::ConsumesFlagsReturnsReg {
        inst: ref v1,
        result: v2,
    } = arg0 {
        // Rule at src/prelude_lower.isle line 555.
        return v2;
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "consumes_flags_get_reg", "src/prelude_lower.isle line 554")
}

// Generated as internal constructor for term consumes_flags_get_regs.
pub fn constructor_consumes_flags_get_regs<C: Context>(
    ctx: &mut C,
    arg0: &ConsumesFlags,
) -> ValueRegs {
    if let &ConsumesFlags::ConsumesFlagsTwiceReturnsValueRegs {
        inst1: ref v1,
        inst2: ref v2,
        result: v3,
    } = arg0 {
        // Rule at src/prelude_lower.isle line 557.
        return v3;
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "consumes_flags_get_regs", "src/prelude_lower.isle line 556")
}

// Generated as internal constructor for term with_flags.
pub fn constructor_with_flags<C: Context>(
    ctx: &mut C,
    arg0: &ProducesFlags,
    arg1: &ConsumesFlags,
) -> ValueRegs {
    match arg0 {
        &ProducesFlags::ProducesFlagsSideEffect {
            inst: ref v12,
        } => {
            match arg1 {
                &ConsumesFlags::ConsumesFlagsReturnsReg {
                    inst: ref v13,
                    result: v14,
                } => {
                    let v15 = C::emit(ctx, v12);
                    let v16 = C::emit(ctx, v13);
                    let v17 = C::value_reg(ctx, v14);
                    // Rule at src/prelude_lower.isle line 585.
                    return v17;
                }
                &ConsumesFlags::ConsumesFlagsTwiceReturnsValueRegs {
                    inst1: ref v18,
                    inst2: ref v19,
                    result: v20,
                } => {
                    let v15 = C::emit(ctx, v12);
                    let v21 = C::emit(ctx, v18);
                    let v22 = C::emit(ctx, v19);
                    // Rule at src/prelude_lower.isle line 591.
                    return v20;
                }
                &ConsumesFlags::ConsumesFlagsFourTimesReturnsValueRegs {
                    inst1: ref v23,
                    inst2: ref v24,
                    inst3: ref v25,
                    inst4: ref v26,
                    result: v27,
                } => {
                    let v15 = C::emit(ctx, v12);
                    let v28 = C::emit(ctx, v23);
                    let v29 = C::emit(ctx, v24);
                    let v30 = C::emit(ctx, v25);
                    let v31 = C::emit(ctx, v26);
                    // Rule at src/prelude_lower.isle line 603.
                    return v27;
                }
                _ => {}
            }
        }
        &ProducesFlags::ProducesFlagsTwiceSideEffect {
            inst1: ref v32,
            inst2: ref v33,
        } => {
            match arg1 {
                &ConsumesFlags::ConsumesFlagsReturnsReg {
                    inst: ref v13,
                    result: v14,
                } => {
                    let v34 = C::emit(ctx, v32);
                    let v35 = C::emit(ctx, v33);
                    let v36 = C::emit(ctx, v13);
                    let v37 = C::value_reg(ctx, v14);
                    // Rule at src/prelude_lower.isle line 619.
                    return v37;
                }
                &ConsumesFlags::ConsumesFlagsTwiceReturnsValueRegs {
                    inst1: ref v18,
                    inst2: ref v19,
                    result: v20,
                } => {
                    let v34 = C::emit(ctx, v32);
                    let v35 = C::emit(ctx, v33);
                    let v38 = C::emit(ctx, v18);
                    let v39 = C::emit(ctx, v19);
                    // Rule at src/prelude_lower.isle line 626.
                    return v20;
                }
                &ConsumesFlags::ConsumesFlagsFourTimesReturnsValueRegs {
                    inst1: ref v23,
                    inst2: ref v24,
                    inst3: ref v25,
                    inst4: ref v26,
                    result: v27,
                } => {
                    let v34 = C::emit(ctx, v32);
                    let v35 = C::emit(ctx, v33);
                    let v40 = C::emit(ctx, v23);
                    let v41 = C::emit(ctx, v24);
                    let v42 = C::emit(ctx, v25);
                    let v43 = C::emit(ctx, v26);
                    // Rule at src/prelude_lower.isle line 639.
                    return v27;
                }
                _ => {}
            }
        }
        &ProducesFlags::ProducesFlagsReturnsResultWithConsumer {
            inst: ref v1,
            result: v2,
        } => {
            match arg1 {
                &ConsumesFlags::ConsumesFlagsSideEffect {
                    inst: ref v9,
                } => {
                    let v6 = C::emit(ctx, v1);
                    let v10 = C::emit(ctx, v9);
                    let v11 = C::value_reg(ctx, v2);
                    // Rule at src/prelude_lower.isle line 579.
                    return v11;
                }
                &ConsumesFlags::ConsumesFlagsReturnsResultWithProducer {
                    inst: ref v4,
                    result: v5,
                } => {
                    let v6 = C::emit(ctx, v1);
                    let v7 = C::emit(ctx, v4);
                    let v8 = C::value_regs(ctx, v2, v5);
                    // Rule at src/prelude_lower.isle line 571.
                    return v8;
                }
                _ => {}
            }
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "with_flags", "src/prelude_lower.isle line 569")
}

// Generated as internal constructor for term with_flags_reg.
pub fn constructor_with_flags_reg<C: Context>(
    ctx: &mut C,
    arg0: &ProducesFlags,
    arg1: &ConsumesFlags,
) -> Reg {
    let v2 = constructor_with_flags(ctx, arg0, arg1);
    let v4 = C::value_regs_get(ctx, v2, 0x0_usize);
    // Rule at src/prelude_lower.isle line 657.
    return v4;
}

// Generated as internal constructor for term flags_to_producesflags.
pub fn constructor_flags_to_producesflags<C: Context>(
    ctx: &mut C,
    arg0: Value,
) -> ProducesFlags {
    let v1 = C::mark_value_used(ctx, arg0);
    // Rule at src/prelude_lower.isle line 664.
    return ProducesFlags::AlreadyExistingFlags;
}

// Generated as internal constructor for term with_flags_side_effect.
pub fn constructor_with_flags_side_effect<C: Context>(
    ctx: &mut C,
    arg0: &ProducesFlags,
    arg1: &ConsumesFlags,
) -> SideEffectNoResult {
    match arg0 {
        &ProducesFlags::AlreadyExistingFlags => {
            match arg1 {
                &ConsumesFlags::ConsumesFlagsSideEffect {
                    inst: ref v2,
                } => {
                    let v3 = SideEffectNoResult::Inst {
                        inst: v2.clone(),
                    };
                    // Rule at src/prelude_lower.isle line 675.
                    return v3;
                }
                &ConsumesFlags::ConsumesFlagsSideEffect2 {
                    inst1: ref v4,
                    inst2: ref v5,
                } => {
                    let v6 = SideEffectNoResult::Inst2 {
                        inst1: v4.clone(),
                        inst2: v5.clone(),
                    };
                    // Rule at src/prelude_lower.isle line 680.
                    return v6;
                }
                _ => {}
            }
        }
        &ProducesFlags::ProducesFlagsSideEffect {
            inst: ref v7,
        } => {
            match arg1 {
                &ConsumesFlags::ConsumesFlagsSideEffect {
                    inst: ref v2,
                } => {
                    let v8 = SideEffectNoResult::Inst2 {
                        inst1: v7.clone(),
                        inst2: v2.clone(),
                    };
                    // Rule at src/prelude_lower.isle line 685.
                    return v8;
                }
                &ConsumesFlags::ConsumesFlagsSideEffect2 {
                    inst1: ref v4,
                    inst2: ref v5,
                } => {
                    let v9 = SideEffectNoResult::Inst3 {
                        inst1: v7.clone(),
                        inst2: v4.clone(),
                        inst3: v5.clone(),
                    };
                    // Rule at src/prelude_lower.isle line 690.
                    return v9;
                }
                _ => {}
            }
        }
        &ProducesFlags::ProducesFlagsTwiceSideEffect {
            inst1: ref v10,
            inst2: ref v11,
        } => {
            if let &ConsumesFlags::ConsumesFlagsSideEffect {
                inst: ref v2,
            } = arg1 {
                let v12 = SideEffectNoResult::Inst3 {
                    inst1: v10.clone(),
                    inst2: v11.clone(),
                    inst3: v2.clone(),
                };
                // Rule at src/prelude_lower.isle line 695.
                return v12;
            }
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "with_flags_side_effect", "src/prelude_lower.isle line 673")
}

// Generated as internal constructor for term with_flags_chained.
pub fn constructor_with_flags_chained<C: Context>(
    ctx: &mut C,
    arg0: &ProducesFlags,
    arg1: &ConsumesAndProducesFlags,
    arg2: &ConsumesFlags,
) -> MultiReg {
    match arg0 {
        &ProducesFlags::ProducesFlagsSideEffect {
            inst: ref v1,
        } => {
            match arg1 {
                &ConsumesAndProducesFlags::SideEffect {
                    inst: ref v3,
                } => {
                    match arg2 {
                        &ConsumesFlags::ConsumesFlagsSideEffect {
                            inst: ref v5,
                        } => {
                            let v6 = C::emit(ctx, v1);
                            let v7 = C::emit(ctx, v3);
                            let v8 = C::emit(ctx, v5);
                            // Rule at src/prelude_lower.isle line 704.
                            return MultiReg::Empty;
                        }
                        &ConsumesFlags::ConsumesFlagsSideEffect2 {
                            inst1: ref v10,
                            inst2: ref v11,
                        } => {
                            let v6 = C::emit(ctx, v1);
                            let v7 = C::emit(ctx, v3);
                            let v12 = C::emit(ctx, v10);
                            let v13 = C::emit(ctx, v11);
                            // Rule at src/prelude_lower.isle line 712.
                            return MultiReg::Empty;
                        }
                        &ConsumesFlags::ConsumesFlagsReturnsReg {
                            inst: ref v14,
                            result: v15,
                        } => {
                            let v6 = C::emit(ctx, v1);
                            let v7 = C::emit(ctx, v3);
                            let v16 = C::emit(ctx, v14);
                            let v17 = MultiReg::One {
                                a: v15,
                            };
                            // Rule at src/prelude_lower.isle line 721.
                            return v17;
                        }
                        &ConsumesFlags::ConsumesFlagsTwiceReturnsValueRegs {
                            inst1: ref v18,
                            inst2: ref v19,
                            result: v20,
                        } => {
                            let v6 = C::emit(ctx, v1);
                            let v7 = C::emit(ctx, v3);
                            let v21 = C::emit(ctx, v18);
                            let v22 = C::emit(ctx, v19);
                            let v24 = C::value_regs_get(ctx, v20, 0x0_usize);
                            let v26 = C::value_regs_get(ctx, v20, 0x1_usize);
                            let v27 = MultiReg::Two {
                                a: v24,
                                b: v26,
                            };
                            // Rule at src/prelude_lower.isle line 729.
                            return v27;
                        }
                        &ConsumesFlags::ConsumesFlagsFourTimesReturnsValueRegs {
                            inst1: ref v28,
                            inst2: ref v29,
                            inst3: ref v30,
                            inst4: ref v31,
                            result: v32,
                        } => {
                            let v6 = C::emit(ctx, v1);
                            let v7 = C::emit(ctx, v3);
                            let v33 = C::emit(ctx, v28);
                            let v34 = C::emit(ctx, v29);
                            let v35 = C::emit(ctx, v30);
                            let v36 = C::emit(ctx, v31);
                            let v37 = C::value_regs_get(ctx, v32, 0x0_usize);
                            let v38 = C::value_regs_get(ctx, v32, 0x1_usize);
                            let v39 = MultiReg::Two {
                                a: v37,
                                b: v38,
                            };
                            // Rule at src/prelude_lower.isle line 738.
                            return v39;
                        }
                        _ => {}
                    }
                }
                &ConsumesAndProducesFlags::ReturnsReg {
                    inst: ref v47,
                    result: v48,
                } => {
                    match arg2 {
                        &ConsumesFlags::ConsumesFlagsSideEffect {
                            inst: ref v5,
                        } => {
                            let v6 = C::emit(ctx, v1);
                            let v49 = C::emit(ctx, v47);
                            let v8 = C::emit(ctx, v5);
                            let v50 = MultiReg::One {
                                a: v48,
                            };
                            // Rule at src/prelude_lower.isle line 798.
                            return v50;
                        }
                        &ConsumesFlags::ConsumesFlagsSideEffect2 {
                            inst1: ref v10,
                            inst2: ref v11,
                        } => {
                            let v6 = C::emit(ctx, v1);
                            let v49 = C::emit(ctx, v47);
                            let v12 = C::emit(ctx, v10);
                            let v13 = C::emit(ctx, v11);
                            let v50 = MultiReg::One {
                                a: v48,
                            };
                            // Rule at src/prelude_lower.isle line 806.
                            return v50;
                        }
                        &ConsumesFlags::ConsumesFlagsReturnsReg {
                            inst: ref v14,
                            result: v15,
                        } => {
                            let v6 = C::emit(ctx, v1);
                            let v49 = C::emit(ctx, v47);
                            let v16 = C::emit(ctx, v14);
                            let v51 = MultiReg::Two {
                                a: v48,
                                b: v15,
                            };
                            // Rule at src/prelude_lower.isle line 815.
                            return v51;
                        }
                        &ConsumesFlags::ConsumesFlagsTwiceReturnsValueRegs {
                            inst1: ref v18,
                            inst2: ref v19,
                            result: v20,
                        } => {
                            let v6 = C::emit(ctx, v1);
                            let v49 = C::emit(ctx, v47);
                            let v21 = C::emit(ctx, v18);
                            let v22 = C::emit(ctx, v19);
                            let v24 = C::value_regs_get(ctx, v20, 0x0_usize);
                            let v26 = C::value_regs_get(ctx, v20, 0x1_usize);
                            let v52 = MultiReg::Three {
                                a: v48,
                                b: v24,
                                c: v26,
                            };
                            // Rule at src/prelude_lower.isle line 823.
                            return v52;
                        }
                        &ConsumesFlags::ConsumesFlagsFourTimesReturnsValueRegs {
                            inst1: ref v28,
                            inst2: ref v29,
                            inst3: ref v30,
                            inst4: ref v31,
                            result: v32,
                        } => {
                            let v6 = C::emit(ctx, v1);
                            let v49 = C::emit(ctx, v47);
                            let v33 = C::emit(ctx, v28);
                            let v34 = C::emit(ctx, v29);
                            let v35 = C::emit(ctx, v30);
                            let v36 = C::emit(ctx, v31);
                            let v37 = C::value_regs_get(ctx, v32, 0x0_usize);
                            let v38 = C::value_regs_get(ctx, v32, 0x1_usize);
                            let v53 = MultiReg::Three {
                                a: v48,
                                b: v37,
                                c: v38,
                            };
                            // Rule at src/prelude_lower.isle line 832.
                            return v53;
                        }
                        _ => {}
                    }
                }
                _ => {}
            }
        }
        &ProducesFlags::ProducesFlagsReturnsReg {
            inst: ref v40,
            result: v41,
        } => {
            match arg1 {
                &ConsumesAndProducesFlags::SideEffect {
                    inst: ref v3,
                } => {
                    match arg2 {
                        &ConsumesFlags::ConsumesFlagsSideEffect {
                            inst: ref v5,
                        } => {
                            let v42 = C::emit(ctx, v40);
                            let v7 = C::emit(ctx, v3);
                            let v8 = C::emit(ctx, v5);
                            let v43 = MultiReg::One {
                                a: v41,
                            };
                            // Rule at src/prelude_lower.isle line 751.
                            return v43;
                        }
                        &ConsumesFlags::ConsumesFlagsSideEffect2 {
                            inst1: ref v10,
                            inst2: ref v11,
                        } => {
                            let v42 = C::emit(ctx, v40);
                            let v7 = C::emit(ctx, v3);
                            let v12 = C::emit(ctx, v10);
                            let v13 = C::emit(ctx, v11);
                            let v43 = MultiReg::One {
                                a: v41,
                            };
                            // Rule at src/prelude_lower.isle line 759.
                            return v43;
                        }
                        &ConsumesFlags::ConsumesFlagsReturnsReg {
                            inst: ref v14,
                            result: v15,
                        } => {
                            let v42 = C::emit(ctx, v40);
                            let v7 = C::emit(ctx, v3);
                            let v16 = C::emit(ctx, v14);
                            let v44 = MultiReg::Two {
                                a: v41,
                                b: v15,
                            };
                            // Rule at src/prelude_lower.isle line 768.
                            return v44;
                        }
                        &ConsumesFlags::ConsumesFlagsTwiceReturnsValueRegs {
                            inst1: ref v18,
                            inst2: ref v19,
                            result: v20,
                        } => {
                            let v42 = C::emit(ctx, v40);
                            let v7 = C::emit(ctx, v3);
                            let v21 = C::emit(ctx, v18);
                            let v22 = C::emit(ctx, v19);
                            let v24 = C::value_regs_get(ctx, v20, 0x0_usize);
                            let v26 = C::value_regs_get(ctx, v20, 0x1_usize);
                            let v45 = MultiReg::Three {
                                a: v41,
                                b: v24,
                                c: v26,
                            };
                            // Rule at src/prelude_lower.isle line 776.
                            return v45;
                        }
                        &ConsumesFlags::ConsumesFlagsFourTimesReturnsValueRegs {
                            inst1: ref v28,
                            inst2: ref v29,
                            inst3: ref v30,
                            inst4: ref v31,
                            result: v32,
                        } => {
                            let v42 = C::emit(ctx, v40);
                            let v7 = C::emit(ctx, v3);
                            let v33 = C::emit(ctx, v28);
                            let v34 = C::emit(ctx, v29);
                            let v35 = C::emit(ctx, v30);
                            let v36 = C::emit(ctx, v31);
                            let v37 = C::value_regs_get(ctx, v32, 0x0_usize);
                            let v38 = C::value_regs_get(ctx, v32, 0x1_usize);
                            let v46 = MultiReg::Three {
                                a: v41,
                                b: v37,
                                c: v38,
                            };
                            // Rule at src/prelude_lower.isle line 785.
                            return v46;
                        }
                        _ => {}
                    }
                }
                &ConsumesAndProducesFlags::ReturnsReg {
                    inst: ref v47,
                    result: v48,
                } => {
                    match arg2 {
                        &ConsumesFlags::ConsumesFlagsSideEffect {
                            inst: ref v5,
                        } => {
                            let v42 = C::emit(ctx, v40);
                            let v49 = C::emit(ctx, v47);
                            let v8 = C::emit(ctx, v5);
                            let v54 = MultiReg::Two {
                                a: v41,
                                b: v48,
                            };
                            // Rule at src/prelude_lower.isle line 845.
                            return v54;
                        }
                        &ConsumesFlags::ConsumesFlagsSideEffect2 {
                            inst1: ref v10,
                            inst2: ref v11,
                        } => {
                            let v42 = C::emit(ctx, v40);
                            let v49 = C::emit(ctx, v47);
                            let v12 = C::emit(ctx, v10);
                            let v13 = C::emit(ctx, v11);
                            let v54 = MultiReg::Two {
                                a: v41,
                                b: v48,
                            };
                            // Rule at src/prelude_lower.isle line 853.
                            return v54;
                        }
                        &ConsumesFlags::ConsumesFlagsReturnsReg {
                            inst: ref v14,
                            result: v15,
                        } => {
                            let v42 = C::emit(ctx, v40);
                            let v49 = C::emit(ctx, v47);
                            let v16 = C::emit(ctx, v14);
                            let v55 = MultiReg::Three {
                                a: v41,
                                b: v48,
                                c: v15,
                            };
                            // Rule at src/prelude_lower.isle line 862.
                            return v55;
                        }
                        &ConsumesFlags::ConsumesFlagsTwiceReturnsValueRegs {
                            inst1: ref v18,
                            inst2: ref v19,
                            result: v20,
                        } => {
                            let v42 = C::emit(ctx, v40);
                            let v49 = C::emit(ctx, v47);
                            let v21 = C::emit(ctx, v18);
                            let v22 = C::emit(ctx, v19);
                            let v24 = C::value_regs_get(ctx, v20, 0x0_usize);
                            let v26 = C::value_regs_get(ctx, v20, 0x1_usize);
                            let v56 = MultiReg::Four {
                                a: v41,
                                b: v48,
                                c: v24,
                                d: v26,
                            };
                            // Rule at src/prelude_lower.isle line 870.
                            return v56;
                        }
                        &ConsumesFlags::ConsumesFlagsFourTimesReturnsValueRegs {
                            inst1: ref v28,
                            inst2: ref v29,
                            inst3: ref v30,
                            inst4: ref v31,
                            result: v32,
                        } => {
                            let v42 = C::emit(ctx, v40);
                            let v49 = C::emit(ctx, v47);
                            let v33 = C::emit(ctx, v28);
                            let v34 = C::emit(ctx, v29);
                            let v35 = C::emit(ctx, v30);
                            let v36 = C::emit(ctx, v31);
                            let v37 = C::value_regs_get(ctx, v32, 0x0_usize);
                            let v38 = C::value_regs_get(ctx, v32, 0x1_usize);
                            let v57 = MultiReg::Four {
                                a: v41,
                                b: v48,
                                c: v37,
                                d: v38,
                            };
                            // Rule at src/prelude_lower.isle line 879.
                            return v57;
                        }
                        _ => {}
                    }
                }
                _ => {}
            }
        }
        &ProducesFlags::ProducesFlagsReturnsResultWithConsumer {
            inst: ref v58,
            result: v59,
        } => {
            if let &ConsumesAndProducesFlags::ReturnsReg {
                inst: ref v47,
                result: v48,
            } = arg1 {
                match arg2 {
                    &ConsumesFlags::ConsumesFlagsSideEffect {
                        inst: ref v5,
                    } => {
                        let v60 = C::emit(ctx, v58);
                        let v49 = C::emit(ctx, v47);
                        let v8 = C::emit(ctx, v5);
                        let v61 = MultiReg::Two {
                            a: v59,
                            b: v48,
                        };
                        // Rule at src/prelude_lower.isle line 891.
                        return v61;
                    }
                    &ConsumesFlags::ConsumesFlagsSideEffect2 {
                        inst1: ref v10,
                        inst2: ref v11,
                    } => {
                        let v60 = C::emit(ctx, v58);
                        let v49 = C::emit(ctx, v47);
                        let v12 = C::emit(ctx, v10);
                        let v13 = C::emit(ctx, v11);
                        let v61 = MultiReg::Two {
                            a: v59,
                            b: v48,
                        };
                        // Rule at src/prelude_lower.isle line 899.
                        return v61;
                    }
                    &ConsumesFlags::ConsumesFlagsReturnsResultWithProducer {
                        inst: ref v63,
                        result: v64,
                    } => {
                        let v60 = C::emit(ctx, v58);
                        let v49 = C::emit(ctx, v47);
                        let v65 = C::emit(ctx, v63);
                        let v66 = MultiReg::Three {
                            a: v59,
                            b: v48,
                            c: v64,
                        };
                        // Rule at src/prelude_lower.isle line 916.
                        return v66;
                    }
                    &ConsumesFlags::ConsumesFlagsReturnsReg {
                        inst: ref v14,
                        result: v15,
                    } => {
                        let v60 = C::emit(ctx, v58);
                        let v49 = C::emit(ctx, v47);
                        let v16 = C::emit(ctx, v14);
                        let v62 = MultiReg::Three {
                            a: v59,
                            b: v48,
                            c: v15,
                        };
                        // Rule at src/prelude_lower.isle line 908.
                        return v62;
                    }
                    &ConsumesFlags::ConsumesFlagsTwiceReturnsValueRegs {
                        inst1: ref v18,
                        inst2: ref v19,
                        result: v20,
                    } => {
                        let v60 = C::emit(ctx, v58);
                        let v49 = C::emit(ctx, v47);
                        let v21 = C::emit(ctx, v18);
                        let v22 = C::emit(ctx, v19);
                        let v24 = C::value_regs_get(ctx, v20, 0x0_usize);
                        let v26 = C::value_regs_get(ctx, v20, 0x1_usize);
                        let v67 = MultiReg::Four {
                            a: v59,
                            b: v48,
                            c: v24,
                            d: v26,
                        };
                        // Rule at src/prelude_lower.isle line 924.
                        return v67;
                    }
                    &ConsumesFlags::ConsumesFlagsFourTimesReturnsValueRegs {
                        inst1: ref v28,
                        inst2: ref v29,
                        inst3: ref v30,
                        inst4: ref v31,
                        result: v32,
                    } => {
                        let v60 = C::emit(ctx, v58);
                        let v49 = C::emit(ctx, v47);
                        let v33 = C::emit(ctx, v28);
                        let v34 = C::emit(ctx, v29);
                        let v35 = C::emit(ctx, v30);
                        let v36 = C::emit(ctx, v31);
                        let v37 = C::value_regs_get(ctx, v32, 0x0_usize);
                        let v38 = C::value_regs_get(ctx, v32, 0x1_usize);
                        let v68 = MultiReg::Four {
                            a: v59,
                            b: v48,
                            c: v37,
                            d: v38,
                        };
                        // Rule at src/prelude_lower.isle line 933.
                        return v68;
                    }
                    _ => {}
                }
            }
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "with_flags_chained", "src/prelude_lower.isle line 701")
}

// Generated as internal constructor for term lower_return.
pub fn constructor_lower_return<C: Context>(
    ctx: &mut C,
    arg0: ValueSlice,
) -> InstOutput {
    let v1 = &C::put_in_regs_vec(ctx, arg0);
    let v2 = C::gen_return(ctx, v1);
    let v3 = C::output_none(ctx);
    // Rule at src/prelude_lower.isle line 1143.
    return v3;
}

// Generated as internal constructor for term ty_to_operand_size.
pub fn constructor_ty_to_operand_size<C: Context>(
    ctx: &mut C,
    arg0: Type,
) -> OperandSize {
    match arg0 {
        I32 => {
            // Rule at src/isa/pulley_shared/inst.isle line 5.
            return OperandSize::Size32;
        }
        I64 => {
            // Rule at src/isa/pulley_shared/inst.isle line 6.
            return OperandSize::Size64;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "ty_to_operand_size", "src/isa/pulley_shared/inst.isle line 4")
}

// Generated as internal constructor for term raw_inst_to_inst.
pub fn constructor_raw_inst_to_inst<C: Context>(
    ctx: &mut C,
    arg0: &RawInst,
) -> MInst {
    let v1 = MInst::Raw {
        raw: arg0.clone(),
    };
    // Rule at src/isa/pulley_shared/inst.isle line 158.
    return v1;
}

// Generated as internal constructor for term amode_base.
pub fn constructor_amode_base<C: Context>(
    ctx: &mut C,
    arg0: Value,
    arg1: Offset32,
) -> ValueOffset {
    let v4 = C::def_inst(ctx, arg0);
    if let Some(v5) = v4 {
        let v6 = C::inst_data_value(ctx, v5);
        if let &InstructionData::Binary {
            opcode: ref v9,
            args: ref v10,
        } = &v6.1 {
            if let &Opcode::Iadd = v9 {
                let v11 = C::unpack_value_array_2(ctx, v10);
                let v14 = C::i64_from_iconst(ctx, v11.1);
                if let Some(v15) = v14 {
                    let v16 = C::i64_from_i32(ctx, v15);
                    if let Some(v17) = v16 {
                        let v2 = C::offset32(ctx, arg1);
                        let v18 = C::i32_checked_add(ctx, v17, v2);
                        if let Some(v19) = v18 {
                            let v20 = ValueOffset::Both {
                                value: v11.0,
                                offset: v19,
                            };
                            // Rule at src/isa/pulley_shared/inst.isle line 184.
                            return v20;
                        }
                    }
                }
            }
        }
    }
    let v2 = C::offset32(ctx, arg1);
    let v3 = ValueOffset::Both {
        value: arg0,
        offset: v2,
    };
    // Rule at src/isa/pulley_shared/inst.isle line 183.
    return v3;
}

// Generated as internal constructor for term amode.
pub fn constructor_amode<C: Context>(
    ctx: &mut C,
    arg0: Value,
    arg1: Offset32,
) -> Amode {
    let v2 = &constructor_amode_base(ctx, arg0, arg1);
    if let &ValueOffset::Both {
        value: v3,
        offset: v4,
    } = v2 {
        let v5 = constructor_put_in_xreg(ctx, v3);
        let v6 = Amode::RegOffset {
            base: v5,
            offset: v4,
        };
        // Rule at src/isa/pulley_shared/inst.isle line 199.
        return v6;
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "amode", "src/isa/pulley_shared/inst.isle line 198")
}

// Generated as internal constructor for term addro32.
pub fn constructor_addro32<C: Context>(
    ctx: &mut C,
    arg0: Value,
    arg1: Offset32,
) -> AddrO32 {
    let v2 = &constructor_amode_base(ctx, arg0, arg1);
    if let &ValueOffset::Both {
        value: v3,
        offset: v4,
    } = v2 {
        let v5 = constructor_put_in_xreg(ctx, v3);
        let v6 = AddrO32::Base {
            addr: v5,
            offset: v4,
        };
        // Rule at src/isa/pulley_shared/inst.isle line 212.
        return v6;
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "addro32", "src/isa/pulley_shared/inst.isle line 211")
}

// Generated as internal constructor for term addrz.
pub fn constructor_addrz<C: Context>(
    ctx: &mut C,
    arg0: Value,
    arg1: Offset32,
) -> AddrZ {
    let v2 = &constructor_amode_base(ctx, arg0, arg1);
    if let &ValueOffset::Both {
        value: v3,
        offset: v4,
    } = v2 {
        let v5 = constructor_put_in_xreg(ctx, v3);
        let v6 = AddrZ::Base {
            addr: v5,
            offset: v4,
        };
        // Rule at src/isa/pulley_shared/inst.isle line 225.
        return v6;
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "addrz", "src/isa/pulley_shared/inst.isle line 224")
}

// Generated as internal constructor for term sinkable_load.
pub fn constructor_sinkable_load<C: Context>(
    ctx: &mut C,
    arg0: Value,
) -> Option<SinkableLoad> {
    let v2 = C::is_sinkable_inst(ctx, arg0);
    if let Some(v3) = v2 {
        let v4 = C::inst_data_value(ctx, v3);
        if let &InstructionData::Load {
            opcode: ref v7,
            arg: v8,
            flags: v9,
            offset: v10,
        } = &v4.1 {
            if let &Opcode::Load = v7 {
                let v11 = C::mem_flags_data(ctx, v9);
                if let Some(v12) = v11 {
                    let v14 = &C::endianness(ctx, v12);
                    let v15 = C::is_native_endianness(ctx, v14);
                    if v15 == true {
                        let v16 = C::memflags_nontrapping(ctx, v12);
                        if v16 == true {
                            let v13 = C::offset32(ctx, v10);
                            let v17 = C::i32_try_into_u8(ctx, v13);
                            if let Some(v18) = v17 {
                                let v1 = C::value_type(ctx, arg0);
                                let v19 = SinkableLoad::Load {
                                    inst: v3,
                                    ty: v1,
                                    addr: v8,
                                    offset: v18,
                                };
                                let v20 = Some(v19);
                                // Rule at src/isa/pulley_shared/inst.isle line 271.
                                return v20;
                            }
                        }
                    }
                }
            }
        }
    }
    None
}

// Generated as internal constructor for term sink_load.
pub fn constructor_sink_load<C: Context>(
    ctx: &mut C,
    arg0: &SinkableLoad,
) -> SunkLoad {
    if let &SinkableLoad::Load {
        inst: v1,
        ty: v2,
        addr: v3,
        offset: v4,
    } = arg0 {
        let v5 = C::sink_inst(ctx, v1);
        let v6 = SunkLoad::Load {
            ty: v2,
            addr: v3,
            offset: v4,
        };
        // Rule at src/isa/pulley_shared/inst.isle line 287.
        return v6;
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "sink_load", "src/isa/pulley_shared/inst.isle line 286")
}

// Generated as internal constructor for term gen_addrg32.
pub fn constructor_gen_addrg32<C: Context>(
    ctx: &mut C,
    arg0: &G32,
) -> AddrG32 {
    if let &G32::All {
        heap_base: v1,
        heap_bound: v2,
        wasm_addr: v3,
        offset: v4,
    } = arg0 {
        let v5 = constructor_put_in_xreg(ctx, v1);
        let v6 = constructor_put_in_xreg(ctx, v2);
        let v7 = constructor_put_in_xreg(ctx, v3);
        let v8 = AddrG32::RegisterBound {
            host_heap_base: v5,
            host_heap_bound: v6,
            wasm_addr: v7,
            offset: v4,
        };
        // Rule at src/isa/pulley_shared/inst.isle line 312.
        return v8;
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "gen_addrg32", "src/isa/pulley_shared/inst.isle line 311")
}

// Generated as internal constructor for term gen_addrg32bne.
pub fn constructor_gen_addrg32bne<C: Context>(
    ctx: &mut C,
    arg0: &G32Bne,
) -> AddrG32Bne {
    if let &G32Bne::All {
        heap_base: v1,
        heap_bound: ref v2,
        wasm_addr: v3,
        offset: v4,
    } = arg0 {
        let v5 = constructor_put_in_xreg(ctx, v1);
        let v6 = &constructor_sink_load(ctx, v2);
        let v7 = constructor_put_in_xreg(ctx, v3);
        let v8 = &constructor_gen_addrg32bne_for_real(ctx, v5, v6, v7, v4);
        // Rule at src/isa/pulley_shared/inst.isle line 321.
        return v8.clone();
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "gen_addrg32bne", "src/isa/pulley_shared/inst.isle line 320")
}

// Generated as internal constructor for term gen_addrg32bne_for_real.
pub fn constructor_gen_addrg32bne_for_real<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: &SunkLoad,
    arg2: XReg,
    arg3: u8,
) -> AddrG32Bne {
    if let &SunkLoad::Load {
        ty: v2,
        addr: v3,
        offset: v4,
    } = arg1 {
        let v7 = constructor_put_in_xreg(ctx, v3);
        let v8 = AddrG32Bne::BoundNe {
            host_heap_base: arg0,
            host_heap_bound_addr: v7,
            host_heap_bound_offset: v4,
            wasm_addr: arg2,
            offset: arg3,
        };
        // Rule at src/isa/pulley_shared/inst.isle line 327.
        return v8;
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "gen_addrg32bne_for_real", "src/isa/pulley_shared/inst.isle line 326")
}

// Generated as internal constructor for term addrg32bne.
pub fn constructor_addrg32bne<C: Context>(
    ctx: &mut C,
    arg0: &G32,
) -> Option<G32Bne> {
    if let &G32::All {
        heap_base: v1,
        heap_bound: v2,
        wasm_addr: v3,
        offset: v4,
    } = arg0 {
        let v5 = &constructor_sinkable_load(ctx, v2);
        if let Some(v6) = v5 {
            let v7 = C::u16_try_into_u8(ctx, v4);
            if let Some(v8) = v7 {
                let v9 = G32Bne::All {
                    heap_base: v1,
                    heap_bound: v6.clone(),
                    wasm_addr: v3,
                    offset: v8,
                };
                let v10 = Some(v9);
                // Rule at src/isa/pulley_shared/inst.isle line 335.
                return v10;
            }
        }
    }
    None
}

// Generated as internal constructor for term wasm_g32.
pub fn constructor_wasm_g32<C: Context>(
    ctx: &mut C,
    arg0: Value,
    arg1: Offset32,
    arg2: MemFlagsData,
    arg3: Type,
) -> Option<G32> {
    let v1 = C::def_inst(ctx, arg0);
    if let Some(v2) = v1 {
        let v3 = C::inst_data_value(ctx, v2);
        if let &InstructionData::Ternary {
            opcode: ref v6,
            args: ref v7,
        } = &v3.1 {
            if let &Opcode::Select = v6 {
                let v8 = C::unpack_value_array_3(ctx, v7);
                let v12 = C::def_inst(ctx, v8.1);
                if let Some(v13) = v12 {
                    let v14 = C::inst_data_value(ctx, v13);
                    if let &InstructionData::UnaryImm {
                        opcode: ref v17,
                        imm: v18,
                    } = &v14.1 {
                        if let &Opcode::Iconst = v17 {
                            let v19 = C::u64_from_imm64(ctx, v18);
                            if v19 == 0x0_u64 {
                                let v21 = C::offset32(ctx, arg1);
                                if v21 == 0_i32 {
                                    let v24 = C::memflags_is_wasm(ctx, arg2);
                                    if v24 == true {
                                        let v25 = &constructor_host_offset(ctx, v8.2);
                                        if let &HostOffset::All {
                                            a: v26,
                                            b: v27,
                                        } = v25 {
                                            let v28 = &constructor_wasm_oob_select(ctx, v8.0, v26);
                                            if let Some(v29) = v28 {
                                                if let &OobSelect::All {
                                                    a: v30,
                                                    b: v31,
                                                    c: v32,
                                                    d: v33,
                                                } = v29 {
                                                    let v34 = C::g32_offset(ctx, v27, arg3, v33);
                                                    if let Some(v35) = v34 {
                                                        let v36 = G32::All {
                                                            heap_base: v30,
                                                            heap_bound: v31,
                                                            wasm_addr: v32,
                                                            offset: v35,
                                                        };
                                                        let v37 = Some(v36);
                                                        // Rule at src/isa/pulley_shared/inst.isle line 351.
                                                        return v37;
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    None
}

// Generated as internal constructor for term host_offset.
pub fn constructor_host_offset<C: Context>(
    ctx: &mut C,
    arg0: Value,
) -> HostOffset {
    let v3 = C::def_inst(ctx, arg0);
    if let Some(v4) = v3 {
        let v5 = C::inst_data_value(ctx, v4);
        if let &InstructionData::Binary {
            opcode: ref v8,
            args: ref v9,
        } = &v5.1 {
            if let &Opcode::Iadd = v8 {
                let v10 = C::unpack_value_array_2(ctx, v9);
                let v28 = C::i64_from_iconst(ctx, v10.0);
                if let Some(v29) = v28 {
                    let v30 = C::i64_from_i32(ctx, v29);
                    if let Some(v31) = v30 {
                        let v32 = C::def_inst(ctx, v10.1);
                        if let Some(v33) = v32 {
                            let v34 = C::inst_data_value(ctx, v33);
                            if let &InstructionData::Binary {
                                opcode: ref v37,
                                args: ref v38,
                            } = &v34.1 {
                                if let &Opcode::Iadd = v37 {
                                    let v42 = HostOffset::All {
                                        a: v10.1,
                                        b: v31,
                                    };
                                    // Rule at src/isa/pulley_shared/inst.isle line 388.
                                    return v42;
                                }
                            }
                        }
                    }
                }
                let v13 = C::def_inst(ctx, v10.0);
                if let Some(v14) = v13 {
                    let v15 = C::inst_data_value(ctx, v14);
                    if let &InstructionData::Binary {
                        opcode: ref v18,
                        args: ref v19,
                    } = &v15.1 {
                        if let &Opcode::Iadd = v18 {
                            let v23 = C::i64_from_iconst(ctx, v10.1);
                            if let Some(v24) = v23 {
                                let v25 = C::i64_from_i32(ctx, v24);
                                if let Some(v26) = v25 {
                                    let v27 = HostOffset::All {
                                        a: v10.0,
                                        b: v26,
                                    };
                                    // Rule at src/isa/pulley_shared/inst.isle line 387.
                                    return v27;
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    let v2 = HostOffset::All {
        a: arg0,
        b: 0_i32,
    };
    // Rule at src/isa/pulley_shared/inst.isle line 386.
    return v2;
}

// Generated as internal constructor for term wasm_oob_select.
pub fn constructor_wasm_oob_select<C: Context>(
    ctx: &mut C,
    arg0: Value,
    arg1: Value,
) -> Option<OobSelect> {
    let v2 = C::def_inst(ctx, arg1);
    if let Some(v3) = v2 {
        let v4 = C::inst_data_value(ctx, v3);
        if let &InstructionData::Binary {
            opcode: ref v7,
            args: ref v8,
        } = &v4.1 {
            if let &Opcode::Iadd = v7 {
                let v17 = &C::pointer_width(ctx);
                match v17 {
                    &PointerWidth::PointerWidth32 => {
                        let v9 = C::unpack_value_array_2(ctx, v8);
                        let v20 = C::value_type(ctx, v9.0);
                        if v20 == I32 {
                            let v21 = &constructor_wasm_oob_cond(ctx, v9.0, arg0);
                            if let Some(v22) = v21 {
                                if let &OobCond::All {
                                    a: v23,
                                    b: v24,
                                } = v22 {
                                    let v25 = OobSelect::All {
                                        a: v9.1,
                                        b: v23,
                                        c: v9.0,
                                        d: v24,
                                    };
                                    let v26 = Some(v25);
                                    // Rule at src/isa/pulley_shared/inst.isle line 402.
                                    return v26;
                                }
                            }
                        }
                        let v12 = C::value_type(ctx, v9.1);
                        if v12 == I32 {
                            let v13 = &constructor_wasm_oob_cond(ctx, v9.1, arg0);
                            if let Some(v14) = v13 {
                                if let &OobCond::All {
                                    a: v15,
                                    b: v16,
                                } = v14 {
                                    let v18 = OobSelect::All {
                                        a: v9.0,
                                        b: v15,
                                        c: v9.1,
                                        d: v16,
                                    };
                                    let v19 = Some(v18);
                                    // Rule at src/isa/pulley_shared/inst.isle line 398.
                                    return v19;
                                }
                            }
                        }
                    }
                    &PointerWidth::PointerWidth64 => {
                        let v9 = C::unpack_value_array_2(ctx, v8);
                        let v20 = C::value_type(ctx, v9.0);
                        if v20 == I64 {
                            let v21 = &constructor_wasm_oob_cond(ctx, v9.0, arg0);
                            if let Some(v22) = v21 {
                                if let &OobCond::All {
                                    a: v23,
                                    b: v24,
                                } = v22 {
                                    let v31 = constructor_wasm32_addr_for_host64(ctx, v9.0);
                                    if let Some(v32) = v31 {
                                        let v33 = OobSelect::All {
                                            a: v9.1,
                                            b: v23,
                                            c: v32,
                                            d: v24,
                                        };
                                        let v34 = Some(v33);
                                        // Rule at src/isa/pulley_shared/inst.isle line 414.
                                        return v34;
                                    }
                                }
                            }
                        }
                        let v12 = C::value_type(ctx, v9.1);
                        if v12 == I64 {
                            let v13 = &constructor_wasm_oob_cond(ctx, v9.1, arg0);
                            if let Some(v14) = v13 {
                                if let &OobCond::All {
                                    a: v15,
                                    b: v16,
                                } = v14 {
                                    let v27 = constructor_wasm32_addr_for_host64(ctx, v9.1);
                                    if let Some(v28) = v27 {
                                        let v29 = OobSelect::All {
                                            a: v9.0,
                                            b: v15,
                                            c: v28,
                                            d: v16,
                                        };
                                        let v30 = Some(v29);
                                        // Rule at src/isa/pulley_shared/inst.isle line 409.
                                        return v30;
                                    }
                                }
                            }
                        }
                    }
                    _ => {}
                }
            }
        }
    }
    None
}

// Generated as internal constructor for term wasm32_addr_for_host64.
pub fn constructor_wasm32_addr_for_host64<C: Context>(
    ctx: &mut C,
    arg0: Value,
) -> Option<Value> {
    let v1 = C::def_inst(ctx, arg0);
    if let Some(v2) = v1 {
        let v3 = C::inst_data_value(ctx, v2);
        match &v3.1 {
            &InstructionData::Unary {
                opcode: ref v6,
                arg: v7,
            } => {
                if let &Opcode::Uextend = v6 {
                    let v8 = C::value_type(ctx, v7);
                    if v8 == I32 {
                        let v9 = Some(v7);
                        // Rule at src/isa/pulley_shared/inst.isle line 425.
                        return v9;
                    }
                }
            }
            &InstructionData::UnaryImm {
                opcode: ref v10,
                imm: v11,
            } => {
                if let &Opcode::Iconst = v10 {
                    let v12 = C::u64_from_imm64(ctx, v11);
                    let v13 = C::u64_from_u32(ctx, v12);
                    if let Some(v14) = v13 {
                        let v15 = Some(arg0);
                        // Rule at src/isa/pulley_shared/inst.isle line 426.
                        return v15;
                    }
                }
            }
            _ => {}
        }
    }
    None
}

// Generated as internal constructor for term wasm_oob_cond.
pub fn constructor_wasm_oob_cond<C: Context>(
    ctx: &mut C,
    arg0: Value,
    arg1: Value,
) -> Option<OobCond> {
    let v2 = C::def_inst(ctx, arg1);
    if let Some(v3) = v2 {
        let v4 = C::inst_data_value(ctx, v3);
        if let &InstructionData::IntCompare {
            opcode: ref v7,
            args: ref v8,
            cond: ref v9,
        } = &v4.1 {
            if let &Opcode::Icmp = v7 {
                match v9 {
                    &IntCC::UnsignedGreaterThan => {
                        let v10 = C::unpack_value_array_2(ctx, v8);
                        let v13 = C::def_inst(ctx, v10.1);
                        if let Some(v14) = v13 {
                            let v15 = C::inst_data_value(ctx, v14);
                            if let &InstructionData::Binary {
                                opcode: ref v18,
                                args: ref v19,
                            } = &v15.1 {
                                if let &Opcode::Isub = v18 {
                                    let v20 = C::unpack_value_array_2(ctx, v19);
                                    let v23 = C::def_inst(ctx, v20.1);
                                    if let Some(v24) = v23 {
                                        let v25 = C::inst_data_value(ctx, v24);
                                        if let &InstructionData::UnaryImm {
                                            opcode: ref v28,
                                            imm: v29,
                                        } = &v25.1 {
                                            if let &Opcode::Iconst = v28 {
                                                if arg0 == v10.0 {
                                                    let v30 = C::u64_from_imm64(ctx, v29);
                                                    let v31 = OobCond::All {
                                                        a: v20.0,
                                                        b: v30,
                                                    };
                                                    let v32 = Some(v31);
                                                    // Rule at src/isa/pulley_shared/inst.isle line 433.
                                                    return v32;
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                    &IntCC::UnsignedLessThan => {
                        let v10 = C::unpack_value_array_2(ctx, v8);
                        let v33 = C::def_inst(ctx, v10.0);
                        if let Some(v34) = v33 {
                            let v35 = C::inst_data_value(ctx, v34);
                            if let &InstructionData::Binary {
                                opcode: ref v38,
                                args: ref v39,
                            } = &v35.1 {
                                if let &Opcode::Isub = v38 {
                                    let v40 = C::unpack_value_array_2(ctx, v39);
                                    let v43 = C::def_inst(ctx, v40.1);
                                    if let Some(v44) = v43 {
                                        let v45 = C::inst_data_value(ctx, v44);
                                        if let &InstructionData::UnaryImm {
                                            opcode: ref v48,
                                            imm: v49,
                                        } = &v45.1 {
                                            if let &Opcode::Iconst = v48 {
                                                if arg0 == v10.1 {
                                                    let v50 = C::u64_from_imm64(ctx, v49);
                                                    let v51 = OobCond::All {
                                                        a: v40.0,
                                                        b: v50,
                                                    };
                                                    let v52 = Some(v51);
                                                    // Rule at src/isa/pulley_shared/inst.isle line 435.
                                                    return v52;
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                    _ => {}
                }
            }
        }
    }
    None
}

// Generated as internal constructor for term put_in_xreg.
pub fn constructor_put_in_xreg<C: Context>(
    ctx: &mut C,
    arg0: Value,
) -> XReg {
    let v1 = C::put_in_reg(ctx, arg0);
    let v2 = C::xreg_new(ctx, v1);
    // Rule at src/isa/pulley_shared/inst.isle line 467.
    return v2;
}

// Generated as internal constructor for term output_xreg.
pub fn constructor_output_xreg<C: Context>(
    ctx: &mut C,
    arg0: XReg,
) -> InstOutput {
    let v1 = C::xreg_to_reg(ctx, arg0);
    let v2 = constructor_output_reg(ctx, v1);
    // Rule at src/isa/pulley_shared/inst.isle line 472.
    return v2;
}

// Generated as internal constructor for term writable_xreg_to_reg.
pub fn constructor_writable_xreg_to_reg<C: Context>(
    ctx: &mut C,
    arg0: WritableXReg,
) -> Reg {
    let v1 = C::writable_xreg_to_writable_reg(ctx, arg0);
    let v2 = C::writable_reg_to_reg(ctx, v1);
    // Rule at src/isa/pulley_shared/inst.isle line 487.
    return v2;
}

// Generated as internal constructor for term xreg_to_value_regs.
pub fn constructor_xreg_to_value_regs<C: Context>(
    ctx: &mut C,
    arg0: XReg,
) -> ValueRegs {
    let v1 = C::xreg_to_reg(ctx, arg0);
    let v2 = C::value_reg(ctx, v1);
    // Rule at src/isa/pulley_shared/inst.isle line 497.
    return v2;
}

// Generated as internal constructor for term writable_xreg_to_value_regs.
pub fn constructor_writable_xreg_to_value_regs<C: Context>(
    ctx: &mut C,
    arg0: WritableXReg,
) -> ValueRegs {
    let v1 = constructor_writable_xreg_to_reg(ctx, arg0);
    let v2 = C::value_reg(ctx, v1);
    // Rule at src/isa/pulley_shared/inst.isle line 502.
    return v2;
}

// Generated as internal constructor for term temp_writable_xreg.
pub fn constructor_temp_writable_xreg<C: Context>(
    ctx: &mut C,
) -> WritableXReg {
    let v1 = C::temp_writable_reg(ctx, I64);
    let v2 = C::writable_xreg_new(ctx, v1);
    // Rule at src/isa/pulley_shared/inst.isle line 507.
    return v2;
}

// Generated as internal constructor for term put_in_freg.
pub fn constructor_put_in_freg<C: Context>(
    ctx: &mut C,
    arg0: Value,
) -> FReg {
    let v1 = C::put_in_reg(ctx, arg0);
    let v2 = C::freg_new(ctx, v1);
    // Rule at src/isa/pulley_shared/inst.isle line 527.
    return v2;
}

// Generated as internal constructor for term output_freg.
pub fn constructor_output_freg<C: Context>(
    ctx: &mut C,
    arg0: FReg,
) -> InstOutput {
    let v1 = C::freg_to_reg(ctx, arg0);
    let v2 = constructor_output_reg(ctx, v1);
    // Rule at src/isa/pulley_shared/inst.isle line 532.
    return v2;
}

// Generated as internal constructor for term writable_freg_to_reg.
pub fn constructor_writable_freg_to_reg<C: Context>(
    ctx: &mut C,
    arg0: WritableFReg,
) -> Reg {
    let v1 = C::writable_freg_to_writable_reg(ctx, arg0);
    let v2 = C::writable_reg_to_reg(ctx, v1);
    // Rule at src/isa/pulley_shared/inst.isle line 547.
    return v2;
}

// Generated as internal constructor for term freg_to_value_regs.
pub fn constructor_freg_to_value_regs<C: Context>(
    ctx: &mut C,
    arg0: FReg,
) -> ValueRegs {
    let v1 = C::freg_to_reg(ctx, arg0);
    let v2 = C::value_reg(ctx, v1);
    // Rule at src/isa/pulley_shared/inst.isle line 557.
    return v2;
}

// Generated as internal constructor for term writable_freg_to_value_regs.
pub fn constructor_writable_freg_to_value_regs<C: Context>(
    ctx: &mut C,
    arg0: WritableFReg,
) -> ValueRegs {
    let v1 = constructor_writable_freg_to_reg(ctx, arg0);
    let v2 = C::value_reg(ctx, v1);
    // Rule at src/isa/pulley_shared/inst.isle line 562.
    return v2;
}

// Generated as internal constructor for term temp_writable_freg.
pub fn constructor_temp_writable_freg<C: Context>(
    ctx: &mut C,
) -> WritableFReg {
    let v1 = C::temp_writable_reg(ctx, F64);
    let v2 = C::writable_freg_new(ctx, v1);
    // Rule at src/isa/pulley_shared/inst.isle line 567.
    return v2;
}

// Generated as internal constructor for term put_in_vreg.
pub fn constructor_put_in_vreg<C: Context>(
    ctx: &mut C,
    arg0: Value,
) -> VReg {
    let v1 = C::put_in_reg(ctx, arg0);
    let v2 = C::vreg_new(ctx, v1);
    // Rule at src/isa/pulley_shared/inst.isle line 587.
    return v2;
}

// Generated as internal constructor for term output_vreg.
pub fn constructor_output_vreg<C: Context>(
    ctx: &mut C,
    arg0: VReg,
) -> InstOutput {
    let v1 = C::vreg_to_reg(ctx, arg0);
    let v2 = constructor_output_reg(ctx, v1);
    // Rule at src/isa/pulley_shared/inst.isle line 592.
    return v2;
}

// Generated as internal constructor for term writable_vreg_to_reg.
pub fn constructor_writable_vreg_to_reg<C: Context>(
    ctx: &mut C,
    arg0: WritableVReg,
) -> Reg {
    let v1 = C::writable_vreg_to_writable_reg(ctx, arg0);
    let v2 = C::writable_reg_to_reg(ctx, v1);
    // Rule at src/isa/pulley_shared/inst.isle line 607.
    return v2;
}

// Generated as internal constructor for term vreg_to_value_regs.
pub fn constructor_vreg_to_value_regs<C: Context>(
    ctx: &mut C,
    arg0: VReg,
) -> ValueRegs {
    let v1 = C::vreg_to_reg(ctx, arg0);
    let v2 = C::value_reg(ctx, v1);
    // Rule at src/isa/pulley_shared/inst.isle line 617.
    return v2;
}

// Generated as internal constructor for term writable_vreg_to_value_regs.
pub fn constructor_writable_vreg_to_value_regs<C: Context>(
    ctx: &mut C,
    arg0: WritableVReg,
) -> ValueRegs {
    let v1 = constructor_writable_vreg_to_reg(ctx, arg0);
    let v2 = C::value_reg(ctx, v1);
    // Rule at src/isa/pulley_shared/inst.isle line 622.
    return v2;
}

// Generated as internal constructor for term temp_writable_vreg.
pub fn constructor_temp_writable_vreg<C: Context>(
    ctx: &mut C,
) -> WritableVReg {
    let v1 = C::temp_writable_reg(ctx, I8X16);
    let v2 = C::writable_vreg_new(ctx, v1);
    // Rule at src/isa/pulley_shared/inst.isle line 627.
    return v2;
}

// Generated as internal constructor for term imm.
pub fn constructor_imm<C: Context>(
    ctx: &mut C,
    arg0: i64,
) -> Reg {
    match arg0 {
        0_i64 => {
            let v1 = constructor_pulley_xzero(ctx);
            let v2 = C::xreg_to_reg(ctx, v1);
            // Rule at src/isa/pulley_shared/inst.isle line 635.
            return v2;
        }
        1_i64 => {
            let v3 = constructor_pulley_xone(ctx);
            let v4 = C::xreg_to_reg(ctx, v3);
            // Rule at src/isa/pulley_shared/inst.isle line 636.
            return v4;
        }
        _ => {}
    }
    let v5 = C::i64_from_i8(ctx, arg0);
    if let Some(v6) = v5 {
        let v7 = constructor_pulley_xconst8(ctx, v6);
        let v8 = C::xreg_to_reg(ctx, v7);
        // Rule at src/isa/pulley_shared/inst.isle line 640.
        return v8;
    }
    let v9 = C::i64_from_i16(ctx, arg0);
    if let Some(v10) = v9 {
        let v11 = constructor_pulley_xconst16(ctx, v10);
        let v12 = C::xreg_to_reg(ctx, v11);
        // Rule at src/isa/pulley_shared/inst.isle line 641.
        return v12;
    }
    let v13 = C::i64_from_i32(ctx, arg0);
    if let Some(v14) = v13 {
        let v15 = constructor_pulley_xconst32(ctx, v14);
        let v16 = C::xreg_to_reg(ctx, v15);
        // Rule at src/isa/pulley_shared/inst.isle line 642.
        return v16;
    }
    let v17 = constructor_pulley_xconst64(ctx, arg0);
    let v18 = C::xreg_to_reg(ctx, v17);
    // Rule at src/isa/pulley_shared/inst.isle line 643.
    return v18;
}

// Generated as internal constructor for term pulley_trap_if.
pub fn constructor_pulley_trap_if<C: Context>(
    ctx: &mut C,
    arg0: &Cond,
    arg1: &TrapCode,
) -> SideEffectNoResult {
    let v2 = MInst::TrapIf {
        cond: arg0.clone(),
        code: arg1.clone(),
    };
    let v3 = SideEffectNoResult::Inst {
        inst: v2,
    };
    // Rule at src/isa/pulley_shared/inst.isle line 648.
    return v3;
}

// Generated as internal constructor for term pulley_get_special.
pub fn constructor_pulley_get_special<C: Context>(
    ctx: &mut C,
    arg0: XReg,
) -> XReg {
    let v1 = constructor_temp_writable_xreg(ctx);
    let v2 = MInst::GetSpecial {
        dst: v1,
        reg: arg0,
    };
    let v3 = C::emit(ctx, &v2);
    let v4 = C::writable_xreg_to_xreg(ctx, v1);
    // Rule at src/isa/pulley_shared/inst.isle line 655.
    return v4;
}

// Generated as internal constructor for term pulley_jump.
pub fn constructor_pulley_jump<C: Context>(
    ctx: &mut C,
    arg0: MachLabel,
) -> SideEffectNoResult {
    let v1 = MInst::Jump {
        label: arg0,
    };
    let v2 = SideEffectNoResult::Inst {
        inst: v1,
    };
    // Rule at src/isa/pulley_shared/inst.isle line 661.
    return v2;
}

// Generated as internal constructor for term pulley_br_if.
pub fn constructor_pulley_br_if<C: Context>(
    ctx: &mut C,
    arg0: &Cond,
    arg1: MachLabel,
    arg2: MachLabel,
) -> SideEffectNoResult {
    let v3 = MInst::BrIf {
        cond: arg0.clone(),
        taken: arg1,
        not_taken: arg2,
    };
    let v4 = SideEffectNoResult::Inst {
        inst: v3,
    };
    // Rule at src/isa/pulley_shared/inst.isle line 665.
    return v4;
}

// Generated as internal constructor for term pulley_xload.
pub fn constructor_pulley_xload<C: Context>(
    ctx: &mut C,
    arg0: &Amode,
    arg1: Type,
    arg2: MemFlagsData,
) -> XReg {
    let v3 = constructor_temp_writable_xreg(ctx);
    let v4 = MInst::XLoad {
        dst: v3,
        mem: arg0.clone(),
        ty: arg1,
        flags: arg2,
    };
    let v5 = C::emit(ctx, &v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v3);
    // Rule at src/isa/pulley_shared/inst.isle line 669.
    return v6;
}

// Generated as internal constructor for term pulley_xstore.
pub fn constructor_pulley_xstore<C: Context>(
    ctx: &mut C,
    arg0: &Amode,
    arg1: XReg,
    arg2: Type,
    arg3: MemFlagsData,
) -> SideEffectNoResult {
    let v4 = MInst::XStore {
        mem: arg0.clone(),
        src: arg1,
        ty: arg2,
        flags: arg3,
    };
    let v5 = SideEffectNoResult::Inst {
        inst: v4,
    };
    // Rule at src/isa/pulley_shared/inst.isle line 675.
    return v5;
}

// Generated as internal constructor for term pulley_fload.
pub fn constructor_pulley_fload<C: Context>(
    ctx: &mut C,
    arg0: &Amode,
    arg1: Type,
    arg2: MemFlagsData,
) -> FReg {
    let v3 = constructor_temp_writable_freg(ctx);
    let v4 = MInst::FLoad {
        dst: v3,
        mem: arg0.clone(),
        ty: arg1,
        flags: arg2,
    };
    let v5 = C::emit(ctx, &v4);
    let v6 = C::writable_freg_to_freg(ctx, v3);
    // Rule at src/isa/pulley_shared/inst.isle line 679.
    return v6;
}

// Generated as internal constructor for term pulley_fstore.
pub fn constructor_pulley_fstore<C: Context>(
    ctx: &mut C,
    arg0: &Amode,
    arg1: FReg,
    arg2: Type,
    arg3: MemFlagsData,
) -> SideEffectNoResult {
    let v4 = MInst::FStore {
        mem: arg0.clone(),
        src: arg1,
        ty: arg2,
        flags: arg3,
    };
    let v5 = SideEffectNoResult::Inst {
        inst: v4,
    };
    // Rule at src/isa/pulley_shared/inst.isle line 685.
    return v5;
}

// Generated as internal constructor for term pulley_vload.
pub fn constructor_pulley_vload<C: Context>(
    ctx: &mut C,
    arg0: &Amode,
    arg1: Type,
    arg2: MemFlagsData,
) -> VReg {
    let v3 = constructor_temp_writable_vreg(ctx);
    let v4 = MInst::VLoad {
        dst: v3,
        mem: arg0.clone(),
        ty: arg1,
        flags: arg2,
    };
    let v5 = C::emit(ctx, &v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v3);
    // Rule at src/isa/pulley_shared/inst.isle line 689.
    return v6;
}

// Generated as internal constructor for term pulley_vstore.
pub fn constructor_pulley_vstore<C: Context>(
    ctx: &mut C,
    arg0: &Amode,
    arg1: VReg,
    arg2: Type,
    arg3: MemFlagsData,
) -> SideEffectNoResult {
    let v4 = MInst::VStore {
        mem: arg0.clone(),
        src: arg1,
        ty: arg2,
        flags: arg3,
    };
    let v5 = SideEffectNoResult::Inst {
        inst: v4,
    };
    // Rule at src/isa/pulley_shared/inst.isle line 695.
    return v5;
}

// Generated as internal constructor for term gen_br_table.
pub fn constructor_gen_br_table<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: MachLabel,
    arg2: &BoxVecMachLabel,
) -> Unit {
    let v3 = MInst::BrTable {
        idx: arg0,
        default: arg1,
        targets: arg2.clone(),
    };
    let v4 = C::emit(ctx, &v3);
    // Rule at src/isa/pulley_shared/inst.isle line 699.
    return v4;
}

// Generated as internal constructor for term load_ext_name_near.
pub fn constructor_load_ext_name_near<C: Context>(
    ctx: &mut C,
    arg0: BoxExternalName,
    arg1: i64,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = MInst::LoadExtNameNear {
        dst: v2,
        name: arg0,
        offset: arg1,
    };
    let v4 = C::emit(ctx, &v3);
    let v5 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at src/isa/pulley_shared/inst.isle line 704.
    return v5;
}

// Generated as internal constructor for term load_ext_name_far.
pub fn constructor_load_ext_name_far<C: Context>(
    ctx: &mut C,
    arg0: BoxExternalName,
    arg1: i64,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = MInst::LoadExtNameFar {
        dst: v2,
        name: arg0,
        offset: arg1,
    };
    let v4 = C::emit(ctx, &v3);
    let v5 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at src/isa/pulley_shared/inst.isle line 711.
    return v5;
}

// Generated as internal constructor for term load_ext_name.
pub fn constructor_load_ext_name<C: Context>(
    ctx: &mut C,
    arg0: BoxExternalName,
    arg1: i64,
    arg2: &RelocDistance,
) -> XReg {
    match arg2 {
        &RelocDistance::Near => {
            let v3 = constructor_load_ext_name_near(ctx, arg0, arg1);
            // Rule at src/isa/pulley_shared/inst.isle line 718.
            return v3;
        }
        &RelocDistance::Far => {
            let v4 = constructor_load_ext_name_far(ctx, arg0, arg1);
            // Rule at src/isa/pulley_shared/inst.isle line 720.
            return v4;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "load_ext_name", "src/isa/pulley_shared/inst.isle line 717")
}

// Generated as internal constructor for term call_impl.
pub fn constructor_call_impl<C: Context>(
    ctx: &mut C,
    arg0: BoxCallInfo,
) -> SideEffectNoResult {
    let v1 = MInst::Call {
        info: arg0,
    };
    let v2 = SideEffectNoResult::Inst {
        inst: v1,
    };
    // Rule at src/isa/pulley_shared/inst.isle line 742.
    return v2;
}

// Generated as internal constructor for term indirect_call_impl.
pub fn constructor_indirect_call_impl<C: Context>(
    ctx: &mut C,
    arg0: BoxCallIndInfo,
) -> SideEffectNoResult {
    let v1 = MInst::IndirectCall {
        info: arg0,
    };
    let v2 = SideEffectNoResult::Inst {
        inst: v1,
    };
    // Rule at src/isa/pulley_shared/inst.isle line 747.
    return v2;
}

// Generated as internal constructor for term indirect_call_host_impl.
pub fn constructor_indirect_call_host_impl<C: Context>(
    ctx: &mut C,
    arg0: BoxCallIndirectHostInfo,
) -> SideEffectNoResult {
    let v1 = MInst::IndirectCallHost {
        info: arg0,
    };
    let v2 = SideEffectNoResult::Inst {
        inst: v1,
    };
    // Rule at src/isa/pulley_shared/inst.isle line 752.
    return v2;
}

// Generated as internal constructor for term return_call_impl.
pub fn constructor_return_call_impl<C: Context>(
    ctx: &mut C,
    arg0: BoxReturnCallInfo,
) -> SideEffectNoResult {
    let v1 = MInst::ReturnCall {
        info: arg0,
    };
    let v2 = SideEffectNoResult::Inst {
        inst: v1,
    };
    // Rule at src/isa/pulley_shared/inst.isle line 757.
    return v2;
}

// Generated as internal constructor for term return_indirect_call_impl.
pub fn constructor_return_indirect_call_impl<C: Context>(
    ctx: &mut C,
    arg0: BoxReturnCallIndInfo,
) -> SideEffectNoResult {
    let v1 = MInst::ReturnIndirectCall {
        info: arg0,
    };
    let v2 = SideEffectNoResult::Inst {
        inst: v1,
    };
    // Rule at src/isa/pulley_shared/inst.isle line 762.
    return v2;
}

// Generated as internal constructor for term zext32.
pub fn constructor_zext32<C: Context>(
    ctx: &mut C,
    arg0: Value,
) -> XReg {
    let v1 = C::value_type(ctx, arg0);
    match v1 {
        I8 => {
            let v2 = constructor_put_in_xreg(ctx, arg0);
            let v3 = constructor_pulley_zext8(ctx, v2);
            // Rule at src/isa/pulley_shared/inst.isle line 769.
            return v3;
        }
        I16 => {
            let v2 = constructor_put_in_xreg(ctx, arg0);
            let v4 = constructor_pulley_zext16(ctx, v2);
            // Rule at src/isa/pulley_shared/inst.isle line 770.
            return v4;
        }
        I32 => {
            let v2 = constructor_put_in_xreg(ctx, arg0);
            // Rule at src/isa/pulley_shared/inst.isle line 771.
            return v2;
        }
        I64 => {
            let v2 = constructor_put_in_xreg(ctx, arg0);
            // Rule at src/isa/pulley_shared/inst.isle line 772.
            return v2;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "zext32", "src/isa/pulley_shared/inst.isle line 768")
}

// Generated as internal constructor for term sext32.
pub fn constructor_sext32<C: Context>(
    ctx: &mut C,
    arg0: Value,
) -> XReg {
    let v1 = C::value_type(ctx, arg0);
    match v1 {
        I8 => {
            let v2 = constructor_put_in_xreg(ctx, arg0);
            let v3 = constructor_pulley_sext8(ctx, v2);
            // Rule at src/isa/pulley_shared/inst.isle line 776.
            return v3;
        }
        I16 => {
            let v2 = constructor_put_in_xreg(ctx, arg0);
            let v4 = constructor_pulley_sext16(ctx, v2);
            // Rule at src/isa/pulley_shared/inst.isle line 777.
            return v4;
        }
        I32 => {
            let v2 = constructor_put_in_xreg(ctx, arg0);
            // Rule at src/isa/pulley_shared/inst.isle line 778.
            return v2;
        }
        I64 => {
            let v2 = constructor_put_in_xreg(ctx, arg0);
            // Rule at src/isa/pulley_shared/inst.isle line 779.
            return v2;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "sext32", "src/isa/pulley_shared/inst.isle line 775")
}

// Generated as internal constructor for term zext64.
pub fn constructor_zext64<C: Context>(
    ctx: &mut C,
    arg0: Value,
) -> XReg {
    let v1 = C::value_type(ctx, arg0);
    match v1 {
        I8 => {
            let v2 = constructor_put_in_xreg(ctx, arg0);
            let v3 = constructor_pulley_zext8(ctx, v2);
            // Rule at src/isa/pulley_shared/inst.isle line 783.
            return v3;
        }
        I16 => {
            let v2 = constructor_put_in_xreg(ctx, arg0);
            let v4 = constructor_pulley_zext16(ctx, v2);
            // Rule at src/isa/pulley_shared/inst.isle line 784.
            return v4;
        }
        I32 => {
            let v2 = constructor_put_in_xreg(ctx, arg0);
            let v5 = constructor_pulley_zext32(ctx, v2);
            // Rule at src/isa/pulley_shared/inst.isle line 785.
            return v5;
        }
        I64 => {
            let v2 = constructor_put_in_xreg(ctx, arg0);
            // Rule at src/isa/pulley_shared/inst.isle line 786.
            return v2;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "zext64", "src/isa/pulley_shared/inst.isle line 782")
}

// Generated as internal constructor for term sext64.
pub fn constructor_sext64<C: Context>(
    ctx: &mut C,
    arg0: Value,
) -> XReg {
    let v1 = C::value_type(ctx, arg0);
    match v1 {
        I8 => {
            let v2 = constructor_put_in_xreg(ctx, arg0);
            let v3 = constructor_pulley_sext8(ctx, v2);
            // Rule at src/isa/pulley_shared/inst.isle line 790.
            return v3;
        }
        I16 => {
            let v2 = constructor_put_in_xreg(ctx, arg0);
            let v4 = constructor_pulley_sext16(ctx, v2);
            // Rule at src/isa/pulley_shared/inst.isle line 791.
            return v4;
        }
        I32 => {
            let v2 = constructor_put_in_xreg(ctx, arg0);
            let v5 = constructor_pulley_sext32(ctx, v2);
            // Rule at src/isa/pulley_shared/inst.isle line 792.
            return v5;
        }
        I64 => {
            let v2 = constructor_put_in_xreg(ctx, arg0);
            // Rule at src/isa/pulley_shared/inst.isle line 793.
            return v2;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "sext64", "src/isa/pulley_shared/inst.isle line 789")
}

// Generated as internal constructor for term pulley_label_address.
pub fn constructor_pulley_label_address<C: Context>(
    ctx: &mut C,
    arg0: MachLabel,
) -> Reg {
    let v1 = constructor_temp_writable_xreg(ctx);
    let v2 = C::writable_xreg_to_writable_reg(ctx, v1);
    let v3 = C::writable_xreg_new(ctx, v2);
    let v4 = MInst::LabelAddress {
        dst: v3,
        label: arg0,
    };
    let v5 = C::emit(ctx, &v4);
    let v6 = C::writable_reg_to_reg(ctx, v2);
    // Rule at src/isa/pulley_shared/inst.isle line 797.
    return v6;
}

// Generated as internal constructor for term pulley_sequence_point.
pub fn constructor_pulley_sequence_point<C: Context>(
    ctx: &mut C,
) -> SideEffectNoResult {
    let v1 = SideEffectNoResult::Inst {
        inst: MInst::SequencePoint,
    };
    // Rule at src/isa/pulley_shared/inst.isle line 804.
    return v1;
}

// Generated as internal constructor for term lower.
pub fn constructor_lower<C: Context>(
    ctx: &mut C,
    arg0: Inst,
) -> Option<InstOutput> {
    let v1 = C::inst_data_value(ctx, arg0);
    match &v1.1 {
        &InstructionData::Binary {
            opcode: ref v127,
            args: ref v128,
        } => {
            match v127 {
                &Opcode::Swizzle => {
                    let v102 = C::first_result(ctx, arg0);
                    if let Some(v103) = v102 {
                        let v104 = C::value_type(ctx, v103);
                        if v104 == I8X16 {
                            let v129 = C::unpack_value_array_2(ctx, v128);
                            let v197 = constructor_put_in_vreg(ctx, v129.0);
                            let v198 = constructor_put_in_vreg(ctx, v129.1);
                            let v1622 = constructor_pulley_vswizzlei8x16(ctx, v197, v198);
                            let v1623 = constructor_output_vreg(ctx, v1622);
                            let v1624 = Some(v1623);
                            // Rule at src/isa/pulley_shared/lower.isle line 1901.
                            return v1624;
                        }
                    }
                }
                &Opcode::Smin => {
                    let v102 = C::first_result(ctx, arg0);
                    if let Some(v103) = v102 {
                        let v104 = C::value_type(ctx, v103);
                        match v104 {
                            I64 => {
                                let v129 = C::unpack_value_array_2(ctx, v128);
                                let v132 = constructor_put_in_xreg(ctx, v129.0);
                                let v133 = constructor_put_in_xreg(ctx, v129.1);
                                let v682 = constructor_pulley_xmin64_s(ctx, v132, v133);
                                let v683 = constructor_output_xreg(ctx, v682);
                                let v684 = Some(v683);
                                // Rule at src/isa/pulley_shared/lower.isle line 671.
                                return v684;
                            }
                            I8X16 => {
                                let v129 = C::unpack_value_array_2(ctx, v128);
                                let v197 = constructor_put_in_vreg(ctx, v129.0);
                                let v198 = constructor_put_in_vreg(ctx, v129.1);
                                let v685 = constructor_pulley_vmin8x16_s(ctx, v197, v198);
                                let v686 = constructor_output_vreg(ctx, v685);
                                let v687 = Some(v686);
                                // Rule at src/isa/pulley_shared/lower.isle line 672.
                                return v687;
                            }
                            I16X8 => {
                                let v129 = C::unpack_value_array_2(ctx, v128);
                                let v197 = constructor_put_in_vreg(ctx, v129.0);
                                let v198 = constructor_put_in_vreg(ctx, v129.1);
                                let v688 = constructor_pulley_vmin16x8_s(ctx, v197, v198);
                                let v689 = constructor_output_vreg(ctx, v688);
                                let v690 = Some(v689);
                                // Rule at src/isa/pulley_shared/lower.isle line 673.
                                return v690;
                            }
                            I32X4 => {
                                let v129 = C::unpack_value_array_2(ctx, v128);
                                let v197 = constructor_put_in_vreg(ctx, v129.0);
                                let v198 = constructor_put_in_vreg(ctx, v129.1);
                                let v691 = constructor_pulley_vmin32x4_s(ctx, v197, v198);
                                let v692 = constructor_output_vreg(ctx, v691);
                                let v693 = Some(v692);
                                // Rule at src/isa/pulley_shared/lower.isle line 674.
                                return v693;
                            }
                            _ => {}
                        }
                        let v446 = C::fits_in_32(ctx, v104);
                        if let Some(v447) = v446 {
                            let v129 = C::unpack_value_array_2(ctx, v128);
                            let v425 = constructor_sext32(ctx, v129.0);
                            let v426 = constructor_sext32(ctx, v129.1);
                            let v679 = constructor_pulley_xmin32_s(ctx, v425, v426);
                            let v680 = constructor_output_xreg(ctx, v679);
                            let v681 = Some(v680);
                            // Rule at src/isa/pulley_shared/lower.isle line 669.
                            return v681;
                        }
                    }
                }
                &Opcode::Umin => {
                    let v102 = C::first_result(ctx, arg0);
                    if let Some(v103) = v102 {
                        let v104 = C::value_type(ctx, v103);
                        match v104 {
                            I64 => {
                                let v129 = C::unpack_value_array_2(ctx, v128);
                                let v132 = constructor_put_in_xreg(ctx, v129.0);
                                let v133 = constructor_put_in_xreg(ctx, v129.1);
                                let v667 = constructor_pulley_xmin64_u(ctx, v132, v133);
                                let v668 = constructor_output_xreg(ctx, v667);
                                let v669 = Some(v668);
                                // Rule at src/isa/pulley_shared/lower.isle line 662.
                                return v669;
                            }
                            I8X16 => {
                                let v129 = C::unpack_value_array_2(ctx, v128);
                                let v197 = constructor_put_in_vreg(ctx, v129.0);
                                let v198 = constructor_put_in_vreg(ctx, v129.1);
                                let v670 = constructor_pulley_vmin8x16_u(ctx, v197, v198);
                                let v671 = constructor_output_vreg(ctx, v670);
                                let v672 = Some(v671);
                                // Rule at src/isa/pulley_shared/lower.isle line 663.
                                return v672;
                            }
                            I16X8 => {
                                let v129 = C::unpack_value_array_2(ctx, v128);
                                let v197 = constructor_put_in_vreg(ctx, v129.0);
                                let v198 = constructor_put_in_vreg(ctx, v129.1);
                                let v673 = constructor_pulley_vmin16x8_u(ctx, v197, v198);
                                let v674 = constructor_output_vreg(ctx, v673);
                                let v675 = Some(v674);
                                // Rule at src/isa/pulley_shared/lower.isle line 664.
                                return v675;
                            }
                            I32X4 => {
                                let v129 = C::unpack_value_array_2(ctx, v128);
                                let v197 = constructor_put_in_vreg(ctx, v129.0);
                                let v198 = constructor_put_in_vreg(ctx, v129.1);
                                let v676 = constructor_pulley_vmin32x4_u(ctx, v197, v198);
                                let v677 = constructor_output_vreg(ctx, v676);
                                let v678 = Some(v677);
                                // Rule at src/isa/pulley_shared/lower.isle line 665.
                                return v678;
                            }
                            _ => {}
                        }
                        let v446 = C::fits_in_32(ctx, v104);
                        if let Some(v447) = v446 {
                            let v129 = C::unpack_value_array_2(ctx, v128);
                            let v397 = constructor_zext32(ctx, v129.0);
                            let v398 = constructor_zext32(ctx, v129.1);
                            let v664 = constructor_pulley_xmin32_u(ctx, v397, v398);
                            let v665 = constructor_output_xreg(ctx, v664);
                            let v666 = Some(v665);
                            // Rule at src/isa/pulley_shared/lower.isle line 660.
                            return v666;
                        }
                    }
                }
                &Opcode::Smax => {
                    let v102 = C::first_result(ctx, arg0);
                    if let Some(v103) = v102 {
                        let v104 = C::value_type(ctx, v103);
                        match v104 {
                            I64 => {
                                let v129 = C::unpack_value_array_2(ctx, v128);
                                let v132 = constructor_put_in_xreg(ctx, v129.0);
                                let v133 = constructor_put_in_xreg(ctx, v129.1);
                                let v712 = constructor_pulley_xmax64_s(ctx, v132, v133);
                                let v713 = constructor_output_xreg(ctx, v712);
                                let v714 = Some(v713);
                                // Rule at src/isa/pulley_shared/lower.isle line 689.
                                return v714;
                            }
                            I8X16 => {
                                let v129 = C::unpack_value_array_2(ctx, v128);
                                let v197 = constructor_put_in_vreg(ctx, v129.0);
                                let v198 = constructor_put_in_vreg(ctx, v129.1);
                                let v715 = constructor_pulley_vmax8x16_s(ctx, v197, v198);
                                let v716 = constructor_output_vreg(ctx, v715);
                                let v717 = Some(v716);
                                // Rule at src/isa/pulley_shared/lower.isle line 690.
                                return v717;
                            }
                            I16X8 => {
                                let v129 = C::unpack_value_array_2(ctx, v128);
                                let v197 = constructor_put_in_vreg(ctx, v129.0);
                                let v198 = constructor_put_in_vreg(ctx, v129.1);
                                let v718 = constructor_pulley_vmax16x8_s(ctx, v197, v198);
                                let v719 = constructor_output_vreg(ctx, v718);
                                let v720 = Some(v719);
                                // Rule at src/isa/pulley_shared/lower.isle line 691.
                                return v720;
                            }
                            I32X4 => {
                                let v129 = C::unpack_value_array_2(ctx, v128);
                                let v197 = constructor_put_in_vreg(ctx, v129.0);
                                let v198 = constructor_put_in_vreg(ctx, v129.1);
                                let v721 = constructor_pulley_vmax32x4_s(ctx, v197, v198);
                                let v722 = constructor_output_vreg(ctx, v721);
                                let v723 = Some(v722);
                                // Rule at src/isa/pulley_shared/lower.isle line 692.
                                return v723;
                            }
                            _ => {}
                        }
                        let v446 = C::fits_in_32(ctx, v104);
                        if let Some(v447) = v446 {
                            let v129 = C::unpack_value_array_2(ctx, v128);
                            let v425 = constructor_sext32(ctx, v129.0);
                            let v426 = constructor_sext32(ctx, v129.1);
                            let v709 = constructor_pulley_xmax32_s(ctx, v425, v426);
                            let v710 = constructor_output_xreg(ctx, v709);
                            let v711 = Some(v710);
                            // Rule at src/isa/pulley_shared/lower.isle line 687.
                            return v711;
                        }
                    }
                }
                &Opcode::Umax => {
                    let v102 = C::first_result(ctx, arg0);
                    if let Some(v103) = v102 {
                        let v104 = C::value_type(ctx, v103);
                        match v104 {
                            I64 => {
                                let v129 = C::unpack_value_array_2(ctx, v128);
                                let v132 = constructor_put_in_xreg(ctx, v129.0);
                                let v133 = constructor_put_in_xreg(ctx, v129.1);
                                let v697 = constructor_pulley_xmax64_u(ctx, v132, v133);
                                let v698 = constructor_output_xreg(ctx, v697);
                                let v699 = Some(v698);
                                // Rule at src/isa/pulley_shared/lower.isle line 680.
                                return v699;
                            }
                            I8X16 => {
                                let v129 = C::unpack_value_array_2(ctx, v128);
                                let v197 = constructor_put_in_vreg(ctx, v129.0);
                                let v198 = constructor_put_in_vreg(ctx, v129.1);
                                let v700 = constructor_pulley_vmax8x16_u(ctx, v197, v198);
                                let v701 = constructor_output_vreg(ctx, v700);
                                let v702 = Some(v701);
                                // Rule at src/isa/pulley_shared/lower.isle line 681.
                                return v702;
                            }
                            I16X8 => {
                                let v129 = C::unpack_value_array_2(ctx, v128);
                                let v197 = constructor_put_in_vreg(ctx, v129.0);
                                let v198 = constructor_put_in_vreg(ctx, v129.1);
                                let v703 = constructor_pulley_vmax16x8_u(ctx, v197, v198);
                                let v704 = constructor_output_vreg(ctx, v703);
                                let v705 = Some(v704);
                                // Rule at src/isa/pulley_shared/lower.isle line 682.
                                return v705;
                            }
                            I32X4 => {
                                let v129 = C::unpack_value_array_2(ctx, v128);
                                let v197 = constructor_put_in_vreg(ctx, v129.0);
                                let v198 = constructor_put_in_vreg(ctx, v129.1);
                                let v706 = constructor_pulley_vmax32x4_u(ctx, v197, v198);
                                let v707 = constructor_output_vreg(ctx, v706);
                                let v708 = Some(v707);
                                // Rule at src/isa/pulley_shared/lower.isle line 683.
                                return v708;
                            }
                            _ => {}
                        }
                        let v446 = C::fits_in_32(ctx, v104);
                        if let Some(v447) = v446 {
                            let v129 = C::unpack_value_array_2(ctx, v128);
                            let v397 = constructor_zext32(ctx, v129.0);
                            let v398 = constructor_zext32(ctx, v129.1);
                            let v694 = constructor_pulley_xmax32_u(ctx, v397, v398);
                            let v695 = constructor_output_xreg(ctx, v694);
                            let v696 = Some(v695);
                            // Rule at src/isa/pulley_shared/lower.isle line 678.
                            return v696;
                        }
                    }
                }
                &Opcode::AvgRound => {
                    let v102 = C::first_result(ctx, arg0);
                    if let Some(v103) = v102 {
                        let v104 = C::value_type(ctx, v103);
                        match v104 {
                            I8X16 => {
                                let v129 = C::unpack_value_array_2(ctx, v128);
                                let v197 = constructor_put_in_vreg(ctx, v129.0);
                                let v198 = constructor_put_in_vreg(ctx, v129.1);
                                let v472 = constructor_pulley_vavground8x16(ctx, v197, v198);
                                let v473 = constructor_output_vreg(ctx, v472);
                                let v474 = Some(v473);
                                // Rule at src/isa/pulley_shared/lower.isle line 491.
                                return v474;
                            }
                            I16X8 => {
                                let v129 = C::unpack_value_array_2(ctx, v128);
                                let v197 = constructor_put_in_vreg(ctx, v129.0);
                                let v198 = constructor_put_in_vreg(ctx, v129.1);
                                let v475 = constructor_pulley_vavground16x8(ctx, v197, v198);
                                let v476 = constructor_output_vreg(ctx, v475);
                                let v477 = Some(v476);
                                // Rule at src/isa/pulley_shared/lower.isle line 492.
                                return v477;
                            }
                            _ => {}
                        }
                    }
                }
                &Opcode::UaddSat => {
                    let v102 = C::first_result(ctx, arg0);
                    if let Some(v103) = v102 {
                        let v104 = C::value_type(ctx, v103);
                        match v104 {
                            I8X16 => {
                                let v129 = C::unpack_value_array_2(ctx, v128);
                                let v197 = constructor_put_in_vreg(ctx, v129.0);
                                let v198 = constructor_put_in_vreg(ctx, v129.1);
                                let v214 = constructor_pulley_vaddu8x16_sat(ctx, v197, v198);
                                let v215 = constructor_output_vreg(ctx, v214);
                                let v216 = Some(v215);
                                // Rule at src/isa/pulley_shared/lower.isle line 307.
                                return v216;
                            }
                            I16X8 => {
                                let v129 = C::unpack_value_array_2(ctx, v128);
                                let v197 = constructor_put_in_vreg(ctx, v129.0);
                                let v198 = constructor_put_in_vreg(ctx, v129.1);
                                let v220 = constructor_pulley_vaddu16x8_sat(ctx, v197, v198);
                                let v221 = constructor_output_vreg(ctx, v220);
                                let v222 = Some(v221);
                                // Rule at src/isa/pulley_shared/lower.isle line 309.
                                return v222;
                            }
                            _ => {}
                        }
                    }
                }
                &Opcode::SaddSat => {
                    let v102 = C::first_result(ctx, arg0);
                    if let Some(v103) = v102 {
                        let v104 = C::value_type(ctx, v103);
                        match v104 {
                            I8X16 => {
                                let v129 = C::unpack_value_array_2(ctx, v128);
                                let v197 = constructor_put_in_vreg(ctx, v129.0);
                                let v198 = constructor_put_in_vreg(ctx, v129.1);
                                let v211 = constructor_pulley_vaddi8x16_sat(ctx, v197, v198);
                                let v212 = constructor_output_vreg(ctx, v211);
                                let v213 = Some(v212);
                                // Rule at src/isa/pulley_shared/lower.isle line 306.
                                return v213;
                            }
                            I16X8 => {
                                let v129 = C::unpack_value_array_2(ctx, v128);
                                let v197 = constructor_put_in_vreg(ctx, v129.0);
                                let v198 = constructor_put_in_vreg(ctx, v129.1);
                                let v217 = constructor_pulley_vaddi16x8_sat(ctx, v197, v198);
                                let v218 = constructor_output_vreg(ctx, v217);
                                let v219 = Some(v218);
                                // Rule at src/isa/pulley_shared/lower.isle line 308.
                                return v219;
                            }
                            _ => {}
                        }
                    }
                }
                &Opcode::UsubSat => {
                    let v102 = C::first_result(ctx, arg0);
                    if let Some(v103) = v102 {
                        let v104 = C::value_type(ctx, v103);
                        match v104 {
                            I8X16 => {
                                let v129 = C::unpack_value_array_2(ctx, v128);
                                let v197 = constructor_put_in_vreg(ctx, v129.0);
                                let v198 = constructor_put_in_vreg(ctx, v129.1);
                                let v310 = constructor_pulley_vsubu8x16_sat(ctx, v197, v198);
                                let v311 = constructor_output_vreg(ctx, v310);
                                let v312 = Some(v311);
                                // Rule at src/isa/pulley_shared/lower.isle line 370.
                                return v312;
                            }
                            I16X8 => {
                                let v129 = C::unpack_value_array_2(ctx, v128);
                                let v197 = constructor_put_in_vreg(ctx, v129.0);
                                let v198 = constructor_put_in_vreg(ctx, v129.1);
                                let v316 = constructor_pulley_vsubu16x8_sat(ctx, v197, v198);
                                let v317 = constructor_output_vreg(ctx, v316);
                                let v318 = Some(v317);
                                // Rule at src/isa/pulley_shared/lower.isle line 372.
                                return v318;
                            }
                            _ => {}
                        }
                    }
                }
                &Opcode::SsubSat => {
                    let v102 = C::first_result(ctx, arg0);
                    if let Some(v103) = v102 {
                        let v104 = C::value_type(ctx, v103);
                        match v104 {
                            I8X16 => {
                                let v129 = C::unpack_value_array_2(ctx, v128);
                                let v197 = constructor_put_in_vreg(ctx, v129.0);
                                let v198 = constructor_put_in_vreg(ctx, v129.1);
                                let v307 = constructor_pulley_vsubi8x16_sat(ctx, v197, v198);
                                let v308 = constructor_output_vreg(ctx, v307);
                                let v309 = Some(v308);
                                // Rule at src/isa/pulley_shared/lower.isle line 369.
                                return v309;
                            }
                            I16X8 => {
                                let v129 = C::unpack_value_array_2(ctx, v128);
                                let v197 = constructor_put_in_vreg(ctx, v129.0);
                                let v198 = constructor_put_in_vreg(ctx, v129.1);
                                let v313 = constructor_pulley_vsubi16x8_sat(ctx, v197, v198);
                                let v314 = constructor_output_vreg(ctx, v313);
                                let v315 = Some(v314);
                                // Rule at src/isa/pulley_shared/lower.isle line 371.
                                return v315;
                            }
                            _ => {}
                        }
                    }
                }
                &Opcode::Iadd => {
                    let v102 = C::first_result(ctx, arg0);
                    if let Some(v103) = v102 {
                        let v129 = C::unpack_value_array_2(ctx, v128);
                        let v174 = constructor_u8_from_negated_iconst(ctx, v129.1);
                        if let Some(v175) = v174 {
                            let v104 = C::value_type(ctx, v103);
                            if v104 == I64 {
                                let v132 = constructor_put_in_xreg(ctx, v129.0);
                                let v179 = constructor_pulley_xsub64_u8(ctx, v132, v175);
                                let v180 = constructor_output_xreg(ctx, v179);
                                let v181 = Some(v180);
                                // Rule at src/isa/pulley_shared/lower.isle line 270.
                                return v181;
                            }
                            let v123 = C::ty_int(ctx, v104);
                            if let Some(v124) = v123 {
                                let v140 = C::fits_in_32(ctx, v124);
                                if let Some(v141) = v140 {
                                    let v132 = constructor_put_in_xreg(ctx, v129.0);
                                    let v176 = constructor_pulley_xsub32_u8(ctx, v132, v175);
                                    let v177 = constructor_output_xreg(ctx, v176);
                                    let v178 = Some(v177);
                                    // Rule at src/isa/pulley_shared/lower.isle line 267.
                                    return v178;
                                }
                            }
                        }
                        let v166 = constructor_u32_from_negated_iconst(ctx, v129.1);
                        if let Some(v167) = v166 {
                            let v104 = C::value_type(ctx, v103);
                            if v104 == I64 {
                                let v132 = constructor_put_in_xreg(ctx, v129.0);
                                let v171 = constructor_pulley_xsub64_u32(ctx, v132, v167);
                                let v172 = constructor_output_xreg(ctx, v171);
                                let v173 = Some(v172);
                                // Rule at src/isa/pulley_shared/lower.isle line 264.
                                return v173;
                            }
                            let v123 = C::ty_int(ctx, v104);
                            if let Some(v124) = v123 {
                                let v140 = C::fits_in_32(ctx, v124);
                                if let Some(v141) = v140 {
                                    let v132 = constructor_put_in_xreg(ctx, v129.0);
                                    let v168 = constructor_pulley_xsub32_u32(ctx, v132, v167);
                                    let v169 = constructor_output_xreg(ctx, v168);
                                    let v170 = Some(v169);
                                    // Rule at src/isa/pulley_shared/lower.isle line 261.
                                    return v170;
                                }
                            }
                        }
                        let v142 = C::def_inst(ctx, v129.1);
                        if let Some(v143) = v142 {
                            let v144 = C::inst_data_value(ctx, v143);
                            match &v144.1 {
                                &InstructionData::Binary {
                                    opcode: ref v239,
                                    args: ref v240,
                                } => {
                                    if let &Opcode::Imul = v239 {
                                        let v104 = C::value_type(ctx, v103);
                                        match v104 {
                                            I32 => {
                                                let v241 = C::unpack_value_array_2(ctx, v240);
                                                let v244 = constructor_put_in_xreg(ctx, v241.0);
                                                let v245 = constructor_put_in_xreg(ctx, v241.1);
                                                let v246 = constructor_put_in_xreg(ctx, v129.0);
                                                let v247 = constructor_pulley_xmadd32(ctx, v244, v245, v246);
                                                let v248 = constructor_output_xreg(ctx, v247);
                                                let v249 = Some(v248);
                                                // Rule at src/isa/pulley_shared/lower.isle line 314.
                                                return v249;
                                            }
                                            I64 => {
                                                let v241 = C::unpack_value_array_2(ctx, v240);
                                                let v244 = constructor_put_in_xreg(ctx, v241.0);
                                                let v245 = constructor_put_in_xreg(ctx, v241.1);
                                                let v246 = constructor_put_in_xreg(ctx, v129.0);
                                                let v253 = constructor_pulley_xmadd64(ctx, v244, v245, v246);
                                                let v254 = constructor_output_xreg(ctx, v253);
                                                let v255 = Some(v254);
                                                // Rule at src/isa/pulley_shared/lower.isle line 316.
                                                return v255;
                                            }
                                            _ => {}
                                        }
                                    }
                                }
                                &InstructionData::UnaryImm {
                                    opcode: ref v147,
                                    imm: v148,
                                } => {
                                    if let &Opcode::Iconst = v147 {
                                        let v104 = C::value_type(ctx, v103);
                                        if v104 == I64 {
                                            let v149 = C::u64_from_imm64(ctx, v148);
                                            let v155 = C::u64_from_u8(ctx, v149);
                                            if let Some(v156) = v155 {
                                                let v132 = constructor_put_in_xreg(ctx, v129.0);
                                                let v163 = constructor_pulley_xadd64_u8(ctx, v132, v156);
                                                let v164 = constructor_output_xreg(ctx, v163);
                                                let v165 = Some(v164);
                                                // Rule at src/isa/pulley_shared/lower.isle line 256.
                                                return v165;
                                            }
                                            let v150 = C::u64_from_u32(ctx, v149);
                                            if let Some(v151) = v150 {
                                                let v132 = constructor_put_in_xreg(ctx, v129.0);
                                                let v160 = constructor_pulley_xadd64_u32(ctx, v132, v151);
                                                let v161 = constructor_output_xreg(ctx, v160);
                                                let v162 = Some(v161);
                                                // Rule at src/isa/pulley_shared/lower.isle line 254.
                                                return v162;
                                            }
                                        }
                                        let v123 = C::ty_int(ctx, v104);
                                        if let Some(v124) = v123 {
                                            let v140 = C::fits_in_32(ctx, v124);
                                            if let Some(v141) = v140 {
                                                let v149 = C::u64_from_imm64(ctx, v148);
                                                let v155 = C::u64_from_u8(ctx, v149);
                                                if let Some(v156) = v155 {
                                                    let v132 = constructor_put_in_xreg(ctx, v129.0);
                                                    let v157 = constructor_pulley_xadd32_u8(ctx, v132, v156);
                                                    let v158 = constructor_output_xreg(ctx, v157);
                                                    let v159 = Some(v158);
                                                    // Rule at src/isa/pulley_shared/lower.isle line 252.
                                                    return v159;
                                                }
                                                let v150 = C::u64_from_u32(ctx, v149);
                                                if let Some(v151) = v150 {
                                                    let v132 = constructor_put_in_xreg(ctx, v129.0);
                                                    let v152 = constructor_pulley_xadd32_u32(ctx, v132, v151);
                                                    let v153 = constructor_output_xreg(ctx, v152);
                                                    let v154 = Some(v153);
                                                    // Rule at src/isa/pulley_shared/lower.isle line 250.
                                                    return v154;
                                                }
                                            }
                                        }
                                    }
                                }
                                _ => {}
                            }
                        }
                        let v104 = C::value_type(ctx, v103);
                        match v104 {
                            I32 => {
                                let v223 = C::def_inst(ctx, v129.0);
                                if let Some(v224) = v223 {
                                    let v225 = C::inst_data_value(ctx, v224);
                                    if let &InstructionData::Binary {
                                        opcode: ref v228,
                                        args: ref v229,
                                    } = &v225.1 {
                                        if let &Opcode::Imul = v228 {
                                            let v230 = C::unpack_value_array_2(ctx, v229);
                                            let v233 = constructor_put_in_xreg(ctx, v230.0);
                                            let v234 = constructor_put_in_xreg(ctx, v230.1);
                                            let v235 = constructor_put_in_xreg(ctx, v129.1);
                                            let v236 = constructor_pulley_xmadd32(ctx, v233, v234, v235);
                                            let v237 = constructor_output_xreg(ctx, v236);
                                            let v238 = Some(v237);
                                            // Rule at src/isa/pulley_shared/lower.isle line 313.
                                            return v238;
                                        }
                                    }
                                }
                            }
                            I64 => {
                                let v223 = C::def_inst(ctx, v129.0);
                                if let Some(v224) = v223 {
                                    let v225 = C::inst_data_value(ctx, v224);
                                    if let &InstructionData::Binary {
                                        opcode: ref v228,
                                        args: ref v229,
                                    } = &v225.1 {
                                        if let &Opcode::Imul = v228 {
                                            let v230 = C::unpack_value_array_2(ctx, v229);
                                            let v233 = constructor_put_in_xreg(ctx, v230.0);
                                            let v234 = constructor_put_in_xreg(ctx, v230.1);
                                            let v235 = constructor_put_in_xreg(ctx, v129.1);
                                            let v250 = constructor_pulley_xmadd64(ctx, v233, v234, v235);
                                            let v251 = constructor_output_xreg(ctx, v250);
                                            let v252 = Some(v251);
                                            // Rule at src/isa/pulley_shared/lower.isle line 315.
                                            return v252;
                                        }
                                    }
                                }
                                let v132 = constructor_put_in_xreg(ctx, v129.0);
                                let v133 = constructor_put_in_xreg(ctx, v129.1);
                                let v137 = constructor_pulley_xadd64(ctx, v132, v133);
                                let v138 = constructor_output_xreg(ctx, v137);
                                let v139 = Some(v138);
                                // Rule at src/isa/pulley_shared/lower.isle line 247.
                                return v139;
                            }
                            I128 => {
                                let v182 = C::put_in_regs(ctx, v129.0);
                                let v183 = C::put_in_regs(ctx, v129.1);
                                let v185 = C::value_regs_get(ctx, v182, 0x0_usize);
                                let v186 = C::xreg_new(ctx, v185);
                                let v188 = C::value_regs_get(ctx, v182, 0x1_usize);
                                let v189 = C::xreg_new(ctx, v188);
                                let v190 = C::value_regs_get(ctx, v183, 0x0_usize);
                                let v191 = C::xreg_new(ctx, v190);
                                let v192 = C::value_regs_get(ctx, v183, 0x1_usize);
                                let v193 = C::xreg_new(ctx, v192);
                                let v194 = constructor_pulley_xadd128(ctx, v186, v189, v191, v193);
                                let v195 = C::output(ctx, v194);
                                let v196 = Some(v195);
                                // Rule at src/isa/pulley_shared/lower.isle line 291.
                                return v196;
                            }
                            I8X16 => {
                                let v197 = constructor_put_in_vreg(ctx, v129.0);
                                let v198 = constructor_put_in_vreg(ctx, v129.1);
                                let v199 = constructor_pulley_vaddi8x16(ctx, v197, v198);
                                let v200 = constructor_output_vreg(ctx, v199);
                                let v201 = Some(v200);
                                // Rule at src/isa/pulley_shared/lower.isle line 301.
                                return v201;
                            }
                            I16X8 => {
                                let v197 = constructor_put_in_vreg(ctx, v129.0);
                                let v198 = constructor_put_in_vreg(ctx, v129.1);
                                let v202 = constructor_pulley_vaddi16x8(ctx, v197, v198);
                                let v203 = constructor_output_vreg(ctx, v202);
                                let v204 = Some(v203);
                                // Rule at src/isa/pulley_shared/lower.isle line 302.
                                return v204;
                            }
                            I32X4 => {
                                let v197 = constructor_put_in_vreg(ctx, v129.0);
                                let v198 = constructor_put_in_vreg(ctx, v129.1);
                                let v205 = constructor_pulley_vaddi32x4(ctx, v197, v198);
                                let v206 = constructor_output_vreg(ctx, v205);
                                let v207 = Some(v206);
                                // Rule at src/isa/pulley_shared/lower.isle line 303.
                                return v207;
                            }
                            I64X2 => {
                                let v197 = constructor_put_in_vreg(ctx, v129.0);
                                let v198 = constructor_put_in_vreg(ctx, v129.1);
                                let v208 = constructor_pulley_vaddi64x2(ctx, v197, v198);
                                let v209 = constructor_output_vreg(ctx, v208);
                                let v210 = Some(v209);
                                // Rule at src/isa/pulley_shared/lower.isle line 304.
                                return v210;
                            }
                            _ => {}
                        }
                        let v123 = C::ty_int(ctx, v104);
                        if let Some(v124) = v123 {
                            let v125 = C::fits_in_64(ctx, v124);
                            if let Some(v126) = v125 {
                                let v132 = constructor_put_in_xreg(ctx, v129.0);
                                let v133 = constructor_put_in_xreg(ctx, v129.1);
                                let v134 = constructor_pulley_xadd32(ctx, v132, v133);
                                let v135 = constructor_output_xreg(ctx, v134);
                                let v136 = Some(v135);
                                // Rule at src/isa/pulley_shared/lower.isle line 246.
                                return v136;
                            }
                        }
                    }
                }
                &Opcode::Isub => {
                    let v102 = C::first_result(ctx, arg0);
                    if let Some(v103) = v102 {
                        let v129 = C::unpack_value_array_2(ctx, v128);
                        let v174 = constructor_u8_from_negated_iconst(ctx, v129.1);
                        if let Some(v175) = v174 {
                            let v104 = C::value_type(ctx, v103);
                            if v104 == I64 {
                                let v132 = constructor_put_in_xreg(ctx, v129.0);
                                let v289 = constructor_pulley_xadd64_u8(ctx, v132, v175);
                                let v290 = constructor_output_xreg(ctx, v289);
                                let v291 = Some(v290);
                                // Rule at src/isa/pulley_shared/lower.isle line 349.
                                return v291;
                            }
                            let v123 = C::ty_int(ctx, v104);
                            if let Some(v124) = v123 {
                                let v140 = C::fits_in_32(ctx, v124);
                                if let Some(v141) = v140 {
                                    let v132 = constructor_put_in_xreg(ctx, v129.0);
                                    let v286 = constructor_pulley_xadd32_u8(ctx, v132, v175);
                                    let v287 = constructor_output_xreg(ctx, v286);
                                    let v288 = Some(v287);
                                    // Rule at src/isa/pulley_shared/lower.isle line 346.
                                    return v288;
                                }
                            }
                        }
                        let v166 = constructor_u32_from_negated_iconst(ctx, v129.1);
                        if let Some(v167) = v166 {
                            let v104 = C::value_type(ctx, v103);
                            if v104 == I64 {
                                let v132 = constructor_put_in_xreg(ctx, v129.0);
                                let v283 = constructor_pulley_xadd64_u32(ctx, v132, v167);
                                let v284 = constructor_output_xreg(ctx, v283);
                                let v285 = Some(v284);
                                // Rule at src/isa/pulley_shared/lower.isle line 343.
                                return v285;
                            }
                            let v123 = C::ty_int(ctx, v104);
                            if let Some(v124) = v123 {
                                let v140 = C::fits_in_32(ctx, v124);
                                if let Some(v141) = v140 {
                                    let v132 = constructor_put_in_xreg(ctx, v129.0);
                                    let v280 = constructor_pulley_xadd32_u32(ctx, v132, v167);
                                    let v281 = constructor_output_xreg(ctx, v280);
                                    let v282 = Some(v281);
                                    // Rule at src/isa/pulley_shared/lower.isle line 340.
                                    return v282;
                                }
                            }
                        }
                        let v142 = C::def_inst(ctx, v129.1);
                        if let Some(v143) = v142 {
                            let v144 = C::inst_data_value(ctx, v143);
                            if let &InstructionData::UnaryImm {
                                opcode: ref v147,
                                imm: v148,
                            } = &v144.1 {
                                if let &Opcode::Iconst = v147 {
                                    let v104 = C::value_type(ctx, v103);
                                    if v104 == I64 {
                                        let v149 = C::u64_from_imm64(ctx, v148);
                                        let v155 = C::u64_from_u8(ctx, v149);
                                        if let Some(v156) = v155 {
                                            let v132 = constructor_put_in_xreg(ctx, v129.0);
                                            let v277 = constructor_pulley_xsub64_u8(ctx, v132, v156);
                                            let v278 = constructor_output_xreg(ctx, v277);
                                            let v279 = Some(v278);
                                            // Rule at src/isa/pulley_shared/lower.isle line 335.
                                            return v279;
                                        }
                                        let v150 = C::u64_from_u32(ctx, v149);
                                        if let Some(v151) = v150 {
                                            let v132 = constructor_put_in_xreg(ctx, v129.0);
                                            let v274 = constructor_pulley_xsub64_u32(ctx, v132, v151);
                                            let v275 = constructor_output_xreg(ctx, v274);
                                            let v276 = Some(v275);
                                            // Rule at src/isa/pulley_shared/lower.isle line 333.
                                            return v276;
                                        }
                                    }
                                    let v123 = C::ty_int(ctx, v104);
                                    if let Some(v124) = v123 {
                                        let v140 = C::fits_in_32(ctx, v124);
                                        if let Some(v141) = v140 {
                                            let v149 = C::u64_from_imm64(ctx, v148);
                                            let v155 = C::u64_from_u8(ctx, v149);
                                            if let Some(v156) = v155 {
                                                let v132 = constructor_put_in_xreg(ctx, v129.0);
                                                let v271 = constructor_pulley_xsub32_u8(ctx, v132, v156);
                                                let v272 = constructor_output_xreg(ctx, v271);
                                                let v273 = Some(v272);
                                                // Rule at src/isa/pulley_shared/lower.isle line 331.
                                                return v273;
                                            }
                                            let v150 = C::u64_from_u32(ctx, v149);
                                            if let Some(v151) = v150 {
                                                let v132 = constructor_put_in_xreg(ctx, v129.0);
                                                let v268 = constructor_pulley_xsub32_u32(ctx, v132, v151);
                                                let v269 = constructor_output_xreg(ctx, v268);
                                                let v270 = Some(v269);
                                                // Rule at src/isa/pulley_shared/lower.isle line 329.
                                                return v270;
                                            }
                                        }
                                    }
                                }
                            }
                        }
                        let v104 = C::value_type(ctx, v103);
                        match v104 {
                            I64 => {
                                let v132 = constructor_put_in_xreg(ctx, v129.0);
                                let v133 = constructor_put_in_xreg(ctx, v129.1);
                                let v265 = constructor_pulley_xsub64(ctx, v132, v133);
                                let v266 = constructor_output_xreg(ctx, v265);
                                let v267 = Some(v266);
                                // Rule at src/isa/pulley_shared/lower.isle line 326.
                                return v267;
                            }
                            I128 => {
                                let v182 = C::put_in_regs(ctx, v129.0);
                                let v183 = C::put_in_regs(ctx, v129.1);
                                let v185 = C::value_regs_get(ctx, v182, 0x0_usize);
                                let v186 = C::xreg_new(ctx, v185);
                                let v188 = C::value_regs_get(ctx, v182, 0x1_usize);
                                let v189 = C::xreg_new(ctx, v188);
                                let v190 = C::value_regs_get(ctx, v183, 0x0_usize);
                                let v191 = C::xreg_new(ctx, v190);
                                let v192 = C::value_regs_get(ctx, v183, 0x1_usize);
                                let v193 = C::xreg_new(ctx, v192);
                                let v292 = constructor_pulley_xsub128(ctx, v186, v189, v191, v193);
                                let v293 = C::output(ctx, v292);
                                let v294 = Some(v293);
                                // Rule at src/isa/pulley_shared/lower.isle line 354.
                                return v294;
                            }
                            I8X16 => {
                                let v197 = constructor_put_in_vreg(ctx, v129.0);
                                let v198 = constructor_put_in_vreg(ctx, v129.1);
                                let v295 = constructor_pulley_vsubi8x16(ctx, v197, v198);
                                let v296 = constructor_output_vreg(ctx, v295);
                                let v297 = Some(v296);
                                // Rule at src/isa/pulley_shared/lower.isle line 364.
                                return v297;
                            }
                            I16X8 => {
                                let v197 = constructor_put_in_vreg(ctx, v129.0);
                                let v198 = constructor_put_in_vreg(ctx, v129.1);
                                let v298 = constructor_pulley_vsubi16x8(ctx, v197, v198);
                                let v299 = constructor_output_vreg(ctx, v298);
                                let v300 = Some(v299);
                                // Rule at src/isa/pulley_shared/lower.isle line 365.
                                return v300;
                            }
                            I32X4 => {
                                let v197 = constructor_put_in_vreg(ctx, v129.0);
                                let v198 = constructor_put_in_vreg(ctx, v129.1);
                                let v301 = constructor_pulley_vsubi32x4(ctx, v197, v198);
                                let v302 = constructor_output_vreg(ctx, v301);
                                let v303 = Some(v302);
                                // Rule at src/isa/pulley_shared/lower.isle line 366.
                                return v303;
                            }
                            I64X2 => {
                                let v197 = constructor_put_in_vreg(ctx, v129.0);
                                let v198 = constructor_put_in_vreg(ctx, v129.1);
                                let v304 = constructor_pulley_vsubi64x2(ctx, v197, v198);
                                let v305 = constructor_output_vreg(ctx, v304);
                                let v306 = Some(v305);
                                // Rule at src/isa/pulley_shared/lower.isle line 367.
                                return v306;
                            }
                            _ => {}
                        }
                        let v123 = C::ty_int(ctx, v104);
                        if let Some(v124) = v123 {
                            let v140 = C::fits_in_32(ctx, v124);
                            if let Some(v141) = v140 {
                                let v132 = constructor_put_in_xreg(ctx, v129.0);
                                let v133 = constructor_put_in_xreg(ctx, v129.1);
                                let v262 = constructor_pulley_xsub32(ctx, v132, v133);
                                let v263 = constructor_output_xreg(ctx, v262);
                                let v264 = Some(v263);
                                // Rule at src/isa/pulley_shared/lower.isle line 325.
                                return v264;
                            }
                        }
                    }
                }
                &Opcode::Imul => {
                    let v102 = C::first_result(ctx, arg0);
                    if let Some(v103) = v102 {
                        let v104 = C::value_type(ctx, v103);
                        match v104 {
                            I64 => {
                                let v129 = C::unpack_value_array_2(ctx, v128);
                                let v325 = C::i64_from_iconst(ctx, v129.1);
                                if let Some(v326) = v325 {
                                    let v335 = C::i64_from_i8(ctx, v326);
                                    if let Some(v336) = v335 {
                                        let v132 = constructor_put_in_xreg(ctx, v129.0);
                                        let v340 = constructor_pulley_xmul64_s8(ctx, v132, v336);
                                        let v341 = constructor_output_xreg(ctx, v340);
                                        let v342 = Some(v341);
                                        // Rule at src/isa/pulley_shared/lower.isle line 387.
                                        return v342;
                                    }
                                }
                            }
                            I128 => {
                                let v129 = C::unpack_value_array_2(ctx, v128);
                                let v142 = C::def_inst(ctx, v129.1);
                                if let Some(v143) = v142 {
                                    let v144 = C::inst_data_value(ctx, v143);
                                    if let &InstructionData::Unary {
                                        opcode: ref v345,
                                        arg: v346,
                                    } = &v144.1 {
                                        match v345 {
                                            &Opcode::Uextend => {
                                                let v223 = C::def_inst(ctx, v129.0);
                                                if let Some(v224) = v223 {
                                                    let v225 = C::inst_data_value(ctx, v224);
                                                    if let &InstructionData::Unary {
                                                        opcode: ref v343,
                                                        arg: v344,
                                                    } = &v225.1 {
                                                        if let &Opcode::Uextend = v343 {
                                                            let v347 = constructor_zext64(ctx, v344);
                                                            let v348 = constructor_zext64(ctx, v346);
                                                            let v349 = constructor_pulley_xwidemul64_u(ctx, v347, v348);
                                                            let v350 = C::output(ctx, v349);
                                                            let v351 = Some(v350);
                                                            // Rule at src/isa/pulley_shared/lower.isle line 391.
                                                            return v351;
                                                        }
                                                    }
                                                }
                                            }
                                            &Opcode::Sextend => {
                                                let v223 = C::def_inst(ctx, v129.0);
                                                if let Some(v224) = v223 {
                                                    let v225 = C::inst_data_value(ctx, v224);
                                                    if let &InstructionData::Unary {
                                                        opcode: ref v343,
                                                        arg: v344,
                                                    } = &v225.1 {
                                                        if let &Opcode::Sextend = v343 {
                                                            let v352 = constructor_sext64(ctx, v344);
                                                            let v353 = constructor_sext64(ctx, v346);
                                                            let v354 = constructor_pulley_xwidemul64_s(ctx, v352, v353);
                                                            let v355 = C::output(ctx, v354);
                                                            let v356 = Some(v355);
                                                            // Rule at src/isa/pulley_shared/lower.isle line 393.
                                                            return v356;
                                                        }
                                                    }
                                                }
                                            }
                                            _ => {}
                                        }
                                    }
                                }
                            }
                            _ => {}
                        }
                        let v129 = C::unpack_value_array_2(ctx, v128);
                        let v325 = C::i64_from_iconst(ctx, v129.1);
                        if let Some(v326) = v325 {
                            let v123 = C::ty_int(ctx, v104);
                            if let Some(v124) = v123 {
                                let v140 = C::fits_in_32(ctx, v124);
                                if let Some(v141) = v140 {
                                    let v335 = C::i64_from_i8(ctx, v326);
                                    if let Some(v336) = v335 {
                                        let v132 = constructor_put_in_xreg(ctx, v129.0);
                                        let v337 = constructor_pulley_xmul32_s8(ctx, v132, v336);
                                        let v338 = constructor_output_xreg(ctx, v337);
                                        let v339 = Some(v338);
                                        // Rule at src/isa/pulley_shared/lower.isle line 385.
                                        return v339;
                                    }
                                }
                            }
                            let v327 = C::i64_from_i32(ctx, v326);
                            if let Some(v328) = v327 {
                                if v104 == I64 {
                                    let v132 = constructor_put_in_xreg(ctx, v129.0);
                                    let v332 = constructor_pulley_xmul64_s32(ctx, v132, v328);
                                    let v333 = constructor_output_xreg(ctx, v332);
                                    let v334 = Some(v333);
                                    // Rule at src/isa/pulley_shared/lower.isle line 383.
                                    return v334;
                                }
                                if let Some(v124) = v123 {
                                    let v140 = C::fits_in_32(ctx, v124);
                                    if let Some(v141) = v140 {
                                        let v132 = constructor_put_in_xreg(ctx, v129.0);
                                        let v329 = constructor_pulley_xmul32_s32(ctx, v132, v328);
                                        let v330 = constructor_output_xreg(ctx, v329);
                                        let v331 = Some(v330);
                                        // Rule at src/isa/pulley_shared/lower.isle line 381.
                                        return v331;
                                    }
                                }
                            }
                        }
                        match v104 {
                            I8 => {
                                let v132 = constructor_put_in_xreg(ctx, v129.0);
                                let v133 = constructor_put_in_xreg(ctx, v129.1);
                                let v319 = constructor_pulley_xmul32(ctx, v132, v133);
                                let v320 = constructor_output_xreg(ctx, v319);
                                let v321 = Some(v320);
                                // Rule at src/isa/pulley_shared/lower.isle line 376.
                                return v321;
                            }
                            I16 => {
                                let v132 = constructor_put_in_xreg(ctx, v129.0);
                                let v133 = constructor_put_in_xreg(ctx, v129.1);
                                let v319 = constructor_pulley_xmul32(ctx, v132, v133);
                                let v320 = constructor_output_xreg(ctx, v319);
                                let v321 = Some(v320);
                                // Rule at src/isa/pulley_shared/lower.isle line 377.
                                return v321;
                            }
                            I32 => {
                                let v132 = constructor_put_in_xreg(ctx, v129.0);
                                let v133 = constructor_put_in_xreg(ctx, v129.1);
                                let v319 = constructor_pulley_xmul32(ctx, v132, v133);
                                let v320 = constructor_output_xreg(ctx, v319);
                                let v321 = Some(v320);
                                // Rule at src/isa/pulley_shared/lower.isle line 378.
                                return v321;
                            }
                            I64 => {
                                let v132 = constructor_put_in_xreg(ctx, v129.0);
                                let v133 = constructor_put_in_xreg(ctx, v129.1);
                                let v322 = constructor_pulley_xmul64(ctx, v132, v133);
                                let v323 = constructor_output_xreg(ctx, v322);
                                let v324 = Some(v323);
                                // Rule at src/isa/pulley_shared/lower.isle line 379.
                                return v324;
                            }
                            I128 => {
                                let v182 = C::put_in_regs(ctx, v129.0);
                                let v357 = C::value_regs_get(ctx, v182, 0x0_usize);
                                let v358 = C::xreg_new(ctx, v357);
                                let v359 = C::value_regs_get(ctx, v182, 0x1_usize);
                                let v360 = C::xreg_new(ctx, v359);
                                let v361 = C::put_in_regs(ctx, v129.1);
                                let v362 = C::value_regs_get(ctx, v361, 0x0_usize);
                                let v363 = C::xreg_new(ctx, v362);
                                let v364 = C::value_regs_get(ctx, v361, 0x1_usize);
                                let v365 = C::xreg_new(ctx, v364);
                                let v366 = constructor_pulley_xwidemul64_u(ctx, v358, v363);
                                let v367 = C::value_regs_get(ctx, v366, 0x0_usize);
                                let v368 = C::xreg_new(ctx, v367);
                                let v369 = C::value_regs_get(ctx, v366, 0x1_usize);
                                let v370 = C::xreg_new(ctx, v369);
                                let v371 = constructor_pulley_xmul64(ctx, v358, v365);
                                let v372 = constructor_pulley_xmul64(ctx, v360, v363);
                                let v373 = constructor_pulley_xadd64(ctx, v370, v371);
                                let v374 = constructor_pulley_xadd64(ctx, v373, v372);
                                let v375 = C::xreg_to_reg(ctx, v368);
                                let v376 = C::xreg_to_reg(ctx, v374);
                                let v377 = C::value_regs(ctx, v375, v376);
                                let v378 = C::output(ctx, v377);
                                let v379 = Some(v378);
                                // Rule at src/isa/pulley_shared/lower.isle line 397.
                                return v379;
                            }
                            I8X16 => {
                                let v197 = constructor_put_in_vreg(ctx, v129.0);
                                let v198 = constructor_put_in_vreg(ctx, v129.1);
                                let v380 = constructor_pulley_vmuli8x16(ctx, v197, v198);
                                let v381 = constructor_output_vreg(ctx, v380);
                                let v382 = Some(v381);
                                // Rule at src/isa/pulley_shared/lower.isle line 422.
                                return v382;
                            }
                            I16X8 => {
                                let v197 = constructor_put_in_vreg(ctx, v129.0);
                                let v198 = constructor_put_in_vreg(ctx, v129.1);
                                let v383 = constructor_pulley_vmuli16x8(ctx, v197, v198);
                                let v384 = constructor_output_vreg(ctx, v383);
                                let v385 = Some(v384);
                                // Rule at src/isa/pulley_shared/lower.isle line 423.
                                return v385;
                            }
                            I32X4 => {
                                let v197 = constructor_put_in_vreg(ctx, v129.0);
                                let v198 = constructor_put_in_vreg(ctx, v129.1);
                                let v386 = constructor_pulley_vmuli32x4(ctx, v197, v198);
                                let v387 = constructor_output_vreg(ctx, v386);
                                let v388 = Some(v387);
                                // Rule at src/isa/pulley_shared/lower.isle line 424.
                                return v388;
                            }
                            I64X2 => {
                                let v197 = constructor_put_in_vreg(ctx, v129.0);
                                let v198 = constructor_put_in_vreg(ctx, v129.1);
                                let v389 = constructor_pulley_vmuli64x2(ctx, v197, v198);
                                let v390 = constructor_output_vreg(ctx, v389);
                                let v391 = Some(v390);
                                // Rule at src/isa/pulley_shared/lower.isle line 425.
                                return v391;
                            }
                            _ => {}
                        }
                    }
                }
                &Opcode::Umulhi => {
                    let v102 = C::first_result(ctx, arg0);
                    if let Some(v103) = v102 {
                        let v104 = C::value_type(ctx, v103);
                        match v104 {
                            I8 => {
                                let v393 = C::u64_try_into_u8(ctx, 0x8_u64);
                                if let Some(v394) = v393 {
                                    let v395 = C::u6_from_u8(ctx, v394);
                                    if let Some(v396) = v395 {
                                        let v129 = C::unpack_value_array_2(ctx, v128);
                                        let v397 = constructor_zext32(ctx, v129.0);
                                        let v398 = constructor_zext32(ctx, v129.1);
                                        let v399 = constructor_pulley_xmul32(ctx, v397, v398);
                                        let v400 = constructor_pulley_xshr32_u_u6(ctx, v399, v396);
                                        let v401 = constructor_output_xreg(ctx, v400);
                                        let v402 = Some(v401);
                                        // Rule at src/isa/pulley_shared/lower.isle line 429.
                                        return v402;
                                    }
                                }
                            }
                            I16 => {
                                let v404 = C::u64_try_into_u8(ctx, 0x10_u64);
                                if let Some(v405) = v404 {
                                    let v406 = C::u6_from_u8(ctx, v405);
                                    if let Some(v407) = v406 {
                                        let v129 = C::unpack_value_array_2(ctx, v128);
                                        let v397 = constructor_zext32(ctx, v129.0);
                                        let v398 = constructor_zext32(ctx, v129.1);
                                        let v399 = constructor_pulley_xmul32(ctx, v397, v398);
                                        let v408 = constructor_pulley_xshr32_u_u6(ctx, v399, v407);
                                        let v409 = constructor_output_xreg(ctx, v408);
                                        let v410 = Some(v409);
                                        // Rule at src/isa/pulley_shared/lower.isle line 433.
                                        return v410;
                                    }
                                }
                            }
                            I32 => {
                                let v412 = C::u64_try_into_u8(ctx, 0x20_u64);
                                if let Some(v413) = v412 {
                                    let v414 = C::u6_from_u8(ctx, v413);
                                    if let Some(v415) = v414 {
                                        let v129 = C::unpack_value_array_2(ctx, v128);
                                        let v416 = constructor_zext64(ctx, v129.0);
                                        let v417 = constructor_zext64(ctx, v129.1);
                                        let v418 = constructor_pulley_xmul64(ctx, v416, v417);
                                        let v419 = constructor_pulley_xshr64_u_u6(ctx, v418, v415);
                                        let v420 = constructor_output_xreg(ctx, v419);
                                        let v421 = Some(v420);
                                        // Rule at src/isa/pulley_shared/lower.isle line 437.
                                        return v421;
                                    }
                                }
                            }
                            I64 => {
                                let v129 = C::unpack_value_array_2(ctx, v128);
                                let v132 = constructor_put_in_xreg(ctx, v129.0);
                                let v133 = constructor_put_in_xreg(ctx, v129.1);
                                let v422 = constructor_pulley_xmulhi64_u(ctx, v132, v133);
                                let v423 = constructor_output_xreg(ctx, v422);
                                let v424 = Some(v423);
                                // Rule at src/isa/pulley_shared/lower.isle line 441.
                                return v424;
                            }
                            _ => {}
                        }
                    }
                }
                &Opcode::Smulhi => {
                    let v102 = C::first_result(ctx, arg0);
                    if let Some(v103) = v102 {
                        let v104 = C::value_type(ctx, v103);
                        match v104 {
                            I8 => {
                                let v393 = C::u64_try_into_u8(ctx, 0x8_u64);
                                if let Some(v394) = v393 {
                                    let v395 = C::u6_from_u8(ctx, v394);
                                    if let Some(v396) = v395 {
                                        let v129 = C::unpack_value_array_2(ctx, v128);
                                        let v425 = constructor_sext32(ctx, v129.0);
                                        let v426 = constructor_sext32(ctx, v129.1);
                                        let v427 = constructor_pulley_xmul32(ctx, v425, v426);
                                        let v428 = constructor_pulley_xshr32_s_u6(ctx, v427, v396);
                                        let v429 = constructor_output_xreg(ctx, v428);
                                        let v430 = Some(v429);
                                        // Rule at src/isa/pulley_shared/lower.isle line 446.
                                        return v430;
                                    }
                                }
                            }
                            I16 => {
                                let v404 = C::u64_try_into_u8(ctx, 0x10_u64);
                                if let Some(v405) = v404 {
                                    let v406 = C::u6_from_u8(ctx, v405);
                                    if let Some(v407) = v406 {
                                        let v129 = C::unpack_value_array_2(ctx, v128);
                                        let v425 = constructor_sext32(ctx, v129.0);
                                        let v426 = constructor_sext32(ctx, v129.1);
                                        let v427 = constructor_pulley_xmul32(ctx, v425, v426);
                                        let v431 = constructor_pulley_xshr32_s_u6(ctx, v427, v407);
                                        let v432 = constructor_output_xreg(ctx, v431);
                                        let v433 = Some(v432);
                                        // Rule at src/isa/pulley_shared/lower.isle line 450.
                                        return v433;
                                    }
                                }
                            }
                            I32 => {
                                let v412 = C::u64_try_into_u8(ctx, 0x20_u64);
                                if let Some(v413) = v412 {
                                    let v414 = C::u6_from_u8(ctx, v413);
                                    if let Some(v415) = v414 {
                                        let v129 = C::unpack_value_array_2(ctx, v128);
                                        let v434 = constructor_sext64(ctx, v129.0);
                                        let v435 = constructor_sext64(ctx, v129.1);
                                        let v436 = constructor_pulley_xmul64(ctx, v434, v435);
                                        let v437 = constructor_pulley_xshr64_s_u6(ctx, v436, v415);
                                        let v438 = constructor_output_xreg(ctx, v437);
                                        let v439 = Some(v438);
                                        // Rule at src/isa/pulley_shared/lower.isle line 454.
                                        return v439;
                                    }
                                }
                            }
                            I64 => {
                                let v129 = C::unpack_value_array_2(ctx, v128);
                                let v132 = constructor_put_in_xreg(ctx, v129.0);
                                let v133 = constructor_put_in_xreg(ctx, v129.1);
                                let v440 = constructor_pulley_xmulhi64_s(ctx, v132, v133);
                                let v441 = constructor_output_xreg(ctx, v440);
                                let v442 = Some(v441);
                                // Rule at src/isa/pulley_shared/lower.isle line 458.
                                return v442;
                            }
                            _ => {}
                        }
                    }
                }
                &Opcode::SqmulRoundSat => {
                    let v102 = C::first_result(ctx, arg0);
                    if let Some(v103) = v102 {
                        let v104 = C::value_type(ctx, v103);
                        if v104 == I16X8 {
                            let v129 = C::unpack_value_array_2(ctx, v128);
                            let v197 = constructor_put_in_vreg(ctx, v129.0);
                            let v198 = constructor_put_in_vreg(ctx, v129.1);
                            let v443 = constructor_pulley_vqmulrsi16x8(ctx, v197, v198);
                            let v444 = constructor_output_vreg(ctx, v443);
                            let v445 = Some(v444);
                            // Rule at src/isa/pulley_shared/lower.isle line 463.
                            return v445;
                        }
                    }
                }
                &Opcode::Udiv => {
                    let v102 = C::first_result(ctx, arg0);
                    if let Some(v103) = v102 {
                        let v104 = C::value_type(ctx, v103);
                        if v104 == I64 {
                            let v129 = C::unpack_value_array_2(ctx, v128);
                            let v132 = constructor_put_in_xreg(ctx, v129.0);
                            let v133 = constructor_put_in_xreg(ctx, v129.1);
                            let v463 = constructor_pulley_xdiv64_u(ctx, v132, v133);
                            let v464 = constructor_output_xreg(ctx, v463);
                            let v465 = Some(v464);
                            // Rule at src/isa/pulley_shared/lower.isle line 481.
                            return v465;
                        }
                        let v123 = C::ty_int(ctx, v104);
                        if let Some(v124) = v123 {
                            let v140 = C::fits_in_32(ctx, v124);
                            if let Some(v141) = v140 {
                                let v129 = C::unpack_value_array_2(ctx, v128);
                                let v397 = constructor_zext32(ctx, v129.0);
                                let v398 = constructor_zext32(ctx, v129.1);
                                let v460 = constructor_pulley_xdiv32_u(ctx, v397, v398);
                                let v461 = constructor_output_xreg(ctx, v460);
                                let v462 = Some(v461);
                                // Rule at src/isa/pulley_shared/lower.isle line 479.
                                return v462;
                            }
                        }
                    }
                }
                &Opcode::Sdiv => {
                    let v102 = C::first_result(ctx, arg0);
                    if let Some(v103) = v102 {
                        let v104 = C::value_type(ctx, v103);
                        if v104 == I64 {
                            let v129 = C::unpack_value_array_2(ctx, v128);
                            let v132 = constructor_put_in_xreg(ctx, v129.0);
                            let v133 = constructor_put_in_xreg(ctx, v129.1);
                            let v451 = constructor_pulley_xdiv64_s(ctx, v132, v133);
                            let v452 = constructor_output_xreg(ctx, v451);
                            let v453 = Some(v452);
                            // Rule at src/isa/pulley_shared/lower.isle line 469.
                            return v453;
                        }
                        let v446 = C::fits_in_32(ctx, v104);
                        if let Some(v447) = v446 {
                            let v129 = C::unpack_value_array_2(ctx, v128);
                            let v425 = constructor_sext32(ctx, v129.0);
                            let v426 = constructor_sext32(ctx, v129.1);
                            let v448 = constructor_pulley_xdiv32_s(ctx, v425, v426);
                            let v449 = constructor_output_xreg(ctx, v448);
                            let v450 = Some(v449);
                            // Rule at src/isa/pulley_shared/lower.isle line 467.
                            return v450;
                        }
                    }
                }
                &Opcode::Urem => {
                    let v102 = C::first_result(ctx, arg0);
                    if let Some(v103) = v102 {
                        let v104 = C::value_type(ctx, v103);
                        if v104 == I64 {
                            let v129 = C::unpack_value_array_2(ctx, v128);
                            let v132 = constructor_put_in_xreg(ctx, v129.0);
                            let v133 = constructor_put_in_xreg(ctx, v129.1);
                            let v469 = constructor_pulley_xrem64_u(ctx, v132, v133);
                            let v470 = constructor_output_xreg(ctx, v469);
                            let v471 = Some(v470);
                            // Rule at src/isa/pulley_shared/lower.isle line 487.
                            return v471;
                        }
                        let v123 = C::ty_int(ctx, v104);
                        if let Some(v124) = v123 {
                            let v140 = C::fits_in_32(ctx, v124);
                            if let Some(v141) = v140 {
                                let v129 = C::unpack_value_array_2(ctx, v128);
                                let v397 = constructor_zext32(ctx, v129.0);
                                let v398 = constructor_zext32(ctx, v129.1);
                                let v466 = constructor_pulley_xrem32_u(ctx, v397, v398);
                                let v467 = constructor_output_xreg(ctx, v466);
                                let v468 = Some(v467);
                                // Rule at src/isa/pulley_shared/lower.isle line 485.
                                return v468;
                            }
                        }
                    }
                }
                &Opcode::Srem => {
                    let v102 = C::first_result(ctx, arg0);
                    if let Some(v103) = v102 {
                        let v104 = C::value_type(ctx, v103);
                        if v104 == I64 {
                            let v129 = C::unpack_value_array_2(ctx, v128);
                            let v132 = constructor_put_in_xreg(ctx, v129.0);
                            let v133 = constructor_put_in_xreg(ctx, v129.1);
                            let v457 = constructor_pulley_xrem64_s(ctx, v132, v133);
                            let v458 = constructor_output_xreg(ctx, v457);
                            let v459 = Some(v458);
                            // Rule at src/isa/pulley_shared/lower.isle line 475.
                            return v459;
                        }
                        let v446 = C::fits_in_32(ctx, v104);
                        if let Some(v447) = v446 {
                            let v129 = C::unpack_value_array_2(ctx, v128);
                            let v425 = constructor_sext32(ctx, v129.0);
                            let v426 = constructor_sext32(ctx, v129.1);
                            let v454 = constructor_pulley_xrem32_s(ctx, v425, v426);
                            let v455 = constructor_output_xreg(ctx, v454);
                            let v456 = Some(v455);
                            // Rule at src/isa/pulley_shared/lower.isle line 473.
                            return v456;
                        }
                    }
                }
                &Opcode::UaddOverflow => {
                    let v102 = C::first_result(ctx, arg0);
                    if let Some(v103) = v102 {
                        let v104 = C::value_type(ctx, v103);
                        match v104 {
                            I32 => {
                                let v129 = C::unpack_value_array_2(ctx, v128);
                                let v132 = constructor_put_in_xreg(ctx, v129.0);
                                let v133 = constructor_put_in_xreg(ctx, v129.1);
                                let v134 = constructor_pulley_xadd32(ctx, v132, v133);
                                let v1039 = constructor_put_in_xreg(ctx, v129.0);
                                let v1040 = constructor_pulley_xult32(ctx, v134, v1039);
                                let v1041 = C::xreg_to_reg(ctx, v134);
                                let v1042 = C::value_reg(ctx, v1041);
                                let v1043 = C::xreg_to_reg(ctx, v1040);
                                let v1044 = C::value_reg(ctx, v1043);
                                let v1045 = C::output_pair(ctx, v1042, v1044);
                                let v1046 = Some(v1045);
                                // Rule at src/isa/pulley_shared/lower.isle line 1419.
                                return v1046;
                            }
                            I64 => {
                                let v129 = C::unpack_value_array_2(ctx, v128);
                                let v132 = constructor_put_in_xreg(ctx, v129.0);
                                let v133 = constructor_put_in_xreg(ctx, v129.1);
                                let v137 = constructor_pulley_xadd64(ctx, v132, v133);
                                let v1039 = constructor_put_in_xreg(ctx, v129.0);
                                let v1047 = constructor_pulley_xult64(ctx, v137, v1039);
                                let v1048 = C::xreg_to_reg(ctx, v137);
                                let v1049 = C::value_reg(ctx, v1048);
                                let v1050 = C::xreg_to_reg(ctx, v1047);
                                let v1051 = C::value_reg(ctx, v1050);
                                let v1052 = C::output_pair(ctx, v1049, v1051);
                                let v1053 = Some(v1052);
                                // Rule at src/isa/pulley_shared/lower.isle line 1424.
                                return v1053;
                            }
                            _ => {}
                        }
                    }
                }
                &Opcode::Band => {
                    let v102 = C::first_result(ctx, arg0);
                    if let Some(v103) = v102 {
                        let v129 = C::unpack_value_array_2(ctx, v128);
                        let v325 = C::i64_from_iconst(ctx, v129.1);
                        if let Some(v326) = v325 {
                            let v335 = C::i64_from_i8(ctx, v326);
                            if let Some(v336) = v335 {
                                let v104 = C::value_type(ctx, v103);
                                if v104 == I64 {
                                    let v132 = constructor_put_in_xreg(ctx, v129.0);
                                    let v589 = constructor_pulley_xband64_s8(ctx, v132, v336);
                                    let v590 = constructor_output_xreg(ctx, v589);
                                    let v591 = Some(v590);
                                    // Rule at src/isa/pulley_shared/lower.isle line 602.
                                    return v591;
                                }
                                let v123 = C::ty_int(ctx, v104);
                                if let Some(v124) = v123 {
                                    let v140 = C::fits_in_32(ctx, v124);
                                    if let Some(v141) = v140 {
                                        let v132 = constructor_put_in_xreg(ctx, v129.0);
                                        let v586 = constructor_pulley_xband32_s8(ctx, v132, v336);
                                        let v587 = constructor_output_xreg(ctx, v586);
                                        let v588 = Some(v587);
                                        // Rule at src/isa/pulley_shared/lower.isle line 600.
                                        return v588;
                                    }
                                }
                            }
                            let v327 = C::i64_from_i32(ctx, v326);
                            if let Some(v328) = v327 {
                                let v104 = C::value_type(ctx, v103);
                                if v104 == I64 {
                                    let v132 = constructor_put_in_xreg(ctx, v129.0);
                                    let v583 = constructor_pulley_xband64_s32(ctx, v132, v328);
                                    let v584 = constructor_output_xreg(ctx, v583);
                                    let v585 = Some(v584);
                                    // Rule at src/isa/pulley_shared/lower.isle line 598.
                                    return v585;
                                }
                                let v123 = C::ty_int(ctx, v104);
                                if let Some(v124) = v123 {
                                    let v140 = C::fits_in_32(ctx, v124);
                                    if let Some(v141) = v140 {
                                        let v132 = constructor_put_in_xreg(ctx, v129.0);
                                        let v580 = constructor_pulley_xband32_s32(ctx, v132, v328);
                                        let v581 = constructor_output_xreg(ctx, v580);
                                        let v582 = Some(v581);
                                        // Rule at src/isa/pulley_shared/lower.isle line 596.
                                        return v582;
                                    }
                                }
                            }
                        }
                        let v104 = C::value_type(ctx, v103);
                        let v592 = C::ty_vec128(ctx, v104);
                        if let Some(v593) = v592 {
                            let v197 = constructor_put_in_vreg(ctx, v129.0);
                            let v198 = constructor_put_in_vreg(ctx, v129.1);
                            let v594 = constructor_pulley_vband128(ctx, v197, v198);
                            let v595 = constructor_output_vreg(ctx, v594);
                            let v596 = Some(v595);
                            // Rule at src/isa/pulley_shared/lower.isle line 605.
                            return v596;
                        }
                        if v104 == I64 {
                            let v132 = constructor_put_in_xreg(ctx, v129.0);
                            let v133 = constructor_put_in_xreg(ctx, v129.1);
                            let v577 = constructor_pulley_xband64(ctx, v132, v133);
                            let v578 = constructor_output_xreg(ctx, v577);
                            let v579 = Some(v578);
                            // Rule at src/isa/pulley_shared/lower.isle line 594.
                            return v579;
                        }
                        let v446 = C::fits_in_32(ctx, v104);
                        if let Some(v447) = v446 {
                            let v132 = constructor_put_in_xreg(ctx, v129.0);
                            let v133 = constructor_put_in_xreg(ctx, v129.1);
                            let v574 = constructor_pulley_xband32(ctx, v132, v133);
                            let v575 = constructor_output_xreg(ctx, v574);
                            let v576 = Some(v575);
                            // Rule at src/isa/pulley_shared/lower.isle line 593.
                            return v576;
                        }
                    }
                }
                &Opcode::Bor => {
                    let v102 = C::first_result(ctx, arg0);
                    if let Some(v103) = v102 {
                        let v129 = C::unpack_value_array_2(ctx, v128);
                        let v325 = C::i64_from_iconst(ctx, v129.1);
                        if let Some(v326) = v325 {
                            let v335 = C::i64_from_i8(ctx, v326);
                            if let Some(v336) = v335 {
                                let v104 = C::value_type(ctx, v103);
                                if v104 == I64 {
                                    let v132 = constructor_put_in_xreg(ctx, v129.0);
                                    let v612 = constructor_pulley_xbor64_s8(ctx, v132, v336);
                                    let v613 = constructor_output_xreg(ctx, v612);
                                    let v614 = Some(v613);
                                    // Rule at src/isa/pulley_shared/lower.isle line 619.
                                    return v614;
                                }
                                let v123 = C::ty_int(ctx, v104);
                                if let Some(v124) = v123 {
                                    let v140 = C::fits_in_32(ctx, v124);
                                    if let Some(v141) = v140 {
                                        let v132 = constructor_put_in_xreg(ctx, v129.0);
                                        let v609 = constructor_pulley_xbor32_s8(ctx, v132, v336);
                                        let v610 = constructor_output_xreg(ctx, v609);
                                        let v611 = Some(v610);
                                        // Rule at src/isa/pulley_shared/lower.isle line 617.
                                        return v611;
                                    }
                                }
                            }
                            let v327 = C::i64_from_i32(ctx, v326);
                            if let Some(v328) = v327 {
                                let v104 = C::value_type(ctx, v103);
                                if v104 == I64 {
                                    let v132 = constructor_put_in_xreg(ctx, v129.0);
                                    let v606 = constructor_pulley_xbor64_s32(ctx, v132, v328);
                                    let v607 = constructor_output_xreg(ctx, v606);
                                    let v608 = Some(v607);
                                    // Rule at src/isa/pulley_shared/lower.isle line 615.
                                    return v608;
                                }
                                let v123 = C::ty_int(ctx, v104);
                                if let Some(v124) = v123 {
                                    let v140 = C::fits_in_32(ctx, v124);
                                    if let Some(v141) = v140 {
                                        let v132 = constructor_put_in_xreg(ctx, v129.0);
                                        let v603 = constructor_pulley_xbor32_s32(ctx, v132, v328);
                                        let v604 = constructor_output_xreg(ctx, v603);
                                        let v605 = Some(v604);
                                        // Rule at src/isa/pulley_shared/lower.isle line 613.
                                        return v605;
                                    }
                                }
                            }
                        }
                        let v104 = C::value_type(ctx, v103);
                        let v592 = C::ty_vec128(ctx, v104);
                        if let Some(v593) = v592 {
                            let v197 = constructor_put_in_vreg(ctx, v129.0);
                            let v198 = constructor_put_in_vreg(ctx, v129.1);
                            let v615 = constructor_pulley_vbor128(ctx, v197, v198);
                            let v616 = constructor_output_vreg(ctx, v615);
                            let v617 = Some(v616);
                            // Rule at src/isa/pulley_shared/lower.isle line 622.
                            return v617;
                        }
                        if v104 == I64 {
                            let v132 = constructor_put_in_xreg(ctx, v129.0);
                            let v133 = constructor_put_in_xreg(ctx, v129.1);
                            let v600 = constructor_pulley_xbor64(ctx, v132, v133);
                            let v601 = constructor_output_xreg(ctx, v600);
                            let v602 = Some(v601);
                            // Rule at src/isa/pulley_shared/lower.isle line 611.
                            return v602;
                        }
                        let v446 = C::fits_in_32(ctx, v104);
                        if let Some(v447) = v446 {
                            let v132 = constructor_put_in_xreg(ctx, v129.0);
                            let v133 = constructor_put_in_xreg(ctx, v129.1);
                            let v597 = constructor_pulley_xbor32(ctx, v132, v133);
                            let v598 = constructor_output_xreg(ctx, v597);
                            let v599 = Some(v598);
                            // Rule at src/isa/pulley_shared/lower.isle line 610.
                            return v599;
                        }
                    }
                }
                &Opcode::Bxor => {
                    let v102 = C::first_result(ctx, arg0);
                    if let Some(v103) = v102 {
                        let v129 = C::unpack_value_array_2(ctx, v128);
                        let v325 = C::i64_from_iconst(ctx, v129.1);
                        if let Some(v326) = v325 {
                            let v335 = C::i64_from_i8(ctx, v326);
                            if let Some(v336) = v335 {
                                let v104 = C::value_type(ctx, v103);
                                if v104 == I64 {
                                    let v132 = constructor_put_in_xreg(ctx, v129.0);
                                    let v633 = constructor_pulley_xbxor64_s8(ctx, v132, v336);
                                    let v634 = constructor_output_xreg(ctx, v633);
                                    let v635 = Some(v634);
                                    // Rule at src/isa/pulley_shared/lower.isle line 636.
                                    return v635;
                                }
                                let v123 = C::ty_int(ctx, v104);
                                if let Some(v124) = v123 {
                                    let v140 = C::fits_in_32(ctx, v124);
                                    if let Some(v141) = v140 {
                                        let v132 = constructor_put_in_xreg(ctx, v129.0);
                                        let v630 = constructor_pulley_xbxor32_s8(ctx, v132, v336);
                                        let v631 = constructor_output_xreg(ctx, v630);
                                        let v632 = Some(v631);
                                        // Rule at src/isa/pulley_shared/lower.isle line 634.
                                        return v632;
                                    }
                                }
                            }
                            let v327 = C::i64_from_i32(ctx, v326);
                            if let Some(v328) = v327 {
                                let v104 = C::value_type(ctx, v103);
                                if v104 == I64 {
                                    let v132 = constructor_put_in_xreg(ctx, v129.0);
                                    let v627 = constructor_pulley_xbxor64_s32(ctx, v132, v328);
                                    let v628 = constructor_output_xreg(ctx, v627);
                                    let v629 = Some(v628);
                                    // Rule at src/isa/pulley_shared/lower.isle line 632.
                                    return v629;
                                }
                                let v123 = C::ty_int(ctx, v104);
                                if let Some(v124) = v123 {
                                    let v140 = C::fits_in_32(ctx, v124);
                                    if let Some(v141) = v140 {
                                        let v132 = constructor_put_in_xreg(ctx, v129.0);
                                        let v624 = constructor_pulley_xbxor32_s32(ctx, v132, v328);
                                        let v625 = constructor_output_xreg(ctx, v624);
                                        let v626 = Some(v625);
                                        // Rule at src/isa/pulley_shared/lower.isle line 630.
                                        return v626;
                                    }
                                }
                            }
                        }
                        let v104 = C::value_type(ctx, v103);
                        let v592 = C::ty_vec128(ctx, v104);
                        if let Some(v593) = v592 {
                            let v197 = constructor_put_in_vreg(ctx, v129.0);
                            let v198 = constructor_put_in_vreg(ctx, v129.1);
                            let v636 = constructor_pulley_vbxor128(ctx, v197, v198);
                            let v637 = constructor_output_vreg(ctx, v636);
                            let v638 = Some(v637);
                            // Rule at src/isa/pulley_shared/lower.isle line 639.
                            return v638;
                        }
                        if v104 == I64 {
                            let v132 = constructor_put_in_xreg(ctx, v129.0);
                            let v133 = constructor_put_in_xreg(ctx, v129.1);
                            let v621 = constructor_pulley_xbxor64(ctx, v132, v133);
                            let v622 = constructor_output_xreg(ctx, v621);
                            let v623 = Some(v622);
                            // Rule at src/isa/pulley_shared/lower.isle line 628.
                            return v623;
                        }
                        let v446 = C::fits_in_32(ctx, v104);
                        if let Some(v447) = v446 {
                            let v132 = constructor_put_in_xreg(ctx, v129.0);
                            let v133 = constructor_put_in_xreg(ctx, v129.1);
                            let v618 = constructor_pulley_xbxor32(ctx, v132, v133);
                            let v619 = constructor_output_xreg(ctx, v618);
                            let v620 = Some(v619);
                            // Rule at src/isa/pulley_shared/lower.isle line 627.
                            return v620;
                        }
                    }
                }
                &Opcode::Rotl => {
                    let v102 = C::first_result(ctx, arg0);
                    if let Some(v103) = v102 {
                        let v104 = C::value_type(ctx, v103);
                        match v104 {
                            I32 => {
                                let v129 = C::unpack_value_array_2(ctx, v128);
                                let v132 = constructor_put_in_xreg(ctx, v129.0);
                                let v133 = constructor_put_in_xreg(ctx, v129.1);
                                let v778 = constructor_pulley_xrotl32(ctx, v132, v133);
                                let v779 = constructor_output_xreg(ctx, v778);
                                let v780 = Some(v779);
                                // Rule at src/isa/pulley_shared/lower.isle line 729.
                                return v780;
                            }
                            I64 => {
                                let v129 = C::unpack_value_array_2(ctx, v128);
                                let v132 = constructor_put_in_xreg(ctx, v129.0);
                                let v133 = constructor_put_in_xreg(ctx, v129.1);
                                let v781 = constructor_pulley_xrotl64(ctx, v132, v133);
                                let v782 = constructor_output_xreg(ctx, v781);
                                let v783 = Some(v782);
                                // Rule at src/isa/pulley_shared/lower.isle line 730.
                                return v783;
                            }
                            _ => {}
                        }
                    }
                }
                &Opcode::Rotr => {
                    let v102 = C::first_result(ctx, arg0);
                    if let Some(v103) = v102 {
                        let v104 = C::value_type(ctx, v103);
                        match v104 {
                            I32 => {
                                let v129 = C::unpack_value_array_2(ctx, v128);
                                let v132 = constructor_put_in_xreg(ctx, v129.0);
                                let v133 = constructor_put_in_xreg(ctx, v129.1);
                                let v784 = constructor_pulley_xrotr32(ctx, v132, v133);
                                let v785 = constructor_output_xreg(ctx, v784);
                                let v786 = Some(v785);
                                // Rule at src/isa/pulley_shared/lower.isle line 734.
                                return v786;
                            }
                            I64 => {
                                let v129 = C::unpack_value_array_2(ctx, v128);
                                let v132 = constructor_put_in_xreg(ctx, v129.0);
                                let v133 = constructor_put_in_xreg(ctx, v129.1);
                                let v787 = constructor_pulley_xrotr64(ctx, v132, v133);
                                let v788 = constructor_output_xreg(ctx, v787);
                                let v789 = Some(v788);
                                // Rule at src/isa/pulley_shared/lower.isle line 735.
                                return v789;
                            }
                            _ => {}
                        }
                    }
                }
                &Opcode::Ishl => {
                    let v102 = C::first_result(ctx, arg0);
                    if let Some(v103) = v102 {
                        let v104 = C::value_type(ctx, v103);
                        match v104 {
                            I8 => {
                                let v129 = C::unpack_value_array_2(ctx, v128);
                                let v132 = constructor_put_in_xreg(ctx, v129.0);
                                let v133 = constructor_put_in_xreg(ctx, v129.1);
                                let v479 = constructor_pulley_xband32_s8(ctx, v133, 7_i8);
                                let v480 = constructor_pulley_xshl32(ctx, v132, v479);
                                let v481 = constructor_output_xreg(ctx, v480);
                                let v482 = Some(v481);
                                // Rule at src/isa/pulley_shared/lower.isle line 496.
                                return v482;
                            }
                            I16 => {
                                let v129 = C::unpack_value_array_2(ctx, v128);
                                let v132 = constructor_put_in_xreg(ctx, v129.0);
                                let v133 = constructor_put_in_xreg(ctx, v129.1);
                                let v484 = constructor_pulley_xband32_s8(ctx, v133, 15_i8);
                                let v485 = constructor_pulley_xshl32(ctx, v132, v484);
                                let v486 = constructor_output_xreg(ctx, v485);
                                let v487 = Some(v486);
                                // Rule at src/isa/pulley_shared/lower.isle line 499.
                                return v487;
                            }
                            I32 => {
                                let v129 = C::unpack_value_array_2(ctx, v128);
                                let v494 = constructor_u6_shift_from_iconst(ctx, v129.1);
                                if let Some(v495) = v494 {
                                    let v132 = constructor_put_in_xreg(ctx, v129.0);
                                    let v496 = constructor_pulley_xshl32_u6(ctx, v132, v495);
                                    let v497 = constructor_output_xreg(ctx, v496);
                                    let v498 = Some(v497);
                                    // Rule at src/isa/pulley_shared/lower.isle line 509.
                                    return v498;
                                }
                                let v132 = constructor_put_in_xreg(ctx, v129.0);
                                let v133 = constructor_put_in_xreg(ctx, v129.1);
                                let v488 = constructor_pulley_xshl32(ctx, v132, v133);
                                let v489 = constructor_output_xreg(ctx, v488);
                                let v490 = Some(v489);
                                // Rule at src/isa/pulley_shared/lower.isle line 502.
                                return v490;
                            }
                            I64 => {
                                let v129 = C::unpack_value_array_2(ctx, v128);
                                let v494 = constructor_u6_shift_from_iconst(ctx, v129.1);
                                if let Some(v495) = v494 {
                                    let v132 = constructor_put_in_xreg(ctx, v129.0);
                                    let v499 = constructor_pulley_xshl64_u6(ctx, v132, v495);
                                    let v500 = constructor_output_xreg(ctx, v499);
                                    let v501 = Some(v500);
                                    // Rule at src/isa/pulley_shared/lower.isle line 512.
                                    return v501;
                                }
                                let v132 = constructor_put_in_xreg(ctx, v129.0);
                                let v133 = constructor_put_in_xreg(ctx, v129.1);
                                let v491 = constructor_pulley_xshl64(ctx, v132, v133);
                                let v492 = constructor_output_xreg(ctx, v491);
                                let v493 = Some(v492);
                                // Rule at src/isa/pulley_shared/lower.isle line 505.
                                return v493;
                            }
                            I8X16 => {
                                let v129 = C::unpack_value_array_2(ctx, v128);
                                let v197 = constructor_put_in_vreg(ctx, v129.0);
                                let v133 = constructor_put_in_xreg(ctx, v129.1);
                                let v502 = constructor_pulley_vshli8x16(ctx, v197, v133);
                                let v503 = constructor_output_vreg(ctx, v502);
                                let v504 = Some(v503);
                                // Rule at src/isa/pulley_shared/lower.isle line 518.
                                return v504;
                            }
                            I16X8 => {
                                let v129 = C::unpack_value_array_2(ctx, v128);
                                let v197 = constructor_put_in_vreg(ctx, v129.0);
                                let v133 = constructor_put_in_xreg(ctx, v129.1);
                                let v505 = constructor_pulley_vshli16x8(ctx, v197, v133);
                                let v506 = constructor_output_vreg(ctx, v505);
                                let v507 = Some(v506);
                                // Rule at src/isa/pulley_shared/lower.isle line 519.
                                return v507;
                            }
                            I32X4 => {
                                let v129 = C::unpack_value_array_2(ctx, v128);
                                let v197 = constructor_put_in_vreg(ctx, v129.0);
                                let v133 = constructor_put_in_xreg(ctx, v129.1);
                                let v508 = constructor_pulley_vshli32x4(ctx, v197, v133);
                                let v509 = constructor_output_vreg(ctx, v508);
                                let v510 = Some(v509);
                                // Rule at src/isa/pulley_shared/lower.isle line 520.
                                return v510;
                            }
                            I64X2 => {
                                let v129 = C::unpack_value_array_2(ctx, v128);
                                let v197 = constructor_put_in_vreg(ctx, v129.0);
                                let v133 = constructor_put_in_xreg(ctx, v129.1);
                                let v511 = constructor_pulley_vshli64x2(ctx, v197, v133);
                                let v512 = constructor_output_vreg(ctx, v511);
                                let v513 = Some(v512);
                                // Rule at src/isa/pulley_shared/lower.isle line 521.
                                return v513;
                            }
                            _ => {}
                        }
                    }
                }
                &Opcode::Ushr => {
                    let v102 = C::first_result(ctx, arg0);
                    if let Some(v103) = v102 {
                        let v104 = C::value_type(ctx, v103);
                        match v104 {
                            I8 => {
                                let v129 = C::unpack_value_array_2(ctx, v128);
                                let v397 = constructor_zext32(ctx, v129.0);
                                let v133 = constructor_put_in_xreg(ctx, v129.1);
                                let v479 = constructor_pulley_xband32_s8(ctx, v133, 7_i8);
                                let v514 = constructor_pulley_xshr32_u(ctx, v397, v479);
                                let v515 = constructor_output_xreg(ctx, v514);
                                let v516 = Some(v515);
                                // Rule at src/isa/pulley_shared/lower.isle line 535.
                                return v516;
                            }
                            I16 => {
                                let v129 = C::unpack_value_array_2(ctx, v128);
                                let v397 = constructor_zext32(ctx, v129.0);
                                let v133 = constructor_put_in_xreg(ctx, v129.1);
                                let v484 = constructor_pulley_xband32_s8(ctx, v133, 15_i8);
                                let v517 = constructor_pulley_xshr32_u(ctx, v397, v484);
                                let v518 = constructor_output_xreg(ctx, v517);
                                let v519 = Some(v518);
                                // Rule at src/isa/pulley_shared/lower.isle line 538.
                                return v519;
                            }
                            I32 => {
                                let v129 = C::unpack_value_array_2(ctx, v128);
                                let v494 = constructor_u6_shift_from_iconst(ctx, v129.1);
                                if let Some(v495) = v494 {
                                    let v132 = constructor_put_in_xreg(ctx, v129.0);
                                    let v526 = constructor_pulley_xshr32_u_u6(ctx, v132, v495);
                                    let v527 = constructor_output_xreg(ctx, v526);
                                    let v528 = Some(v527);
                                    // Rule at src/isa/pulley_shared/lower.isle line 548.
                                    return v528;
                                }
                                let v132 = constructor_put_in_xreg(ctx, v129.0);
                                let v133 = constructor_put_in_xreg(ctx, v129.1);
                                let v520 = constructor_pulley_xshr32_u(ctx, v132, v133);
                                let v521 = constructor_output_xreg(ctx, v520);
                                let v522 = Some(v521);
                                // Rule at src/isa/pulley_shared/lower.isle line 541.
                                return v522;
                            }
                            I64 => {
                                let v129 = C::unpack_value_array_2(ctx, v128);
                                let v494 = constructor_u6_shift_from_iconst(ctx, v129.1);
                                if let Some(v495) = v494 {
                                    let v132 = constructor_put_in_xreg(ctx, v129.0);
                                    let v529 = constructor_pulley_xshr64_u_u6(ctx, v132, v495);
                                    let v530 = constructor_output_xreg(ctx, v529);
                                    let v531 = Some(v530);
                                    // Rule at src/isa/pulley_shared/lower.isle line 551.
                                    return v531;
                                }
                                let v132 = constructor_put_in_xreg(ctx, v129.0);
                                let v133 = constructor_put_in_xreg(ctx, v129.1);
                                let v523 = constructor_pulley_xshr64_u(ctx, v132, v133);
                                let v524 = constructor_output_xreg(ctx, v523);
                                let v525 = Some(v524);
                                // Rule at src/isa/pulley_shared/lower.isle line 544.
                                return v525;
                            }
                            I8X16 => {
                                let v129 = C::unpack_value_array_2(ctx, v128);
                                let v197 = constructor_put_in_vreg(ctx, v129.0);
                                let v133 = constructor_put_in_xreg(ctx, v129.1);
                                let v532 = constructor_pulley_vshri8x16_u(ctx, v197, v133);
                                let v533 = constructor_output_vreg(ctx, v532);
                                let v534 = Some(v533);
                                // Rule at src/isa/pulley_shared/lower.isle line 557.
                                return v534;
                            }
                            I16X8 => {
                                let v129 = C::unpack_value_array_2(ctx, v128);
                                let v197 = constructor_put_in_vreg(ctx, v129.0);
                                let v133 = constructor_put_in_xreg(ctx, v129.1);
                                let v535 = constructor_pulley_vshri16x8_u(ctx, v197, v133);
                                let v536 = constructor_output_vreg(ctx, v535);
                                let v537 = Some(v536);
                                // Rule at src/isa/pulley_shared/lower.isle line 558.
                                return v537;
                            }
                            I32X4 => {
                                let v129 = C::unpack_value_array_2(ctx, v128);
                                let v197 = constructor_put_in_vreg(ctx, v129.0);
                                let v133 = constructor_put_in_xreg(ctx, v129.1);
                                let v538 = constructor_pulley_vshri32x4_u(ctx, v197, v133);
                                let v539 = constructor_output_vreg(ctx, v538);
                                let v540 = Some(v539);
                                // Rule at src/isa/pulley_shared/lower.isle line 559.
                                return v540;
                            }
                            I64X2 => {
                                let v129 = C::unpack_value_array_2(ctx, v128);
                                let v197 = constructor_put_in_vreg(ctx, v129.0);
                                let v133 = constructor_put_in_xreg(ctx, v129.1);
                                let v541 = constructor_pulley_vshri64x2_u(ctx, v197, v133);
                                let v542 = constructor_output_vreg(ctx, v541);
                                let v543 = Some(v542);
                                // Rule at src/isa/pulley_shared/lower.isle line 560.
                                return v543;
                            }
                            _ => {}
                        }
                    }
                }
                &Opcode::Sshr => {
                    let v102 = C::first_result(ctx, arg0);
                    if let Some(v103) = v102 {
                        let v104 = C::value_type(ctx, v103);
                        match v104 {
                            I8 => {
                                let v129 = C::unpack_value_array_2(ctx, v128);
                                let v425 = constructor_sext32(ctx, v129.0);
                                let v133 = constructor_put_in_xreg(ctx, v129.1);
                                let v479 = constructor_pulley_xband32_s8(ctx, v133, 7_i8);
                                let v544 = constructor_pulley_xshr32_u(ctx, v425, v479);
                                let v545 = constructor_output_xreg(ctx, v544);
                                let v546 = Some(v545);
                                // Rule at src/isa/pulley_shared/lower.isle line 564.
                                return v546;
                            }
                            I16 => {
                                let v129 = C::unpack_value_array_2(ctx, v128);
                                let v425 = constructor_sext32(ctx, v129.0);
                                let v133 = constructor_put_in_xreg(ctx, v129.1);
                                let v484 = constructor_pulley_xband32_s8(ctx, v133, 15_i8);
                                let v547 = constructor_pulley_xshr32_u(ctx, v425, v484);
                                let v548 = constructor_output_xreg(ctx, v547);
                                let v549 = Some(v548);
                                // Rule at src/isa/pulley_shared/lower.isle line 567.
                                return v549;
                            }
                            I32 => {
                                let v129 = C::unpack_value_array_2(ctx, v128);
                                let v494 = constructor_u6_shift_from_iconst(ctx, v129.1);
                                if let Some(v495) = v494 {
                                    let v132 = constructor_put_in_xreg(ctx, v129.0);
                                    let v556 = constructor_pulley_xshr32_s_u6(ctx, v132, v495);
                                    let v557 = constructor_output_xreg(ctx, v556);
                                    let v558 = Some(v557);
                                    // Rule at src/isa/pulley_shared/lower.isle line 577.
                                    return v558;
                                }
                                let v132 = constructor_put_in_xreg(ctx, v129.0);
                                let v133 = constructor_put_in_xreg(ctx, v129.1);
                                let v550 = constructor_pulley_xshr32_s(ctx, v132, v133);
                                let v551 = constructor_output_xreg(ctx, v550);
                                let v552 = Some(v551);
                                // Rule at src/isa/pulley_shared/lower.isle line 570.
                                return v552;
                            }
                            I64 => {
                                let v129 = C::unpack_value_array_2(ctx, v128);
                                let v494 = constructor_u6_shift_from_iconst(ctx, v129.1);
                                if let Some(v495) = v494 {
                                    let v132 = constructor_put_in_xreg(ctx, v129.0);
                                    let v559 = constructor_pulley_xshr64_s_u6(ctx, v132, v495);
                                    let v560 = constructor_output_xreg(ctx, v559);
                                    let v561 = Some(v560);
                                    // Rule at src/isa/pulley_shared/lower.isle line 580.
                                    return v561;
                                }
                                let v132 = constructor_put_in_xreg(ctx, v129.0);
                                let v133 = constructor_put_in_xreg(ctx, v129.1);
                                let v553 = constructor_pulley_xshr64_s(ctx, v132, v133);
                                let v554 = constructor_output_xreg(ctx, v553);
                                let v555 = Some(v554);
                                // Rule at src/isa/pulley_shared/lower.isle line 573.
                                return v555;
                            }
                            I8X16 => {
                                let v129 = C::unpack_value_array_2(ctx, v128);
                                let v197 = constructor_put_in_vreg(ctx, v129.0);
                                let v133 = constructor_put_in_xreg(ctx, v129.1);
                                let v562 = constructor_pulley_vshri8x16_s(ctx, v197, v133);
                                let v563 = constructor_output_vreg(ctx, v562);
                                let v564 = Some(v563);
                                // Rule at src/isa/pulley_shared/lower.isle line 586.
                                return v564;
                            }
                            I16X8 => {
                                let v129 = C::unpack_value_array_2(ctx, v128);
                                let v197 = constructor_put_in_vreg(ctx, v129.0);
                                let v133 = constructor_put_in_xreg(ctx, v129.1);
                                let v565 = constructor_pulley_vshri16x8_s(ctx, v197, v133);
                                let v566 = constructor_output_vreg(ctx, v565);
                                let v567 = Some(v566);
                                // Rule at src/isa/pulley_shared/lower.isle line 587.
                                return v567;
                            }
                            I32X4 => {
                                let v129 = C::unpack_value_array_2(ctx, v128);
                                let v197 = constructor_put_in_vreg(ctx, v129.0);
                                let v133 = constructor_put_in_xreg(ctx, v129.1);
                                let v568 = constructor_pulley_vshri32x4_s(ctx, v197, v133);
                                let v569 = constructor_output_vreg(ctx, v568);
                                let v570 = Some(v569);
                                // Rule at src/isa/pulley_shared/lower.isle line 588.
                                return v570;
                            }
                            I64X2 => {
                                let v129 = C::unpack_value_array_2(ctx, v128);
                                let v197 = constructor_put_in_vreg(ctx, v129.0);
                                let v133 = constructor_put_in_xreg(ctx, v129.1);
                                let v571 = constructor_pulley_vshri64x2_s(ctx, v197, v133);
                                let v572 = constructor_output_vreg(ctx, v571);
                                let v573 = Some(v572);
                                // Rule at src/isa/pulley_shared/lower.isle line 589.
                                return v573;
                            }
                            _ => {}
                        }
                    }
                }
                &Opcode::Fadd => {
                    let v102 = C::first_result(ctx, arg0);
                    if let Some(v103) = v102 {
                        let v104 = C::value_type(ctx, v103);
                        match v104 {
                            F32 => {
                                let v129 = C::unpack_value_array_2(ctx, v128);
                                let v1202 = constructor_put_in_freg(ctx, v129.0);
                                let v1203 = constructor_put_in_freg(ctx, v129.1);
                                let v1210 = constructor_pulley_fadd32(ctx, v1202, v1203);
                                let v1211 = constructor_output_freg(ctx, v1210);
                                let v1212 = Some(v1211);
                                // Rule at src/isa/pulley_shared/lower.isle line 1630.
                                return v1212;
                            }
                            F64 => {
                                let v129 = C::unpack_value_array_2(ctx, v128);
                                let v1202 = constructor_put_in_freg(ctx, v129.0);
                                let v1203 = constructor_put_in_freg(ctx, v129.1);
                                let v1213 = constructor_pulley_fadd64(ctx, v1202, v1203);
                                let v1214 = constructor_output_freg(ctx, v1213);
                                let v1215 = Some(v1214);
                                // Rule at src/isa/pulley_shared/lower.isle line 1631.
                                return v1215;
                            }
                            F32X4 => {
                                let v129 = C::unpack_value_array_2(ctx, v128);
                                let v197 = constructor_put_in_vreg(ctx, v129.0);
                                let v198 = constructor_put_in_vreg(ctx, v129.1);
                                let v1216 = constructor_pulley_vaddf32x4(ctx, v197, v198);
                                let v1217 = constructor_output_vreg(ctx, v1216);
                                let v1218 = Some(v1217);
                                // Rule at src/isa/pulley_shared/lower.isle line 1632.
                                return v1218;
                            }
                            F64X2 => {
                                let v129 = C::unpack_value_array_2(ctx, v128);
                                let v197 = constructor_put_in_vreg(ctx, v129.0);
                                let v198 = constructor_put_in_vreg(ctx, v129.1);
                                let v1219 = constructor_pulley_vaddf64x2(ctx, v197, v198);
                                let v1220 = constructor_output_vreg(ctx, v1219);
                                let v1221 = Some(v1220);
                                // Rule at src/isa/pulley_shared/lower.isle line 1633.
                                return v1221;
                            }
                            _ => {}
                        }
                    }
                }
                &Opcode::Fsub => {
                    let v102 = C::first_result(ctx, arg0);
                    if let Some(v103) = v102 {
                        let v104 = C::value_type(ctx, v103);
                        match v104 {
                            F32 => {
                                let v129 = C::unpack_value_array_2(ctx, v128);
                                let v1202 = constructor_put_in_freg(ctx, v129.0);
                                let v1203 = constructor_put_in_freg(ctx, v129.1);
                                let v1222 = constructor_pulley_fsub32(ctx, v1202, v1203);
                                let v1223 = constructor_output_freg(ctx, v1222);
                                let v1224 = Some(v1223);
                                // Rule at src/isa/pulley_shared/lower.isle line 1637.
                                return v1224;
                            }
                            F64 => {
                                let v129 = C::unpack_value_array_2(ctx, v128);
                                let v1202 = constructor_put_in_freg(ctx, v129.0);
                                let v1203 = constructor_put_in_freg(ctx, v129.1);
                                let v1225 = constructor_pulley_fsub64(ctx, v1202, v1203);
                                let v1226 = constructor_output_freg(ctx, v1225);
                                let v1227 = Some(v1226);
                                // Rule at src/isa/pulley_shared/lower.isle line 1638.
                                return v1227;
                            }
                            F32X4 => {
                                let v129 = C::unpack_value_array_2(ctx, v128);
                                let v197 = constructor_put_in_vreg(ctx, v129.0);
                                let v198 = constructor_put_in_vreg(ctx, v129.1);
                                let v1228 = constructor_pulley_vsubf32x4(ctx, v197, v198);
                                let v1229 = constructor_output_vreg(ctx, v1228);
                                let v1230 = Some(v1229);
                                // Rule at src/isa/pulley_shared/lower.isle line 1639.
                                return v1230;
                            }
                            F64X2 => {
                                let v129 = C::unpack_value_array_2(ctx, v128);
                                let v197 = constructor_put_in_vreg(ctx, v129.0);
                                let v198 = constructor_put_in_vreg(ctx, v129.1);
                                let v1231 = constructor_pulley_vsubf64x2(ctx, v197, v198);
                                let v1232 = constructor_output_vreg(ctx, v1231);
                                let v1233 = Some(v1232);
                                // Rule at src/isa/pulley_shared/lower.isle line 1640.
                                return v1233;
                            }
                            _ => {}
                        }
                    }
                }
                &Opcode::Fmul => {
                    let v102 = C::first_result(ctx, arg0);
                    if let Some(v103) = v102 {
                        let v104 = C::value_type(ctx, v103);
                        match v104 {
                            F32 => {
                                let v129 = C::unpack_value_array_2(ctx, v128);
                                let v1202 = constructor_put_in_freg(ctx, v129.0);
                                let v1203 = constructor_put_in_freg(ctx, v129.1);
                                let v1234 = constructor_pulley_fmul32(ctx, v1202, v1203);
                                let v1235 = constructor_output_freg(ctx, v1234);
                                let v1236 = Some(v1235);
                                // Rule at src/isa/pulley_shared/lower.isle line 1644.
                                return v1236;
                            }
                            F64 => {
                                let v129 = C::unpack_value_array_2(ctx, v128);
                                let v1202 = constructor_put_in_freg(ctx, v129.0);
                                let v1203 = constructor_put_in_freg(ctx, v129.1);
                                let v1237 = constructor_pulley_fmul64(ctx, v1202, v1203);
                                let v1238 = constructor_output_freg(ctx, v1237);
                                let v1239 = Some(v1238);
                                // Rule at src/isa/pulley_shared/lower.isle line 1645.
                                return v1239;
                            }
                            F32X4 => {
                                let v129 = C::unpack_value_array_2(ctx, v128);
                                let v197 = constructor_put_in_vreg(ctx, v129.0);
                                let v198 = constructor_put_in_vreg(ctx, v129.1);
                                let v1240 = constructor_pulley_vmulf32x4(ctx, v197, v198);
                                let v1241 = constructor_output_vreg(ctx, v1240);
                                let v1242 = Some(v1241);
                                // Rule at src/isa/pulley_shared/lower.isle line 1646.
                                return v1242;
                            }
                            F64X2 => {
                                let v129 = C::unpack_value_array_2(ctx, v128);
                                let v197 = constructor_put_in_vreg(ctx, v129.0);
                                let v198 = constructor_put_in_vreg(ctx, v129.1);
                                let v1243 = constructor_pulley_vmulf64x2(ctx, v197, v198);
                                let v1244 = constructor_output_vreg(ctx, v1243);
                                let v1245 = Some(v1244);
                                // Rule at src/isa/pulley_shared/lower.isle line 1647.
                                return v1245;
                            }
                            _ => {}
                        }
                    }
                }
                &Opcode::Fdiv => {
                    let v102 = C::first_result(ctx, arg0);
                    if let Some(v103) = v102 {
                        let v104 = C::value_type(ctx, v103);
                        match v104 {
                            F32 => {
                                let v129 = C::unpack_value_array_2(ctx, v128);
                                let v1202 = constructor_put_in_freg(ctx, v129.0);
                                let v1203 = constructor_put_in_freg(ctx, v129.1);
                                let v1246 = constructor_pulley_fdiv32(ctx, v1202, v1203);
                                let v1247 = constructor_output_freg(ctx, v1246);
                                let v1248 = Some(v1247);
                                // Rule at src/isa/pulley_shared/lower.isle line 1651.
                                return v1248;
                            }
                            F64 => {
                                let v129 = C::unpack_value_array_2(ctx, v128);
                                let v1202 = constructor_put_in_freg(ctx, v129.0);
                                let v1203 = constructor_put_in_freg(ctx, v129.1);
                                let v1249 = constructor_pulley_fdiv64(ctx, v1202, v1203);
                                let v1250 = constructor_output_freg(ctx, v1249);
                                let v1251 = Some(v1250);
                                // Rule at src/isa/pulley_shared/lower.isle line 1652.
                                return v1251;
                            }
                            F32X4 => {
                                let v129 = C::unpack_value_array_2(ctx, v128);
                                let v197 = constructor_put_in_vreg(ctx, v129.0);
                                let v198 = constructor_put_in_vreg(ctx, v129.1);
                                let v1252 = constructor_pulley_vdivf32x4(ctx, v197, v198);
                                let v1253 = constructor_output_vreg(ctx, v1252);
                                let v1254 = Some(v1253);
                                // Rule at src/isa/pulley_shared/lower.isle line 1653.
                                return v1254;
                            }
                            F64X2 => {
                                let v129 = C::unpack_value_array_2(ctx, v128);
                                let v197 = constructor_put_in_vreg(ctx, v129.0);
                                let v198 = constructor_put_in_vreg(ctx, v129.1);
                                let v1255 = constructor_pulley_vdivf64x2(ctx, v197, v198);
                                let v1256 = constructor_output_vreg(ctx, v1255);
                                let v1257 = Some(v1256);
                                // Rule at src/isa/pulley_shared/lower.isle line 1654.
                                return v1257;
                            }
                            _ => {}
                        }
                    }
                }
                &Opcode::Fcopysign => {
                    let v102 = C::first_result(ctx, arg0);
                    if let Some(v103) = v102 {
                        let v104 = C::value_type(ctx, v103);
                        match v104 {
                            F32 => {
                                let v129 = C::unpack_value_array_2(ctx, v128);
                                let v1202 = constructor_put_in_freg(ctx, v129.0);
                                let v1203 = constructor_put_in_freg(ctx, v129.1);
                                let v1204 = constructor_pulley_fcopysign32(ctx, v1202, v1203);
                                let v1205 = constructor_output_freg(ctx, v1204);
                                let v1206 = Some(v1205);
                                // Rule at src/isa/pulley_shared/lower.isle line 1622.
                                return v1206;
                            }
                            F64 => {
                                let v129 = C::unpack_value_array_2(ctx, v128);
                                let v1202 = constructor_put_in_freg(ctx, v129.0);
                                let v1203 = constructor_put_in_freg(ctx, v129.1);
                                let v1207 = constructor_pulley_fcopysign64(ctx, v1202, v1203);
                                let v1208 = constructor_output_freg(ctx, v1207);
                                let v1209 = Some(v1208);
                                // Rule at src/isa/pulley_shared/lower.isle line 1625.
                                return v1209;
                            }
                            _ => {}
                        }
                    }
                }
                &Opcode::Fmin => {
                    let v102 = C::first_result(ctx, arg0);
                    if let Some(v103) = v102 {
                        let v104 = C::value_type(ctx, v103);
                        match v104 {
                            F32 => {
                                let v129 = C::unpack_value_array_2(ctx, v128);
                                let v1202 = constructor_put_in_freg(ctx, v129.0);
                                let v1203 = constructor_put_in_freg(ctx, v129.1);
                                let v1270 = constructor_pulley_fminimum32(ctx, v1202, v1203);
                                let v1271 = constructor_output_freg(ctx, v1270);
                                let v1272 = Some(v1271);
                                // Rule at src/isa/pulley_shared/lower.isle line 1665.
                                return v1272;
                            }
                            F64 => {
                                let v129 = C::unpack_value_array_2(ctx, v128);
                                let v1202 = constructor_put_in_freg(ctx, v129.0);
                                let v1203 = constructor_put_in_freg(ctx, v129.1);
                                let v1273 = constructor_pulley_fminimum64(ctx, v1202, v1203);
                                let v1274 = constructor_output_freg(ctx, v1273);
                                let v1275 = Some(v1274);
                                // Rule at src/isa/pulley_shared/lower.isle line 1666.
                                return v1275;
                            }
                            F32X4 => {
                                let v129 = C::unpack_value_array_2(ctx, v128);
                                let v197 = constructor_put_in_vreg(ctx, v129.0);
                                let v198 = constructor_put_in_vreg(ctx, v129.1);
                                let v1276 = constructor_pulley_vminimumf32x4(ctx, v197, v198);
                                let v1277 = constructor_output_vreg(ctx, v1276);
                                let v1278 = Some(v1277);
                                // Rule at src/isa/pulley_shared/lower.isle line 1667.
                                return v1278;
                            }
                            F64X2 => {
                                let v129 = C::unpack_value_array_2(ctx, v128);
                                let v197 = constructor_put_in_vreg(ctx, v129.0);
                                let v198 = constructor_put_in_vreg(ctx, v129.1);
                                let v1279 = constructor_pulley_vminimumf64x2(ctx, v197, v198);
                                let v1280 = constructor_output_vreg(ctx, v1279);
                                let v1281 = Some(v1280);
                                // Rule at src/isa/pulley_shared/lower.isle line 1668.
                                return v1281;
                            }
                            _ => {}
                        }
                    }
                }
                &Opcode::Fmax => {
                    let v102 = C::first_result(ctx, arg0);
                    if let Some(v103) = v102 {
                        let v104 = C::value_type(ctx, v103);
                        match v104 {
                            F32 => {
                                let v129 = C::unpack_value_array_2(ctx, v128);
                                let v1202 = constructor_put_in_freg(ctx, v129.0);
                                let v1203 = constructor_put_in_freg(ctx, v129.1);
                                let v1258 = constructor_pulley_fmaximum32(ctx, v1202, v1203);
                                let v1259 = constructor_output_freg(ctx, v1258);
                                let v1260 = Some(v1259);
                                // Rule at src/isa/pulley_shared/lower.isle line 1658.
                                return v1260;
                            }
                            F64 => {
                                let v129 = C::unpack_value_array_2(ctx, v128);
                                let v1202 = constructor_put_in_freg(ctx, v129.0);
                                let v1203 = constructor_put_in_freg(ctx, v129.1);
                                let v1261 = constructor_pulley_fmaximum64(ctx, v1202, v1203);
                                let v1262 = constructor_output_freg(ctx, v1261);
                                let v1263 = Some(v1262);
                                // Rule at src/isa/pulley_shared/lower.isle line 1659.
                                return v1263;
                            }
                            F32X4 => {
                                let v129 = C::unpack_value_array_2(ctx, v128);
                                let v197 = constructor_put_in_vreg(ctx, v129.0);
                                let v198 = constructor_put_in_vreg(ctx, v129.1);
                                let v1264 = constructor_pulley_vmaximumf32x4(ctx, v197, v198);
                                let v1265 = constructor_output_vreg(ctx, v1264);
                                let v1266 = Some(v1265);
                                // Rule at src/isa/pulley_shared/lower.isle line 1660.
                                return v1266;
                            }
                            F64X2 => {
                                let v129 = C::unpack_value_array_2(ctx, v128);
                                let v197 = constructor_put_in_vreg(ctx, v129.0);
                                let v198 = constructor_put_in_vreg(ctx, v129.1);
                                let v1267 = constructor_pulley_vmaximumf64x2(ctx, v197, v198);
                                let v1268 = constructor_output_vreg(ctx, v1267);
                                let v1269 = Some(v1268);
                                // Rule at src/isa/pulley_shared/lower.isle line 1661.
                                return v1269;
                            }
                            _ => {}
                        }
                    }
                }
                &Opcode::Snarrow => {
                    let v129 = C::unpack_value_array_2(ctx, v128);
                    let v1508 = C::value_type(ctx, v129.0);
                    match v1508 {
                        I16X8 => {
                            let v197 = constructor_put_in_vreg(ctx, v129.0);
                            let v198 = constructor_put_in_vreg(ctx, v129.1);
                            let v1509 = constructor_pulley_vnarrow16x8_s(ctx, v197, v198);
                            let v1510 = constructor_output_vreg(ctx, v1509);
                            let v1511 = Some(v1510);
                            // Rule at src/isa/pulley_shared/lower.isle line 1824.
                            return v1511;
                        }
                        I32X4 => {
                            let v197 = constructor_put_in_vreg(ctx, v129.0);
                            let v198 = constructor_put_in_vreg(ctx, v129.1);
                            let v1512 = constructor_pulley_vnarrow32x4_s(ctx, v197, v198);
                            let v1513 = constructor_output_vreg(ctx, v1512);
                            let v1514 = Some(v1513);
                            // Rule at src/isa/pulley_shared/lower.isle line 1825.
                            return v1514;
                        }
                        I64X2 => {
                            let v197 = constructor_put_in_vreg(ctx, v129.0);
                            let v198 = constructor_put_in_vreg(ctx, v129.1);
                            let v1515 = constructor_pulley_vnarrow64x2_s(ctx, v197, v198);
                            let v1516 = constructor_output_vreg(ctx, v1515);
                            let v1517 = Some(v1516);
                            // Rule at src/isa/pulley_shared/lower.isle line 1826.
                            return v1517;
                        }
                        _ => {}
                    }
                }
                &Opcode::Unarrow => {
                    let v129 = C::unpack_value_array_2(ctx, v128);
                    let v1508 = C::value_type(ctx, v129.0);
                    match v1508 {
                        I16X8 => {
                            let v197 = constructor_put_in_vreg(ctx, v129.0);
                            let v198 = constructor_put_in_vreg(ctx, v129.1);
                            let v1518 = constructor_pulley_vnarrow16x8_u(ctx, v197, v198);
                            let v1519 = constructor_output_vreg(ctx, v1518);
                            let v1520 = Some(v1519);
                            // Rule at src/isa/pulley_shared/lower.isle line 1830.
                            return v1520;
                        }
                        I32X4 => {
                            let v197 = constructor_put_in_vreg(ctx, v129.0);
                            let v198 = constructor_put_in_vreg(ctx, v129.1);
                            let v1521 = constructor_pulley_vnarrow32x4_u(ctx, v197, v198);
                            let v1522 = constructor_output_vreg(ctx, v1521);
                            let v1523 = Some(v1522);
                            // Rule at src/isa/pulley_shared/lower.isle line 1831.
                            return v1523;
                        }
                        _ => {}
                    }
                }
                &Opcode::Uunarrow => {
                    let v129 = C::unpack_value_array_2(ctx, v128);
                    let v1508 = C::value_type(ctx, v129.0);
                    if v1508 == I64X2 {
                        let v197 = constructor_put_in_vreg(ctx, v129.0);
                        let v198 = constructor_put_in_vreg(ctx, v129.1);
                        let v1524 = constructor_pulley_vunarrow64x2_u(ctx, v197, v198);
                        let v1525 = constructor_output_vreg(ctx, v1524);
                        let v1526 = Some(v1525);
                        // Rule at src/isa/pulley_shared/lower.isle line 1835.
                        return v1526;
                    }
                }
                &Opcode::IaddPairwise => {
                    let v102 = C::first_result(ctx, arg0);
                    if let Some(v103) = v102 {
                        let v104 = C::value_type(ctx, v103);
                        match v104 {
                            I16X8 => {
                                let v129 = C::unpack_value_array_2(ctx, v128);
                                let v197 = constructor_put_in_vreg(ctx, v129.0);
                                let v198 = constructor_put_in_vreg(ctx, v129.1);
                                let v256 = constructor_pulley_vaddpairwisei16x8_s(ctx, v197, v198);
                                let v257 = constructor_output_vreg(ctx, v256);
                                let v258 = Some(v257);
                                // Rule at src/isa/pulley_shared/lower.isle line 320.
                                return v258;
                            }
                            I32X4 => {
                                let v129 = C::unpack_value_array_2(ctx, v128);
                                let v197 = constructor_put_in_vreg(ctx, v129.0);
                                let v198 = constructor_put_in_vreg(ctx, v129.1);
                                let v259 = constructor_pulley_vaddpairwisei32x4_s(ctx, v197, v198);
                                let v260 = constructor_output_vreg(ctx, v259);
                                let v261 = Some(v260);
                                // Rule at src/isa/pulley_shared/lower.isle line 321.
                                return v261;
                            }
                            _ => {}
                        }
                    }
                }
                &Opcode::Iconcat => {
                    let v102 = C::first_result(ctx, arg0);
                    if let Some(v103) = v102 {
                        let v104 = C::value_type(ctx, v103);
                        if v104 == I128 {
                            let v129 = C::unpack_value_array_2(ctx, v128);
                            let v1008 = C::put_in_reg(ctx, v129.0);
                            let v1009 = C::put_in_reg(ctx, v129.1);
                            let v1010 = C::value_regs(ctx, v1008, v1009);
                            let v1011 = C::output(ctx, v1010);
                            let v1012 = Some(v1011);
                            // Rule at src/isa/pulley_shared/lower.isle line 1399.
                            return v1012;
                        }
                    }
                }
                _ => {}
            }
        }
        &InstructionData::BinaryImm8 {
            opcode: ref v1533,
            arg: v1534,
            imm: v1535,
        } => {
            if let &Opcode::Extractlane = v1533 {
                let v1536 = C::value_type(ctx, v1534);
                match v1536 {
                    I8X16 => {
                        let v1538 = constructor_put_in_vreg(ctx, v1534);
                        let v1537 = C::u8_from_uimm8(ctx, v1535);
                        let v1539 = constructor_pulley_xextractv8x16(ctx, v1538, v1537);
                        let v1540 = constructor_output_xreg(ctx, v1539);
                        let v1541 = Some(v1540);
                        // Rule at src/isa/pulley_shared/lower.isle line 1847.
                        return v1541;
                    }
                    I16X8 => {
                        let v1538 = constructor_put_in_vreg(ctx, v1534);
                        let v1537 = C::u8_from_uimm8(ctx, v1535);
                        let v1542 = constructor_pulley_xextractv16x8(ctx, v1538, v1537);
                        let v1543 = constructor_output_xreg(ctx, v1542);
                        let v1544 = Some(v1543);
                        // Rule at src/isa/pulley_shared/lower.isle line 1849.
                        return v1544;
                    }
                    I32X4 => {
                        let v1538 = constructor_put_in_vreg(ctx, v1534);
                        let v1537 = C::u8_from_uimm8(ctx, v1535);
                        let v1545 = constructor_pulley_xextractv32x4(ctx, v1538, v1537);
                        let v1546 = constructor_output_xreg(ctx, v1545);
                        let v1547 = Some(v1546);
                        // Rule at src/isa/pulley_shared/lower.isle line 1851.
                        return v1547;
                    }
                    I64X2 => {
                        let v1538 = constructor_put_in_vreg(ctx, v1534);
                        let v1537 = C::u8_from_uimm8(ctx, v1535);
                        let v1548 = constructor_pulley_xextractv64x2(ctx, v1538, v1537);
                        let v1549 = constructor_output_xreg(ctx, v1548);
                        let v1550 = Some(v1549);
                        // Rule at src/isa/pulley_shared/lower.isle line 1853.
                        return v1550;
                    }
                    F32X4 => {
                        let v1538 = constructor_put_in_vreg(ctx, v1534);
                        let v1537 = C::u8_from_uimm8(ctx, v1535);
                        let v1551 = constructor_pulley_fextractv32x4(ctx, v1538, v1537);
                        let v1552 = constructor_output_freg(ctx, v1551);
                        let v1553 = Some(v1552);
                        // Rule at src/isa/pulley_shared/lower.isle line 1855.
                        return v1553;
                    }
                    F64X2 => {
                        let v1538 = constructor_put_in_vreg(ctx, v1534);
                        let v1537 = C::u8_from_uimm8(ctx, v1535);
                        let v1554 = constructor_pulley_fextractv64x2(ctx, v1538, v1537);
                        let v1555 = constructor_output_freg(ctx, v1554);
                        let v1556 = Some(v1555);
                        // Rule at src/isa/pulley_shared/lower.isle line 1857.
                        return v1556;
                    }
                    _ => {}
                }
            }
        }
        &InstructionData::Call {
            opcode: ref v36,
            args: v37,
            func_ref: v38,
        } => {
            match v36 {
                &Opcode::Call => {
                    let v40 = C::func_ref_data(ctx, v38);
                    if let &RelocDistance::Near = &v40.2 {
                        let v45 = &C::gen_call_output(ctx, v40.0);
                        let v46 = C::abi_sig(ctx, v40.0);
                        let v39 = C::value_list_slice(ctx, v37);
                        let v47 = &C::put_in_regs_vec(ctx, v39);
                        let v48 = C::gen_call_args(ctx, v46, v47);
                        let v49 = C::gen_call_rets(ctx, v46, v45);
                        let v50 = C::try_call_none(ctx);
                        let v51 = C::gen_call_info(ctx, v46, v40.1, v48, v49, v50, v40.3);
                        let v52 = &constructor_call_impl(ctx, v51);
                        let v53 = constructor_emit_side_effect(ctx, v52);
                        let v54 = C::output_vec(ctx, v45);
                        let v55 = Some(v54);
                        // Rule at src/isa/pulley_shared/lower.isle line 146.
                        return v55;
                    }
                    if v40.3 == false {
                        let v45 = &C::gen_call_output(ctx, v40.0);
                        let v46 = C::abi_sig(ctx, v40.0);
                        let v39 = C::value_list_slice(ctx, v37);
                        let v47 = &C::put_in_regs_vec(ctx, v39);
                        let v48 = C::gen_call_args(ctx, v46, v47);
                        let v49 = C::gen_call_rets(ctx, v46, v45);
                        let v50 = C::try_call_none(ctx);
                        let v56 = C::gen_call_host_info(ctx, v46, v40.1, v48, v49, v50);
                        let v57 = &constructor_indirect_call_host_impl(ctx, v56);
                        let v58 = constructor_emit_side_effect(ctx, v57);
                        let v54 = C::output_vec(ctx, v45);
                        let v55 = Some(v54);
                        // Rule at src/isa/pulley_shared/lower.isle line 156.
                        return v55;
                    }
                }
                &Opcode::ReturnCall => {
                    let v40 = C::func_ref_data(ctx, v38);
                    if v40.3 == false {
                        if let &RelocDistance::Near = &v40.2 {
                            let v79 = C::abi_sig(ctx, v40.0);
                            let v39 = C::value_list_slice(ctx, v37);
                            let v80 = &C::put_in_regs_vec(ctx, v39);
                            let v81 = C::gen_return_call_args(ctx, v79, v80);
                            let v82 = C::gen_return_call_info(ctx, v79, v40.1, v81);
                            let v83 = &constructor_return_call_impl(ctx, v82);
                            let v84 = constructor_side_effect(ctx, v83);
                            let v85 = Some(v84);
                            // Rule at src/isa/pulley_shared/lower.isle line 210.
                            return v85;
                        }
                        let v79 = C::abi_sig(ctx, v40.0);
                        let v39 = C::value_list_slice(ctx, v37);
                        let v80 = &C::put_in_regs_vec(ctx, v39);
                        let v81 = C::gen_return_call_args(ctx, v79, v80);
                        let v86 = C::box_external_name(ctx, v40.1);
                        let v88 = constructor_load_ext_name(ctx, v86, 0_i64, &v40.2);
                        let v89 = C::xreg_to_reg(ctx, v88);
                        let v90 = C::gen_return_call_ind_info(ctx, v79, v89, v81);
                        let v91 = &constructor_return_indirect_call_impl(ctx, v90);
                        let v92 = constructor_side_effect(ctx, v91);
                        let v93 = Some(v92);
                        // Rule at src/isa/pulley_shared/lower.isle line 217.
                        return v93;
                    }
                }
                _ => {}
            }
        }
        &InstructionData::CallIndirect {
            opcode: ref v59,
            args: v60,
            sig_ref: v61,
        } => {
            match v59 {
                &Opcode::CallIndirect => {
                    let v62 = C::value_list_slice(ctx, v60);
                    let v63 = C::value_slice_unwrap(ctx, v62);
                    if let Some(v64) = v63 {
                        let v67 = &C::gen_call_output(ctx, v61);
                        let v68 = C::abi_sig(ctx, v61);
                        let v69 = C::put_in_reg(ctx, v64.0);
                        let v70 = &C::put_in_regs_vec(ctx, v64.1);
                        let v71 = C::gen_call_args(ctx, v68, v70);
                        let v72 = C::gen_call_rets(ctx, v68, v67);
                        let v73 = C::try_call_none(ctx);
                        let v74 = C::gen_call_ind_info(ctx, v68, v69, v71, v72, v73);
                        let v75 = &constructor_indirect_call_impl(ctx, v74);
                        let v76 = constructor_emit_side_effect(ctx, v75);
                        let v77 = C::output_vec(ctx, v67);
                        let v78 = Some(v77);
                        // Rule at src/isa/pulley_shared/lower.isle line 166.
                        return v78;
                    }
                }
                &Opcode::ReturnCallIndirect => {
                    let v62 = C::value_list_slice(ctx, v60);
                    let v63 = C::value_slice_unwrap(ctx, v62);
                    if let Some(v64) = v63 {
                        let v94 = C::abi_sig(ctx, v61);
                        let v95 = C::put_in_reg(ctx, v64.0);
                        let v96 = &C::put_in_regs_vec(ctx, v64.1);
                        let v97 = C::gen_return_call_args(ctx, v94, v96);
                        let v98 = C::gen_return_call_ind_info(ctx, v94, v95, v97);
                        let v99 = &constructor_return_indirect_call_impl(ctx, v98);
                        let v100 = constructor_side_effect(ctx, v99);
                        let v101 = Some(v100);
                        // Rule at src/isa/pulley_shared/lower.isle line 225.
                        return v101;
                    }
                }
                _ => {}
            }
        }
        &InstructionData::CondTrap {
            opcode: ref v9,
            arg: v10,
            code: ref v11,
        } => {
            match v9 {
                &Opcode::Trapz => {
                    let v12 = &constructor_lower_cond(ctx, v10);
                    let v13 = &C::cond_invert(ctx, v12);
                    let v14 = &constructor_pulley_trap_if(ctx, v13, v11);
                    let v15 = constructor_side_effect(ctx, v14);
                    let v16 = Some(v15);
                    // Rule at src/isa/pulley_shared/lower.isle line 118.
                    return v16;
                }
                &Opcode::Trapnz => {
                    let v12 = &constructor_lower_cond(ctx, v10);
                    let v17 = &constructor_pulley_trap_if(ctx, v12, v11);
                    let v18 = constructor_side_effect(ctx, v17);
                    let v19 = Some(v18);
                    // Rule at src/isa/pulley_shared/lower.isle line 121.
                    return v19;
                }
                _ => {}
            }
        }
        &InstructionData::ExceptionHandlerAddress {
            opcode: ref v1653,
            block: ref v1654,
            imm: v1655,
        } => {
            if let &Opcode::GetExceptionHandlerAddress = v1653 {
                let v1656 = C::u64_from_imm64(ctx, v1655);
                let v1657 = C::block_exn_successor_label(ctx, v1654, v1656);
                let v1658 = constructor_pulley_label_address(ctx, v1657);
                let v1659 = constructor_output_reg(ctx, v1658);
                let v1660 = Some(v1659);
                // Rule at src/isa/pulley_shared/lower.isle line 1921.
                return v1660;
            }
        }
        &InstructionData::FloatCompare {
            opcode: ref v808,
            args: ref v809,
            cond: ref v810,
        } => {
            if let &Opcode::Fcmp = v808 {
                let v811 = C::unpack_value_array_2(ctx, v809);
                let v814 = C::value_type(ctx, v811.1);
                let v820 = C::ty_vec128(ctx, v814);
                if let Some(v821) = v820 {
                    let v822 = constructor_lower_vfcmp(ctx, v821, v810, v811.0, v811.1);
                    let v823 = constructor_output_vreg(ctx, v822);
                    let v824 = Some(v823);
                    // Rule at src/isa/pulley_shared/lower.isle line 896.
                    return v824;
                }
                let v815 = C::ty_scalar_float(ctx, v814);
                if let Some(v816) = v815 {
                    let v817 = constructor_lower_fcmp(ctx, v816, v810, v811.0, v811.1);
                    let v818 = constructor_output_xreg(ctx, v817);
                    let v819 = Some(v818);
                    // Rule at src/isa/pulley_shared/lower.isle line 893.
                    return v819;
                }
            }
        }
        &InstructionData::FuncAddr {
            opcode: ref v1642,
            func_ref: v1643,
        } => {
            if let &Opcode::FuncAddr = v1642 {
                let v1644 = C::func_ref_data(ctx, v1643);
                let v1649 = C::box_external_name(ctx, v1644.1);
                let v1650 = constructor_load_ext_name(ctx, v1649, 0_i64, &v1644.2);
                let v1651 = constructor_output_xreg(ctx, v1650);
                let v1652 = Some(v1651);
                // Rule at src/isa/pulley_shared/lower.isle line 1915.
                return v1652;
            }
        }
        &InstructionData::IntAddTrap {
            opcode: ref v1025,
            args: ref v1026,
            code: ref v1027,
        } => {
            if let &Opcode::UaddOverflowTrap = v1025 {
                let v102 = C::first_result(ctx, arg0);
                if let Some(v103) = v102 {
                    let v104 = C::value_type(ctx, v103);
                    match v104 {
                        I32 => {
                            let v1028 = C::unpack_value_array_2(ctx, v1026);
                            let v1031 = constructor_put_in_xreg(ctx, v1028.0);
                            let v1032 = constructor_put_in_xreg(ctx, v1028.1);
                            let v1033 = constructor_pulley_xadd32_uoverflow_trap(ctx, v1031, v1032, v1027);
                            let v1034 = constructor_output_xreg(ctx, v1033);
                            let v1035 = Some(v1034);
                            // Rule at src/isa/pulley_shared/lower.isle line 1411.
                            return v1035;
                        }
                        I64 => {
                            let v1028 = C::unpack_value_array_2(ctx, v1026);
                            let v1031 = constructor_put_in_xreg(ctx, v1028.0);
                            let v1032 = constructor_put_in_xreg(ctx, v1028.1);
                            let v1036 = constructor_pulley_xadd64_uoverflow_trap(ctx, v1031, v1032, v1027);
                            let v1037 = constructor_output_xreg(ctx, v1036);
                            let v1038 = Some(v1037);
                            // Rule at src/isa/pulley_shared/lower.isle line 1414.
                            return v1038;
                        }
                        _ => {}
                    }
                }
            }
        }
        &InstructionData::IntCompare {
            opcode: ref v790,
            args: ref v791,
            cond: ref v792,
        } => {
            if let &Opcode::Icmp = v790 {
                let v793 = C::unpack_value_array_2(ctx, v791);
                let v802 = C::value_type(ctx, v793.0);
                let v803 = C::ty_vec128(ctx, v802);
                if let Some(v804) = v803 {
                    let v805 = constructor_lower_vcmp(ctx, v804, v792, v793.0, v793.1);
                    let v806 = constructor_output_vreg(ctx, v805);
                    let v807 = Some(v806);
                    // Rule at src/isa/pulley_shared/lower.isle line 850.
                    return v807;
                }
                let v796 = C::value_type(ctx, v793.1);
                let v797 = C::ty_int(ctx, v796);
                if let Some(v798) = v797 {
                    let v799 = constructor_lower_icmp(ctx, v798, v792, v793.0, v793.1);
                    let v800 = constructor_output_xreg(ctx, v799);
                    let v801 = Some(v800);
                    // Rule at src/isa/pulley_shared/lower.isle line 739.
                    return v801;
                }
            }
        }
        &InstructionData::Load {
            opcode: ref v825,
            arg: v826,
            flags: v827,
            offset: v828,
        } => {
            match v825 {
                &Opcode::Load => {
                    let v102 = C::first_result(ctx, arg0);
                    if let Some(v103) = v102 {
                        let v829 = C::mem_flags_data(ctx, v827);
                        if let Some(v830) = v829 {
                            let v104 = C::value_type(ctx, v103);
                            if v104 == I128 {
                                let v840 = C::offset32_to_i32(ctx, v828);
                                let v842 = C::i32_checked_add(ctx, v840, 8_i32);
                                if let Some(v843) = v842 {
                                    let v844 = &constructor_amode(ctx, v826, v828);
                                    let v846 = constructor_pulley_xload(ctx, v844, I64, v830);
                                    let v847 = C::i32_to_offset32(ctx, v843);
                                    let v848 = &constructor_amode(ctx, v826, v847);
                                    let v849 = constructor_pulley_xload(ctx, v848, I64, v830);
                                    let v850 = C::xreg_to_reg(ctx, v846);
                                    let v851 = C::xreg_to_reg(ctx, v849);
                                    let v852 = C::value_regs(ctx, v850, v851);
                                    let v853 = C::output(ctx, v852);
                                    let v854 = Some(v853);
                                    // Rule at src/isa/pulley_shared/lower.isle line 968.
                                    return v854;
                                }
                            }
                            let v592 = C::ty_vec128(ctx, v104);
                            if let Some(v593) = v592 {
                                let v896 = constructor_gen_vload(ctx, v826, v828, v830, v593, &VExtKind::None);
                                let v897 = constructor_output_vreg(ctx, v896);
                                let v898 = Some(v897);
                                // Rule at src/isa/pulley_shared/lower.isle line 1010.
                                return v898;
                            }
                            let v835 = C::ty_scalar_float(ctx, v104);
                            if let Some(v836) = v835 {
                                let v837 = constructor_gen_fload(ctx, v826, v828, v830, v836);
                                let v838 = constructor_output_freg(ctx, v837);
                                let v839 = Some(v838);
                                // Rule at src/isa/pulley_shared/lower.isle line 965.
                                return v839;
                            }
                            let v123 = C::ty_int(ctx, v104);
                            if let Some(v124) = v123 {
                                let v125 = C::fits_in_64(ctx, v124);
                                if let Some(v126) = v125 {
                                    let v832 = constructor_gen_xload(ctx, v826, v828, v830, v126, &ExtKind::None);
                                    let v833 = constructor_output_xreg(ctx, v832);
                                    let v834 = Some(v833);
                                    // Rule at src/isa/pulley_shared/lower.isle line 962.
                                    return v834;
                                }
                            }
                        }
                    }
                }
                &Opcode::Uload8 => {
                    let v102 = C::first_result(ctx, arg0);
                    if let Some(v103) = v102 {
                        let v829 = C::mem_flags_data(ctx, v827);
                        if let Some(v830) = v829 {
                            let v104 = C::value_type(ctx, v103);
                            if v104 == I64 {
                                let v869 = constructor_gen_xload(ctx, v826, v828, v830, I8, &ExtKind::Zero64);
                                let v870 = constructor_output_xreg(ctx, v869);
                                let v871 = Some(v870);
                                // Rule at src/isa/pulley_shared/lower.isle line 983.
                                return v871;
                            }
                            let v123 = C::ty_int(ctx, v104);
                            if let Some(v124) = v123 {
                                let v140 = C::fits_in_32(ctx, v124);
                                if let Some(v141) = v140 {
                                    let v857 = constructor_gen_xload(ctx, v826, v828, v830, I8, &ExtKind::Zero32);
                                    let v858 = constructor_output_xreg(ctx, v857);
                                    let v859 = Some(v858);
                                    // Rule at src/isa/pulley_shared/lower.isle line 974.
                                    return v859;
                                }
                            }
                        }
                    }
                }
                &Opcode::Sload8 => {
                    let v102 = C::first_result(ctx, arg0);
                    if let Some(v103) = v102 {
                        let v829 = C::mem_flags_data(ctx, v827);
                        if let Some(v830) = v829 {
                            let v104 = C::value_type(ctx, v103);
                            if v104 == I64 {
                                let v886 = constructor_gen_xload(ctx, v826, v828, v830, I8, &ExtKind::Sign64);
                                let v887 = constructor_output_xreg(ctx, v886);
                                let v888 = Some(v887);
                                // Rule at src/isa/pulley_shared/lower.isle line 1001.
                                return v888;
                            }
                            let v123 = C::ty_int(ctx, v104);
                            if let Some(v124) = v123 {
                                let v140 = C::fits_in_32(ctx, v124);
                                if let Some(v141) = v140 {
                                    let v879 = constructor_gen_xload(ctx, v826, v828, v830, I8, &ExtKind::Sign32);
                                    let v880 = constructor_output_xreg(ctx, v879);
                                    let v881 = Some(v880);
                                    // Rule at src/isa/pulley_shared/lower.isle line 992.
                                    return v881;
                                }
                            }
                        }
                    }
                }
                &Opcode::Uload16 => {
                    let v102 = C::first_result(ctx, arg0);
                    if let Some(v103) = v102 {
                        let v829 = C::mem_flags_data(ctx, v827);
                        if let Some(v830) = v829 {
                            let v104 = C::value_type(ctx, v103);
                            if v104 == I64 {
                                let v872 = constructor_gen_xload(ctx, v826, v828, v830, I16, &ExtKind::Zero64);
                                let v873 = constructor_output_xreg(ctx, v872);
                                let v874 = Some(v873);
                                // Rule at src/isa/pulley_shared/lower.isle line 986.
                                return v874;
                            }
                            let v123 = C::ty_int(ctx, v104);
                            if let Some(v124) = v123 {
                                let v140 = C::fits_in_32(ctx, v124);
                                if let Some(v141) = v140 {
                                    let v861 = constructor_gen_xload(ctx, v826, v828, v830, I16, &ExtKind::Zero32);
                                    let v862 = constructor_output_xreg(ctx, v861);
                                    let v863 = Some(v862);
                                    // Rule at src/isa/pulley_shared/lower.isle line 977.
                                    return v863;
                                }
                            }
                        }
                    }
                }
                &Opcode::Sload16 => {
                    let v102 = C::first_result(ctx, arg0);
                    if let Some(v103) = v102 {
                        let v829 = C::mem_flags_data(ctx, v827);
                        if let Some(v830) = v829 {
                            let v104 = C::value_type(ctx, v103);
                            if v104 == I64 {
                                let v889 = constructor_gen_xload(ctx, v826, v828, v830, I16, &ExtKind::Sign64);
                                let v890 = constructor_output_xreg(ctx, v889);
                                let v891 = Some(v890);
                                // Rule at src/isa/pulley_shared/lower.isle line 1004.
                                return v891;
                            }
                            let v123 = C::ty_int(ctx, v104);
                            if let Some(v124) = v123 {
                                let v140 = C::fits_in_32(ctx, v124);
                                if let Some(v141) = v140 {
                                    let v882 = constructor_gen_xload(ctx, v826, v828, v830, I16, &ExtKind::Sign32);
                                    let v883 = constructor_output_xreg(ctx, v882);
                                    let v884 = Some(v883);
                                    // Rule at src/isa/pulley_shared/lower.isle line 995.
                                    return v884;
                                }
                            }
                        }
                    }
                }
                &Opcode::Uload32 => {
                    let v102 = C::first_result(ctx, arg0);
                    if let Some(v103) = v102 {
                        let v829 = C::mem_flags_data(ctx, v827);
                        if let Some(v830) = v829 {
                            let v104 = C::value_type(ctx, v103);
                            if v104 == I64 {
                                let v875 = constructor_gen_xload(ctx, v826, v828, v830, I32, &ExtKind::Zero64);
                                let v876 = constructor_output_xreg(ctx, v875);
                                let v877 = Some(v876);
                                // Rule at src/isa/pulley_shared/lower.isle line 989.
                                return v877;
                            }
                            let v123 = C::ty_int(ctx, v104);
                            if let Some(v124) = v123 {
                                let v140 = C::fits_in_32(ctx, v124);
                                if let Some(v141) = v140 {
                                    let v865 = constructor_gen_xload(ctx, v826, v828, v830, I32, &ExtKind::None);
                                    let v866 = constructor_output_xreg(ctx, v865);
                                    let v867 = Some(v866);
                                    // Rule at src/isa/pulley_shared/lower.isle line 980.
                                    return v867;
                                }
                            }
                        }
                    }
                }
                &Opcode::Sload32 => {
                    let v102 = C::first_result(ctx, arg0);
                    if let Some(v103) = v102 {
                        let v829 = C::mem_flags_data(ctx, v827);
                        if let Some(v830) = v829 {
                            let v104 = C::value_type(ctx, v103);
                            if v104 == I64 {
                                let v892 = constructor_gen_xload(ctx, v826, v828, v830, I32, &ExtKind::Sign64);
                                let v893 = constructor_output_xreg(ctx, v892);
                                let v894 = Some(v893);
                                // Rule at src/isa/pulley_shared/lower.isle line 1007.
                                return v894;
                            }
                            let v123 = C::ty_int(ctx, v104);
                            if let Some(v124) = v123 {
                                let v140 = C::fits_in_32(ctx, v124);
                                if let Some(v141) = v140 {
                                    let v865 = constructor_gen_xload(ctx, v826, v828, v830, I32, &ExtKind::None);
                                    let v866 = constructor_output_xreg(ctx, v865);
                                    let v867 = Some(v866);
                                    // Rule at src/isa/pulley_shared/lower.isle line 998.
                                    return v867;
                                }
                            }
                        }
                    }
                }
                &Opcode::Uload8x8 => {
                    let v102 = C::first_result(ctx, arg0);
                    if let Some(v103) = v102 {
                        let v829 = C::mem_flags_data(ctx, v827);
                        if let Some(v830) = v829 {
                            let v104 = C::value_type(ctx, v103);
                            let v904 = constructor_gen_vload(ctx, v826, v828, v830, v104, &VExtKind::U8x8);
                            let v905 = constructor_output_vreg(ctx, v904);
                            let v906 = Some(v905);
                            // Rule at src/isa/pulley_shared/lower.isle line 1016.
                            return v906;
                        }
                    }
                }
                &Opcode::Sload8x8 => {
                    let v102 = C::first_result(ctx, arg0);
                    if let Some(v103) = v102 {
                        let v829 = C::mem_flags_data(ctx, v827);
                        if let Some(v830) = v829 {
                            let v104 = C::value_type(ctx, v103);
                            let v900 = constructor_gen_vload(ctx, v826, v828, v830, v104, &VExtKind::S8x8);
                            let v901 = constructor_output_vreg(ctx, v900);
                            let v902 = Some(v901);
                            // Rule at src/isa/pulley_shared/lower.isle line 1013.
                            return v902;
                        }
                    }
                }
                &Opcode::Uload16x4 => {
                    let v102 = C::first_result(ctx, arg0);
                    if let Some(v103) = v102 {
                        let v829 = C::mem_flags_data(ctx, v827);
                        if let Some(v830) = v829 {
                            let v104 = C::value_type(ctx, v103);
                            let v912 = constructor_gen_vload(ctx, v826, v828, v830, v104, &VExtKind::U16x4);
                            let v913 = constructor_output_vreg(ctx, v912);
                            let v914 = Some(v913);
                            // Rule at src/isa/pulley_shared/lower.isle line 1022.
                            return v914;
                        }
                    }
                }
                &Opcode::Sload16x4 => {
                    let v102 = C::first_result(ctx, arg0);
                    if let Some(v103) = v102 {
                        let v829 = C::mem_flags_data(ctx, v827);
                        if let Some(v830) = v829 {
                            let v104 = C::value_type(ctx, v103);
                            let v908 = constructor_gen_vload(ctx, v826, v828, v830, v104, &VExtKind::S16x4);
                            let v909 = constructor_output_vreg(ctx, v908);
                            let v910 = Some(v909);
                            // Rule at src/isa/pulley_shared/lower.isle line 1019.
                            return v910;
                        }
                    }
                }
                &Opcode::Uload32x2 => {
                    let v102 = C::first_result(ctx, arg0);
                    if let Some(v103) = v102 {
                        let v829 = C::mem_flags_data(ctx, v827);
                        if let Some(v830) = v829 {
                            let v104 = C::value_type(ctx, v103);
                            let v920 = constructor_gen_vload(ctx, v826, v828, v830, v104, &VExtKind::U32x2);
                            let v921 = constructor_output_vreg(ctx, v920);
                            let v922 = Some(v921);
                            // Rule at src/isa/pulley_shared/lower.isle line 1028.
                            return v922;
                        }
                    }
                }
                &Opcode::Sload32x2 => {
                    let v102 = C::first_result(ctx, arg0);
                    if let Some(v103) = v102 {
                        let v829 = C::mem_flags_data(ctx, v827);
                        if let Some(v830) = v829 {
                            let v104 = C::value_type(ctx, v103);
                            let v916 = constructor_gen_vload(ctx, v826, v828, v830, v104, &VExtKind::S32x2);
                            let v917 = constructor_output_vreg(ctx, v916);
                            let v918 = Some(v917);
                            // Rule at src/isa/pulley_shared/lower.isle line 1025.
                            return v918;
                        }
                    }
                }
                _ => {}
            }
        }
        &InstructionData::LoadNoOffset {
            opcode: ref v1077,
            arg: v1078,
            flags: v1079,
        } => {
            if let &Opcode::Bitcast = v1077 {
                let v102 = C::first_result(ctx, arg0);
                if let Some(v103) = v102 {
                    let v104 = C::value_type(ctx, v103);
                    let v1080 = C::value_type(ctx, v1078);
                    if v104 == v1080 {
                        let v1097 = constructor_output_value(ctx, v1078);
                        let v1098 = Some(v1097);
                        // Rule at src/isa/pulley_shared/lower.isle line 1506.
                        return v1098;
                    }
                    let v592 = C::ty_vec128(ctx, v104);
                    if let Some(v593) = v592 {
                        let v1095 = C::ty_vec128(ctx, v1080);
                        if let Some(v1096) = v1095 {
                            let v1097 = constructor_output_value(ctx, v1078);
                            let v1098 = Some(v1097);
                            // Rule at src/isa/pulley_shared/lower.isle line 1503.
                            return v1098;
                        }
                    }
                    match v104 {
                        I32 => {
                            if v1080 == F32 {
                                let v1088 = constructor_put_in_freg(ctx, v1078);
                                let v1089 = constructor_pulley_bitcast_int_from_float_32(ctx, v1088);
                                let v1090 = constructor_output_xreg(ctx, v1089);
                                let v1091 = Some(v1090);
                                // Rule at src/isa/pulley_shared/lower.isle line 1497.
                                return v1091;
                            }
                        }
                        I64 => {
                            if v1080 == F64 {
                                let v1088 = constructor_put_in_freg(ctx, v1078);
                                let v1092 = constructor_pulley_bitcast_int_from_float_64(ctx, v1088);
                                let v1093 = constructor_output_xreg(ctx, v1092);
                                let v1094 = Some(v1093);
                                // Rule at src/isa/pulley_shared/lower.isle line 1500.
                                return v1094;
                            }
                        }
                        F32 => {
                            if v1080 == I32 {
                                let v1081 = constructor_put_in_xreg(ctx, v1078);
                                let v1082 = constructor_pulley_bitcast_float_from_int_32(ctx, v1081);
                                let v1083 = constructor_output_freg(ctx, v1082);
                                let v1084 = Some(v1083);
                                // Rule at src/isa/pulley_shared/lower.isle line 1491.
                                return v1084;
                            }
                        }
                        F64 => {
                            if v1080 == I64 {
                                let v1081 = constructor_put_in_xreg(ctx, v1078);
                                let v1085 = constructor_pulley_bitcast_float_from_int_64(ctx, v1081);
                                let v1086 = constructor_output_freg(ctx, v1085);
                                let v1087 = Some(v1086);
                                // Rule at src/isa/pulley_shared/lower.isle line 1494.
                                return v1087;
                            }
                        }
                        _ => {}
                    }
                }
            }
        }
        &InstructionData::MultiAry {
            opcode: ref v31,
            args: v32,
        } => {
            if let &Opcode::Return = v31 {
                let v33 = C::value_list_slice(ctx, v32);
                let v34 = constructor_lower_return(ctx, v33);
                let v35 = Some(v34);
                // Rule at src/isa/pulley_shared/lower.isle line 140.
                return v35;
            }
        }
        &InstructionData::NullAry {
            opcode: ref v20,
        } => {
            match v20 {
                &Opcode::GetFramePointer => {
                    let v25 = constructor_pulley_xmov_fp(ctx);
                    let v26 = constructor_output_xreg(ctx, v25);
                    let v27 = Some(v26);
                    // Rule at src/isa/pulley_shared/lower.isle line 131.
                    return v27;
                }
                &Opcode::GetStackPointer => {
                    let v21 = C::sp_reg(ctx);
                    let v22 = constructor_pulley_get_special(ctx, v21);
                    let v23 = constructor_output_xreg(ctx, v22);
                    let v24 = Some(v23);
                    // Rule at src/isa/pulley_shared/lower.isle line 126.
                    return v24;
                }
                &Opcode::GetReturnAddress => {
                    let v28 = constructor_pulley_xmov_lr(ctx);
                    let v29 = constructor_output_xreg(ctx, v28);
                    let v30 = Some(v29);
                    // Rule at src/isa/pulley_shared/lower.isle line 135.
                    return v30;
                }
                &Opcode::SequencePoint => {
                    let v1661 = &constructor_pulley_sequence_point(ctx);
                    let v1662 = constructor_side_effect(ctx, v1661);
                    let v1663 = Some(v1662);
                    // Rule at src/isa/pulley_shared/lower.isle line 1927.
                    return v1663;
                }
                _ => {}
            }
        }
        &InstructionData::Shuffle {
            opcode: ref v1609,
            args: ref v1610,
            imm: v1611,
        } => {
            if let &Opcode::Shuffle = v1609 {
                let v102 = C::first_result(ctx, arg0);
                if let Some(v103) = v102 {
                    let v104 = C::value_type(ctx, v103);
                    if v104 == I8X16 {
                        let v1615 = C::u128_from_immediate(ctx, v1611);
                        if let Some(v1616) = v1615 {
                            let v1612 = C::unpack_value_array_2(ctx, v1610);
                            let v1617 = constructor_put_in_vreg(ctx, v1612.0);
                            let v1618 = constructor_put_in_vreg(ctx, v1612.1);
                            let v1619 = constructor_pulley_vshuffle(ctx, v1617, v1618, v1616);
                            let v1620 = constructor_output_vreg(ctx, v1619);
                            let v1621 = Some(v1620);
                            // Rule at src/isa/pulley_shared/lower.isle line 1896.
                            return v1621;
                        }
                    }
                }
            }
        }
        &InstructionData::StackLoad {
            opcode: ref v971,
            stack_slot: v972,
            offset: v973,
        } => {
            if let &Opcode::StackAddr = v971 {
                let v974 = constructor_lower_stack_addr(ctx, v972, v973);
                let v975 = constructor_output_xreg(ctx, v974);
                let v976 = Some(v975);
                // Rule at src/isa/pulley_shared/lower.isle line 1358.
                return v976;
            }
        }
        &InstructionData::Store {
            opcode: ref v923,
            args: ref v924,
            flags: v925,
            offset: v926,
        } => {
            match v923 {
                &Opcode::Store => {
                    let v935 = C::mem_flags_data(ctx, v925);
                    if let Some(v936) = v935 {
                        let v927 = C::unpack_value_array_2(ctx, v924);
                        let v930 = C::value_type(ctx, v927.0);
                        if v930 == I128 {
                            let v959 = C::put_in_regs(ctx, v927.0);
                            let v960 = C::value_regs_get(ctx, v959, 0x0_usize);
                            let v961 = C::xreg_new(ctx, v960);
                            let v962 = C::value_regs_get(ctx, v959, 0x1_usize);
                            let v963 = C::xreg_new(ctx, v962);
                            let v964 = constructor_put_in_xreg(ctx, v927.1);
                            let v967 = Amode::RegOffset {
                                base: v964,
                                offset: 0_i32,
                            };
                            let v965 = Amode::RegOffset {
                                base: v964,
                                offset: 8_i32,
                            };
                            let v968 = &constructor_emit_store_i128(ctx, v936, v961, v963, &v967, &v965);
                            let v969 = constructor_side_effect(ctx, v968);
                            let v970 = Some(v969);
                            // Rule at src/isa/pulley_shared/lower.isle line 1277.
                            return v970;
                        }
                        let v954 = C::ty_vec128(ctx, v930);
                        if let Some(v955) = v954 {
                            let v956 = &constructor_gen_store(ctx, v927.0, v927.1, v926, v936, v955);
                            let v957 = constructor_side_effect(ctx, v956);
                            let v958 = Some(v957);
                            // Rule at src/isa/pulley_shared/lower.isle line 1272.
                            return v958;
                        }
                        let v940 = C::ty_scalar_float(ctx, v930);
                        if let Some(v941) = v940 {
                            let v942 = &constructor_gen_store(ctx, v927.0, v927.1, v926, v936, v941);
                            let v943 = constructor_side_effect(ctx, v942);
                            let v944 = Some(v943);
                            // Rule at src/isa/pulley_shared/lower.isle line 1260.
                            return v944;
                        }
                        let v931 = C::ty_int(ctx, v930);
                        if let Some(v932) = v931 {
                            let v933 = C::fits_in_64(ctx, v932);
                            if let Some(v934) = v933 {
                                let v937 = &constructor_gen_store(ctx, v927.0, v927.1, v926, v936, v934);
                                let v938 = constructor_side_effect(ctx, v937);
                                let v939 = Some(v938);
                                // Rule at src/isa/pulley_shared/lower.isle line 1257.
                                return v939;
                            }
                        }
                    }
                }
                &Opcode::Istore8 => {
                    let v935 = C::mem_flags_data(ctx, v925);
                    if let Some(v936) = v935 {
                        let v927 = C::unpack_value_array_2(ctx, v924);
                        let v945 = &constructor_gen_store(ctx, v927.0, v927.1, v926, v936, I8);
                        let v946 = constructor_side_effect(ctx, v945);
                        let v947 = Some(v946);
                        // Rule at src/isa/pulley_shared/lower.isle line 1263.
                        return v947;
                    }
                }
                &Opcode::Istore16 => {
                    let v935 = C::mem_flags_data(ctx, v925);
                    if let Some(v936) = v935 {
                        let v927 = C::unpack_value_array_2(ctx, v924);
                        let v948 = &constructor_gen_store(ctx, v927.0, v927.1, v926, v936, I16);
                        let v949 = constructor_side_effect(ctx, v948);
                        let v950 = Some(v949);
                        // Rule at src/isa/pulley_shared/lower.isle line 1266.
                        return v950;
                    }
                }
                &Opcode::Istore32 => {
                    let v935 = C::mem_flags_data(ctx, v925);
                    if let Some(v936) = v935 {
                        let v927 = C::unpack_value_array_2(ctx, v924);
                        let v951 = &constructor_gen_store(ctx, v927.0, v927.1, v926, v936, I32);
                        let v952 = constructor_side_effect(ctx, v951);
                        let v953 = Some(v952);
                        // Rule at src/isa/pulley_shared/lower.isle line 1269.
                        return v953;
                    }
                }
                _ => {}
            }
        }
        &InstructionData::Ternary {
            opcode: ref v652,
            args: ref v653,
        } => {
            match v652 {
                &Opcode::Select => {
                    let v102 = C::first_result(ctx, arg0);
                    if let Some(v103) = v102 {
                        let v104 = C::value_type(ctx, v103);
                        let v592 = C::ty_vec128(ctx, v104);
                        if let Some(v593) = v592 {
                            let v654 = C::unpack_value_array_3(ctx, v653);
                            let v1054 = &constructor_lower_cond(ctx, v654.0);
                            let v1055 = constructor_emit_cond(ctx, v1054);
                            let v1072 = constructor_put_in_vreg(ctx, v654.1);
                            let v1073 = constructor_put_in_vreg(ctx, v654.2);
                            let v1074 = constructor_pulley_vselect(ctx, v1055, v1072, v1073);
                            let v1075 = constructor_output_vreg(ctx, v1074);
                            let v1076 = Some(v1075);
                            // Rule at src/isa/pulley_shared/lower.isle line 1443.
                            return v1076;
                        }
                        match v104 {
                            I64 => {
                                let v654 = C::unpack_value_array_3(ctx, v653);
                                let v1054 = &constructor_lower_cond(ctx, v654.0);
                                let v1055 = constructor_emit_cond(ctx, v1054);
                                let v1056 = constructor_put_in_xreg(ctx, v654.1);
                                let v1057 = constructor_put_in_xreg(ctx, v654.2);
                                let v1061 = constructor_pulley_xselect64(ctx, v1055, v1056, v1057);
                                let v1062 = constructor_output_xreg(ctx, v1061);
                                let v1063 = Some(v1062);
                                // Rule at src/isa/pulley_shared/lower.isle line 1434.
                                return v1063;
                            }
                            F32 => {
                                let v654 = C::unpack_value_array_3(ctx, v653);
                                let v1054 = &constructor_lower_cond(ctx, v654.0);
                                let v1055 = constructor_emit_cond(ctx, v1054);
                                let v1064 = constructor_put_in_freg(ctx, v654.1);
                                let v1065 = constructor_put_in_freg(ctx, v654.2);
                                let v1066 = constructor_pulley_fselect32(ctx, v1055, v1064, v1065);
                                let v1067 = constructor_output_freg(ctx, v1066);
                                let v1068 = Some(v1067);
                                // Rule at src/isa/pulley_shared/lower.isle line 1437.
                                return v1068;
                            }
                            F64 => {
                                let v654 = C::unpack_value_array_3(ctx, v653);
                                let v1054 = &constructor_lower_cond(ctx, v654.0);
                                let v1055 = constructor_emit_cond(ctx, v1054);
                                let v1064 = constructor_put_in_freg(ctx, v654.1);
                                let v1065 = constructor_put_in_freg(ctx, v654.2);
                                let v1069 = constructor_pulley_fselect64(ctx, v1055, v1064, v1065);
                                let v1070 = constructor_output_freg(ctx, v1069);
                                let v1071 = Some(v1070);
                                // Rule at src/isa/pulley_shared/lower.isle line 1440.
                                return v1071;
                            }
                            _ => {}
                        }
                        let v123 = C::ty_int(ctx, v104);
                        if let Some(v124) = v123 {
                            let v140 = C::fits_in_32(ctx, v124);
                            if let Some(v141) = v140 {
                                let v654 = C::unpack_value_array_3(ctx, v653);
                                let v1054 = &constructor_lower_cond(ctx, v654.0);
                                let v1055 = constructor_emit_cond(ctx, v1054);
                                let v1056 = constructor_put_in_xreg(ctx, v654.1);
                                let v1057 = constructor_put_in_xreg(ctx, v654.2);
                                let v1058 = constructor_pulley_xselect32(ctx, v1055, v1056, v1057);
                                let v1059 = constructor_output_xreg(ctx, v1058);
                                let v1060 = Some(v1059);
                                // Rule at src/isa/pulley_shared/lower.isle line 1431.
                                return v1060;
                            }
                        }
                    }
                }
                &Opcode::Bitselect => {
                    let v102 = C::first_result(ctx, arg0);
                    if let Some(v103) = v102 {
                        let v104 = C::value_type(ctx, v103);
                        let v592 = C::ty_vec128(ctx, v104);
                        if let Some(v593) = v592 {
                            let v654 = C::unpack_value_array_3(ctx, v653);
                            let v658 = constructor_put_in_vreg(ctx, v654.0);
                            let v659 = constructor_put_in_vreg(ctx, v654.1);
                            let v660 = constructor_put_in_vreg(ctx, v654.2);
                            let v661 = constructor_pulley_vbitselect128(ctx, v658, v659, v660);
                            let v662 = constructor_output_vreg(ctx, v661);
                            let v663 = Some(v662);
                            // Rule at src/isa/pulley_shared/lower.isle line 655.
                            return v663;
                        }
                    }
                }
                &Opcode::Fma => {
                    let v102 = C::first_result(ctx, arg0);
                    if let Some(v103) = v102 {
                        let v104 = C::value_type(ctx, v103);
                        match v104 {
                            F32X4 => {
                                let v654 = C::unpack_value_array_3(ctx, v653);
                                let v658 = constructor_put_in_vreg(ctx, v654.0);
                                let v659 = constructor_put_in_vreg(ctx, v654.1);
                                let v660 = constructor_put_in_vreg(ctx, v654.2);
                                let v1625 = constructor_pulley_vfma32x4(ctx, v658, v659, v660);
                                let v1626 = constructor_output_vreg(ctx, v1625);
                                let v1627 = Some(v1626);
                                // Rule at src/isa/pulley_shared/lower.isle line 1905.
                                return v1627;
                            }
                            F64X2 => {
                                let v654 = C::unpack_value_array_3(ctx, v653);
                                let v658 = constructor_put_in_vreg(ctx, v654.0);
                                let v659 = constructor_put_in_vreg(ctx, v654.1);
                                let v660 = constructor_put_in_vreg(ctx, v654.2);
                                let v1628 = constructor_pulley_vfma64x2(ctx, v658, v659, v660);
                                let v1629 = constructor_output_vreg(ctx, v1628);
                                let v1630 = Some(v1629);
                                // Rule at src/isa/pulley_shared/lower.isle line 1906.
                                return v1630;
                            }
                            _ => {}
                        }
                    }
                }
                _ => {}
            }
        }
        &InstructionData::TernaryImm8 {
            opcode: ref v1557,
            args: ref v1558,
            imm: v1559,
        } => {
            if let &Opcode::Insertlane = v1557 {
                let v1560 = C::unpack_value_array_2(ctx, v1558);
                let v1563 = C::value_type(ctx, v1560.0);
                match v1563 {
                    I8X16 => {
                        let v1565 = constructor_put_in_vreg(ctx, v1560.0);
                        let v1566 = constructor_put_in_xreg(ctx, v1560.1);
                        let v1564 = C::u8_from_uimm8(ctx, v1559);
                        let v1567 = constructor_pulley_vinsertx8(ctx, v1565, v1566, v1564);
                        let v1568 = constructor_output_vreg(ctx, v1567);
                        let v1569 = Some(v1568);
                        // Rule at src/isa/pulley_shared/lower.isle line 1862.
                        return v1569;
                    }
                    I16X8 => {
                        let v1565 = constructor_put_in_vreg(ctx, v1560.0);
                        let v1566 = constructor_put_in_xreg(ctx, v1560.1);
                        let v1564 = C::u8_from_uimm8(ctx, v1559);
                        let v1570 = constructor_pulley_vinsertx16(ctx, v1565, v1566, v1564);
                        let v1571 = constructor_output_vreg(ctx, v1570);
                        let v1572 = Some(v1571);
                        // Rule at src/isa/pulley_shared/lower.isle line 1864.
                        return v1572;
                    }
                    I32X4 => {
                        let v1565 = constructor_put_in_vreg(ctx, v1560.0);
                        let v1566 = constructor_put_in_xreg(ctx, v1560.1);
                        let v1564 = C::u8_from_uimm8(ctx, v1559);
                        let v1573 = constructor_pulley_vinsertx32(ctx, v1565, v1566, v1564);
                        let v1574 = constructor_output_vreg(ctx, v1573);
                        let v1575 = Some(v1574);
                        // Rule at src/isa/pulley_shared/lower.isle line 1866.
                        return v1575;
                    }
                    I64X2 => {
                        let v1565 = constructor_put_in_vreg(ctx, v1560.0);
                        let v1566 = constructor_put_in_xreg(ctx, v1560.1);
                        let v1564 = C::u8_from_uimm8(ctx, v1559);
                        let v1576 = constructor_pulley_vinsertx64(ctx, v1565, v1566, v1564);
                        let v1577 = constructor_output_vreg(ctx, v1576);
                        let v1578 = Some(v1577);
                        // Rule at src/isa/pulley_shared/lower.isle line 1868.
                        return v1578;
                    }
                    F32X4 => {
                        let v1565 = constructor_put_in_vreg(ctx, v1560.0);
                        let v1579 = constructor_put_in_freg(ctx, v1560.1);
                        let v1564 = C::u8_from_uimm8(ctx, v1559);
                        let v1580 = constructor_pulley_vinsertf32(ctx, v1565, v1579, v1564);
                        let v1581 = constructor_output_vreg(ctx, v1580);
                        let v1582 = Some(v1581);
                        // Rule at src/isa/pulley_shared/lower.isle line 1870.
                        return v1582;
                    }
                    F64X2 => {
                        let v1565 = constructor_put_in_vreg(ctx, v1560.0);
                        let v1579 = constructor_put_in_freg(ctx, v1560.1);
                        let v1564 = C::u8_from_uimm8(ctx, v1559);
                        let v1583 = constructor_pulley_vinsertf64(ctx, v1565, v1579, v1564);
                        let v1584 = constructor_output_vreg(ctx, v1583);
                        let v1585 = Some(v1584);
                        // Rule at src/isa/pulley_shared/lower.isle line 1872.
                        return v1585;
                    }
                    _ => {}
                }
            }
        }
        &InstructionData::Trap {
            opcode: ref v4,
            code: ref v5,
        } => {
            if let &Opcode::Trap = v4 {
                let v6 = &constructor_pulley_trap(ctx, v5);
                let v7 = constructor_side_effect(ctx, v6);
                let v8 = Some(v7);
                // Rule at src/isa/pulley_shared/lower.isle line 113.
                return v8;
            }
        }
        &InstructionData::Unary {
            opcode: ref v639,
            arg: v640,
        } => {
            match v639 {
                &Opcode::Splat => {
                    let v102 = C::first_result(ctx, arg0);
                    if let Some(v103) = v102 {
                        let v104 = C::value_type(ctx, v103);
                        match v104 {
                            I8X16 => {
                                let v641 = constructor_put_in_xreg(ctx, v640);
                                let v1418 = constructor_pulley_vsplatx8(ctx, v641);
                                let v1419 = constructor_output_vreg(ctx, v1418);
                                let v1420 = Some(v1419);
                                // Rule at src/isa/pulley_shared/lower.isle line 1762.
                                return v1420;
                            }
                            I16X8 => {
                                let v641 = constructor_put_in_xreg(ctx, v640);
                                let v1421 = constructor_pulley_vsplatx16(ctx, v641);
                                let v1422 = constructor_output_vreg(ctx, v1421);
                                let v1423 = Some(v1422);
                                // Rule at src/isa/pulley_shared/lower.isle line 1763.
                                return v1423;
                            }
                            I32X4 => {
                                let v641 = constructor_put_in_xreg(ctx, v640);
                                let v1424 = constructor_pulley_vsplatx32(ctx, v641);
                                let v1425 = constructor_output_vreg(ctx, v1424);
                                let v1426 = Some(v1425);
                                // Rule at src/isa/pulley_shared/lower.isle line 1764.
                                return v1426;
                            }
                            I64X2 => {
                                let v641 = constructor_put_in_xreg(ctx, v640);
                                let v1427 = constructor_pulley_vsplatx64(ctx, v641);
                                let v1428 = constructor_output_vreg(ctx, v1427);
                                let v1429 = Some(v1428);
                                // Rule at src/isa/pulley_shared/lower.isle line 1765.
                                return v1429;
                            }
                            F32X4 => {
                                let v1099 = constructor_put_in_freg(ctx, v640);
                                let v1430 = constructor_pulley_vsplatf32(ctx, v1099);
                                let v1431 = constructor_output_vreg(ctx, v1430);
                                let v1432 = Some(v1431);
                                // Rule at src/isa/pulley_shared/lower.isle line 1766.
                                return v1432;
                            }
                            F64X2 => {
                                let v1099 = constructor_put_in_freg(ctx, v640);
                                let v1433 = constructor_pulley_vsplatf64(ctx, v1099);
                                let v1434 = constructor_output_vreg(ctx, v1433);
                                let v1435 = Some(v1434);
                                // Rule at src/isa/pulley_shared/lower.isle line 1767.
                                return v1435;
                            }
                            _ => {}
                        }
                    }
                }
                &Opcode::VanyTrue => {
                    let v724 = C::value_type(ctx, v640);
                    match v724 {
                        I8X16 => {
                            let v648 = constructor_put_in_vreg(ctx, v640);
                            let v1460 = constructor_pulley_vanytrue8x16(ctx, v648);
                            let v1461 = constructor_output_xreg(ctx, v1460);
                            let v1462 = Some(v1461);
                            // Rule at src/isa/pulley_shared/lower.isle line 1791.
                            return v1462;
                        }
                        I16X8 => {
                            let v648 = constructor_put_in_vreg(ctx, v640);
                            let v1463 = constructor_pulley_vanytrue16x8(ctx, v648);
                            let v1464 = constructor_output_xreg(ctx, v1463);
                            let v1465 = Some(v1464);
                            // Rule at src/isa/pulley_shared/lower.isle line 1792.
                            return v1465;
                        }
                        I32X4 => {
                            let v648 = constructor_put_in_vreg(ctx, v640);
                            let v1466 = constructor_pulley_vanytrue32x4(ctx, v648);
                            let v1467 = constructor_output_xreg(ctx, v1466);
                            let v1468 = Some(v1467);
                            // Rule at src/isa/pulley_shared/lower.isle line 1793.
                            return v1468;
                        }
                        I64X2 => {
                            let v648 = constructor_put_in_vreg(ctx, v640);
                            let v1469 = constructor_pulley_vanytrue64x2(ctx, v648);
                            let v1470 = constructor_output_xreg(ctx, v1469);
                            let v1471 = Some(v1470);
                            // Rule at src/isa/pulley_shared/lower.isle line 1794.
                            return v1471;
                        }
                        F32X4 => {
                            let v648 = constructor_put_in_vreg(ctx, v640);
                            let v1466 = constructor_pulley_vanytrue32x4(ctx, v648);
                            let v1467 = constructor_output_xreg(ctx, v1466);
                            let v1468 = Some(v1467);
                            // Rule at src/isa/pulley_shared/lower.isle line 1795.
                            return v1468;
                        }
                        F64X2 => {
                            let v648 = constructor_put_in_vreg(ctx, v640);
                            let v1469 = constructor_pulley_vanytrue64x2(ctx, v648);
                            let v1470 = constructor_output_xreg(ctx, v1469);
                            let v1471 = Some(v1470);
                            // Rule at src/isa/pulley_shared/lower.isle line 1796.
                            return v1471;
                        }
                        _ => {}
                    }
                }
                &Opcode::VallTrue => {
                    let v724 = C::value_type(ctx, v640);
                    match v724 {
                        I8X16 => {
                            let v648 = constructor_put_in_vreg(ctx, v640);
                            let v1448 = constructor_pulley_valltrue8x16(ctx, v648);
                            let v1449 = constructor_output_xreg(ctx, v1448);
                            let v1450 = Some(v1449);
                            // Rule at src/isa/pulley_shared/lower.isle line 1782.
                            return v1450;
                        }
                        I16X8 => {
                            let v648 = constructor_put_in_vreg(ctx, v640);
                            let v1451 = constructor_pulley_valltrue16x8(ctx, v648);
                            let v1452 = constructor_output_xreg(ctx, v1451);
                            let v1453 = Some(v1452);
                            // Rule at src/isa/pulley_shared/lower.isle line 1783.
                            return v1453;
                        }
                        I32X4 => {
                            let v648 = constructor_put_in_vreg(ctx, v640);
                            let v1454 = constructor_pulley_valltrue32x4(ctx, v648);
                            let v1455 = constructor_output_xreg(ctx, v1454);
                            let v1456 = Some(v1455);
                            // Rule at src/isa/pulley_shared/lower.isle line 1784.
                            return v1456;
                        }
                        I64X2 => {
                            let v648 = constructor_put_in_vreg(ctx, v640);
                            let v1457 = constructor_pulley_valltrue64x2(ctx, v648);
                            let v1458 = constructor_output_xreg(ctx, v1457);
                            let v1459 = Some(v1458);
                            // Rule at src/isa/pulley_shared/lower.isle line 1785.
                            return v1459;
                        }
                        F32X4 => {
                            let v648 = constructor_put_in_vreg(ctx, v640);
                            let v1454 = constructor_pulley_valltrue32x4(ctx, v648);
                            let v1455 = constructor_output_xreg(ctx, v1454);
                            let v1456 = Some(v1455);
                            // Rule at src/isa/pulley_shared/lower.isle line 1786.
                            return v1456;
                        }
                        F64X2 => {
                            let v648 = constructor_put_in_vreg(ctx, v640);
                            let v1457 = constructor_pulley_valltrue64x2(ctx, v648);
                            let v1458 = constructor_output_xreg(ctx, v1457);
                            let v1459 = Some(v1458);
                            // Rule at src/isa/pulley_shared/lower.isle line 1787.
                            return v1459;
                        }
                        _ => {}
                    }
                }
                &Opcode::VhighBits => {
                    let v102 = C::first_result(ctx, arg0);
                    if let Some(v103) = v102 {
                        let v104 = C::value_type(ctx, v103);
                        let v446 = C::fits_in_32(ctx, v104);
                        if let Some(v447) = v446 {
                            let v724 = C::value_type(ctx, v640);
                            match v724 {
                                I8X16 => {
                                    let v648 = constructor_put_in_vreg(ctx, v640);
                                    let v1436 = constructor_pulley_vbitmask8x16(ctx, v648);
                                    let v1437 = constructor_output_xreg(ctx, v1436);
                                    let v1438 = Some(v1437);
                                    // Rule at src/isa/pulley_shared/lower.isle line 1771.
                                    return v1438;
                                }
                                I16X8 => {
                                    let v648 = constructor_put_in_vreg(ctx, v640);
                                    let v1439 = constructor_pulley_vbitmask16x8(ctx, v648);
                                    let v1440 = constructor_output_xreg(ctx, v1439);
                                    let v1441 = Some(v1440);
                                    // Rule at src/isa/pulley_shared/lower.isle line 1773.
                                    return v1441;
                                }
                                I32X4 => {
                                    let v648 = constructor_put_in_vreg(ctx, v640);
                                    let v1442 = constructor_pulley_vbitmask32x4(ctx, v648);
                                    let v1443 = constructor_output_xreg(ctx, v1442);
                                    let v1444 = Some(v1443);
                                    // Rule at src/isa/pulley_shared/lower.isle line 1775.
                                    return v1444;
                                }
                                I64X2 => {
                                    let v648 = constructor_put_in_vreg(ctx, v640);
                                    let v1445 = constructor_pulley_vbitmask64x2(ctx, v648);
                                    let v1446 = constructor_output_xreg(ctx, v1445);
                                    let v1447 = Some(v1446);
                                    // Rule at src/isa/pulley_shared/lower.isle line 1777.
                                    return v1447;
                                }
                                _ => {}
                            }
                        }
                    }
                }
                &Opcode::Ineg => {
                    let v102 = C::first_result(ctx, arg0);
                    if let Some(v103) = v102 {
                        let v104 = C::value_type(ctx, v103);
                        match v104 {
                            I64 => {
                                let v641 = constructor_put_in_xreg(ctx, v640);
                                let v1357 = constructor_pulley_xneg64(ctx, v641);
                                let v1358 = constructor_output_xreg(ctx, v1357);
                                let v1359 = Some(v1358);
                                // Rule at src/isa/pulley_shared/lower.isle line 1723.
                                return v1359;
                            }
                            I8X16 => {
                                let v648 = constructor_put_in_vreg(ctx, v640);
                                let v1360 = constructor_pulley_vneg8x16(ctx, v648);
                                let v1361 = constructor_output_vreg(ctx, v1360);
                                let v1362 = Some(v1361);
                                // Rule at src/isa/pulley_shared/lower.isle line 1727.
                                return v1362;
                            }
                            I16X8 => {
                                let v648 = constructor_put_in_vreg(ctx, v640);
                                let v1363 = constructor_pulley_vneg16x8(ctx, v648);
                                let v1364 = constructor_output_vreg(ctx, v1363);
                                let v1365 = Some(v1364);
                                // Rule at src/isa/pulley_shared/lower.isle line 1728.
                                return v1365;
                            }
                            I32X4 => {
                                let v648 = constructor_put_in_vreg(ctx, v640);
                                let v1366 = constructor_pulley_vneg32x4(ctx, v648);
                                let v1367 = constructor_output_vreg(ctx, v1366);
                                let v1368 = Some(v1367);
                                // Rule at src/isa/pulley_shared/lower.isle line 1729.
                                return v1368;
                            }
                            I64X2 => {
                                let v648 = constructor_put_in_vreg(ctx, v640);
                                let v1369 = constructor_pulley_vneg64x2(ctx, v648);
                                let v1370 = constructor_output_vreg(ctx, v1369);
                                let v1371 = Some(v1370);
                                // Rule at src/isa/pulley_shared/lower.isle line 1730.
                                return v1371;
                            }
                            _ => {}
                        }
                        let v446 = C::fits_in_32(ctx, v104);
                        if let Some(v447) = v446 {
                            let v987 = constructor_sext32(ctx, v640);
                            let v1354 = constructor_pulley_xneg32(ctx, v987);
                            let v1355 = constructor_output_xreg(ctx, v1354);
                            let v1356 = Some(v1355);
                            // Rule at src/isa/pulley_shared/lower.isle line 1722.
                            return v1356;
                        }
                    }
                }
                &Opcode::Iabs => {
                    let v102 = C::first_result(ctx, arg0);
                    if let Some(v103) = v102 {
                        let v104 = C::value_type(ctx, v103);
                        match v104 {
                            I64 => {
                                let v641 = constructor_put_in_xreg(ctx, v640);
                                let v1403 = constructor_pulley_xabs64(ctx, v641);
                                let v1404 = constructor_output_xreg(ctx, v1403);
                                let v1405 = Some(v1404);
                                // Rule at src/isa/pulley_shared/lower.isle line 1754.
                                return v1405;
                            }
                            I8X16 => {
                                let v648 = constructor_put_in_vreg(ctx, v640);
                                let v1406 = constructor_pulley_vabs8x16(ctx, v648);
                                let v1407 = constructor_output_vreg(ctx, v1406);
                                let v1408 = Some(v1407);
                                // Rule at src/isa/pulley_shared/lower.isle line 1755.
                                return v1408;
                            }
                            I16X8 => {
                                let v648 = constructor_put_in_vreg(ctx, v640);
                                let v1409 = constructor_pulley_vabs16x8(ctx, v648);
                                let v1410 = constructor_output_vreg(ctx, v1409);
                                let v1411 = Some(v1410);
                                // Rule at src/isa/pulley_shared/lower.isle line 1756.
                                return v1411;
                            }
                            I32X4 => {
                                let v648 = constructor_put_in_vreg(ctx, v640);
                                let v1412 = constructor_pulley_vabs32x4(ctx, v648);
                                let v1413 = constructor_output_vreg(ctx, v1412);
                                let v1414 = Some(v1413);
                                // Rule at src/isa/pulley_shared/lower.isle line 1757.
                                return v1414;
                            }
                            I64X2 => {
                                let v648 = constructor_put_in_vreg(ctx, v640);
                                let v1415 = constructor_pulley_vabs64x2(ctx, v648);
                                let v1416 = constructor_output_vreg(ctx, v1415);
                                let v1417 = Some(v1416);
                                // Rule at src/isa/pulley_shared/lower.isle line 1758.
                                return v1417;
                            }
                            _ => {}
                        }
                        let v446 = C::fits_in_32(ctx, v104);
                        if let Some(v447) = v446 {
                            let v987 = constructor_sext32(ctx, v640);
                            let v1400 = constructor_pulley_xabs32(ctx, v987);
                            let v1401 = constructor_output_xreg(ctx, v1400);
                            let v1402 = Some(v1401);
                            // Rule at src/isa/pulley_shared/lower.isle line 1753.
                            return v1402;
                        }
                    }
                }
                &Opcode::Bnot => {
                    let v102 = C::first_result(ctx, arg0);
                    if let Some(v103) = v102 {
                        let v104 = C::value_type(ctx, v103);
                        let v592 = C::ty_vec128(ctx, v104);
                        if let Some(v593) = v592 {
                            let v648 = constructor_put_in_vreg(ctx, v640);
                            let v649 = constructor_pulley_vbnot128(ctx, v648);
                            let v650 = constructor_output_vreg(ctx, v649);
                            let v651 = Some(v650);
                            // Rule at src/isa/pulley_shared/lower.isle line 650.
                            return v651;
                        }
                        if v104 == I64 {
                            let v641 = constructor_put_in_xreg(ctx, v640);
                            let v645 = constructor_pulley_xbnot64(ctx, v641);
                            let v646 = constructor_output_xreg(ctx, v645);
                            let v647 = Some(v646);
                            // Rule at src/isa/pulley_shared/lower.isle line 647.
                            return v647;
                        }
                        let v446 = C::fits_in_32(ctx, v104);
                        if let Some(v447) = v446 {
                            let v641 = constructor_put_in_xreg(ctx, v640);
                            let v642 = constructor_pulley_xbnot32(ctx, v641);
                            let v643 = constructor_output_xreg(ctx, v642);
                            let v644 = Some(v643);
                            // Rule at src/isa/pulley_shared/lower.isle line 644.
                            return v644;
                        }
                    }
                }
                &Opcode::Clz => {
                    let v102 = C::first_result(ctx, arg0);
                    if let Some(v103) = v102 {
                        let v104 = C::value_type(ctx, v103);
                        match v104 {
                            I8 => {
                                let v727 = constructor_zext32(ctx, v640);
                                let v754 = constructor_pulley_xclz32(ctx, v727);
                                let v756 = constructor_pulley_xsub32_u8(ctx, v754, 0x18_u8);
                                let v757 = constructor_output_xreg(ctx, v756);
                                let v758 = Some(v757);
                                // Rule at src/isa/pulley_shared/lower.isle line 714.
                                return v758;
                            }
                            I16 => {
                                let v727 = constructor_zext32(ctx, v640);
                                let v754 = constructor_pulley_xclz32(ctx, v727);
                                let v760 = constructor_pulley_xsub32_u8(ctx, v754, 0x10_u8);
                                let v761 = constructor_output_xreg(ctx, v760);
                                let v762 = Some(v761);
                                // Rule at src/isa/pulley_shared/lower.isle line 716.
                                return v762;
                            }
                            I32 => {
                                let v641 = constructor_put_in_xreg(ctx, v640);
                                let v763 = constructor_pulley_xclz32(ctx, v641);
                                let v764 = constructor_output_xreg(ctx, v763);
                                let v765 = Some(v764);
                                // Rule at src/isa/pulley_shared/lower.isle line 718.
                                return v765;
                            }
                            I64 => {
                                let v641 = constructor_put_in_xreg(ctx, v640);
                                let v766 = constructor_pulley_xclz64(ctx, v641);
                                let v767 = constructor_output_xreg(ctx, v766);
                                let v768 = Some(v767);
                                // Rule at src/isa/pulley_shared/lower.isle line 719.
                                return v768;
                            }
                            _ => {}
                        }
                    }
                }
                &Opcode::Ctz => {
                    let v102 = C::first_result(ctx, arg0);
                    if let Some(v103) = v102 {
                        let v104 = C::value_type(ctx, v103);
                        match v104 {
                            I8 => {
                                let v641 = constructor_put_in_xreg(ctx, v640);
                                let v739 = constructor_pulley_xbor32_s32(ctx, v641, 256_i32);
                                let v740 = constructor_pulley_xctz32(ctx, v739);
                                let v741 = constructor_output_xreg(ctx, v740);
                                let v742 = Some(v741);
                                // Rule at src/isa/pulley_shared/lower.isle line 705.
                                return v742;
                            }
                            I16 => {
                                let v641 = constructor_put_in_xreg(ctx, v640);
                                let v744 = constructor_pulley_xbor32_s32(ctx, v641, 65536_i32);
                                let v745 = constructor_pulley_xctz32(ctx, v744);
                                let v746 = constructor_output_xreg(ctx, v745);
                                let v747 = Some(v746);
                                // Rule at src/isa/pulley_shared/lower.isle line 707.
                                return v747;
                            }
                            I32 => {
                                let v641 = constructor_put_in_xreg(ctx, v640);
                                let v748 = constructor_pulley_xctz32(ctx, v641);
                                let v749 = constructor_output_xreg(ctx, v748);
                                let v750 = Some(v749);
                                // Rule at src/isa/pulley_shared/lower.isle line 709.
                                return v750;
                            }
                            I64 => {
                                let v641 = constructor_put_in_xreg(ctx, v640);
                                let v751 = constructor_pulley_xctz64(ctx, v641);
                                let v752 = constructor_output_xreg(ctx, v751);
                                let v753 = Some(v752);
                                // Rule at src/isa/pulley_shared/lower.isle line 710.
                                return v753;
                            }
                            _ => {}
                        }
                    }
                }
                &Opcode::Bswap => {
                    let v102 = C::first_result(ctx, arg0);
                    if let Some(v103) = v102 {
                        let v104 = C::value_type(ctx, v103);
                        match v104 {
                            I16 => {
                                let v404 = C::u64_try_into_u8(ctx, 0x10_u64);
                                if let Some(v405) = v404 {
                                    let v406 = C::u6_from_u8(ctx, v405);
                                    if let Some(v407) = v406 {
                                        let v641 = constructor_put_in_xreg(ctx, v640);
                                        let v1391 = constructor_pulley_bswap32(ctx, v641);
                                        let v1392 = constructor_pulley_xshr32_u_u6(ctx, v1391, v407);
                                        let v1393 = constructor_output_xreg(ctx, v1392);
                                        let v1394 = Some(v1393);
                                        // Rule at src/isa/pulley_shared/lower.isle line 1745.
                                        return v1394;
                                    }
                                }
                            }
                            I32 => {
                                let v641 = constructor_put_in_xreg(ctx, v640);
                                let v1391 = constructor_pulley_bswap32(ctx, v641);
                                let v1395 = constructor_output_xreg(ctx, v1391);
                                let v1396 = Some(v1395);
                                // Rule at src/isa/pulley_shared/lower.isle line 1748.
                                return v1396;
                            }
                            I64 => {
                                let v641 = constructor_put_in_xreg(ctx, v640);
                                let v1397 = constructor_pulley_bswap64(ctx, v641);
                                let v1398 = constructor_output_xreg(ctx, v1397);
                                let v1399 = Some(v1398);
                                // Rule at src/isa/pulley_shared/lower.isle line 1749.
                                return v1399;
                            }
                            _ => {}
                        }
                    }
                }
                &Opcode::Popcnt => {
                    let v102 = C::first_result(ctx, arg0);
                    if let Some(v103) = v102 {
                        let v104 = C::value_type(ctx, v103);
                        match v104 {
                            I64 => {
                                let v641 = constructor_put_in_xreg(ctx, v640);
                                let v772 = constructor_pulley_xpopcnt64(ctx, v641);
                                let v773 = constructor_output_xreg(ctx, v772);
                                let v774 = Some(v773);
                                // Rule at src/isa/pulley_shared/lower.isle line 724.
                                return v774;
                            }
                            I8X16 => {
                                let v648 = constructor_put_in_vreg(ctx, v640);
                                let v775 = constructor_pulley_vpopcnt8x16(ctx, v648);
                                let v776 = constructor_output_vreg(ctx, v775);
                                let v777 = Some(v776);
                                // Rule at src/isa/pulley_shared/lower.isle line 725.
                                return v777;
                            }
                            _ => {}
                        }
                        let v446 = C::fits_in_32(ctx, v104);
                        if let Some(v447) = v446 {
                            let v727 = constructor_zext32(ctx, v640);
                            let v769 = constructor_pulley_xpopcnt32(ctx, v727);
                            let v770 = constructor_output_xreg(ctx, v769);
                            let v771 = Some(v770);
                            // Rule at src/isa/pulley_shared/lower.isle line 723.
                            return v771;
                        }
                    }
                }
                &Opcode::Sqrt => {
                    let v102 = C::first_result(ctx, arg0);
                    if let Some(v103) = v102 {
                        let v104 = C::value_type(ctx, v103);
                        match v104 {
                            F32 => {
                                let v1099 = constructor_put_in_freg(ctx, v640);
                                let v1330 = constructor_pulley_fsqrt32(ctx, v1099);
                                let v1331 = constructor_output_freg(ctx, v1330);
                                let v1332 = Some(v1331);
                                // Rule at src/isa/pulley_shared/lower.isle line 1706.
                                return v1332;
                            }
                            F64 => {
                                let v1099 = constructor_put_in_freg(ctx, v640);
                                let v1333 = constructor_pulley_fsqrt64(ctx, v1099);
                                let v1334 = constructor_output_freg(ctx, v1333);
                                let v1335 = Some(v1334);
                                // Rule at src/isa/pulley_shared/lower.isle line 1707.
                                return v1335;
                            }
                            F32X4 => {
                                let v648 = constructor_put_in_vreg(ctx, v640);
                                let v1336 = constructor_pulley_vsqrt32x4(ctx, v648);
                                let v1337 = constructor_output_vreg(ctx, v1336);
                                let v1338 = Some(v1337);
                                // Rule at src/isa/pulley_shared/lower.isle line 1708.
                                return v1338;
                            }
                            F64X2 => {
                                let v648 = constructor_put_in_vreg(ctx, v640);
                                let v1339 = constructor_pulley_vsqrt64x2(ctx, v648);
                                let v1340 = constructor_output_vreg(ctx, v1339);
                                let v1341 = Some(v1340);
                                // Rule at src/isa/pulley_shared/lower.isle line 1710.
                                return v1341;
                            }
                            _ => {}
                        }
                    }
                }
                &Opcode::Fneg => {
                    let v102 = C::first_result(ctx, arg0);
                    if let Some(v103) = v102 {
                        let v104 = C::value_type(ctx, v103);
                        match v104 {
                            F32 => {
                                let v1099 = constructor_put_in_freg(ctx, v640);
                                let v1342 = constructor_pulley_fneg32(ctx, v1099);
                                let v1343 = constructor_output_freg(ctx, v1342);
                                let v1344 = Some(v1343);
                                // Rule at src/isa/pulley_shared/lower.isle line 1715.
                                return v1344;
                            }
                            F64 => {
                                let v1099 = constructor_put_in_freg(ctx, v640);
                                let v1345 = constructor_pulley_fneg64(ctx, v1099);
                                let v1346 = constructor_output_freg(ctx, v1345);
                                let v1347 = Some(v1346);
                                // Rule at src/isa/pulley_shared/lower.isle line 1716.
                                return v1347;
                            }
                            F32X4 => {
                                let v648 = constructor_put_in_vreg(ctx, v640);
                                let v1348 = constructor_pulley_vnegf32x4(ctx, v648);
                                let v1349 = constructor_output_vreg(ctx, v1348);
                                let v1350 = Some(v1349);
                                // Rule at src/isa/pulley_shared/lower.isle line 1717.
                                return v1350;
                            }
                            F64X2 => {
                                let v648 = constructor_put_in_vreg(ctx, v640);
                                let v1351 = constructor_pulley_vnegf64x2(ctx, v648);
                                let v1352 = constructor_output_vreg(ctx, v1351);
                                let v1353 = Some(v1352);
                                // Rule at src/isa/pulley_shared/lower.isle line 1718.
                                return v1353;
                            }
                            _ => {}
                        }
                    }
                }
                &Opcode::Fabs => {
                    let v102 = C::first_result(ctx, arg0);
                    if let Some(v103) = v102 {
                        let v104 = C::value_type(ctx, v103);
                        match v104 {
                            F32 => {
                                let v1099 = constructor_put_in_freg(ctx, v640);
                                let v1372 = constructor_pulley_fabs32(ctx, v1099);
                                let v1373 = constructor_output_freg(ctx, v1372);
                                let v1374 = Some(v1373);
                                // Rule at src/isa/pulley_shared/lower.isle line 1734.
                                return v1374;
                            }
                            F64 => {
                                let v1099 = constructor_put_in_freg(ctx, v640);
                                let v1375 = constructor_pulley_fabs64(ctx, v1099);
                                let v1376 = constructor_output_freg(ctx, v1375);
                                let v1377 = Some(v1376);
                                // Rule at src/isa/pulley_shared/lower.isle line 1735.
                                return v1377;
                            }
                            F32X4 => {
                                let v648 = constructor_put_in_vreg(ctx, v640);
                                let v1378 = constructor_pulley_vabsf32x4(ctx, v648);
                                let v1379 = constructor_output_vreg(ctx, v1378);
                                let v1380 = Some(v1379);
                                // Rule at src/isa/pulley_shared/lower.isle line 1736.
                                return v1380;
                            }
                            F64X2 => {
                                let v648 = constructor_put_in_vreg(ctx, v640);
                                let v1381 = constructor_pulley_vabsf64x2(ctx, v648);
                                let v1382 = constructor_output_vreg(ctx, v1381);
                                let v1383 = Some(v1382);
                                // Rule at src/isa/pulley_shared/lower.isle line 1737.
                                return v1383;
                            }
                            _ => {}
                        }
                    }
                }
                &Opcode::Ceil => {
                    let v102 = C::first_result(ctx, arg0);
                    if let Some(v103) = v102 {
                        let v104 = C::value_type(ctx, v103);
                        match v104 {
                            F32 => {
                                let v1099 = constructor_put_in_freg(ctx, v640);
                                let v1306 = constructor_pulley_fceil32(ctx, v1099);
                                let v1307 = constructor_output_freg(ctx, v1306);
                                let v1308 = Some(v1307);
                                // Rule at src/isa/pulley_shared/lower.isle line 1688.
                                return v1308;
                            }
                            F64 => {
                                let v1099 = constructor_put_in_freg(ctx, v640);
                                let v1309 = constructor_pulley_fceil64(ctx, v1099);
                                let v1310 = constructor_output_freg(ctx, v1309);
                                let v1311 = Some(v1310);
                                // Rule at src/isa/pulley_shared/lower.isle line 1689.
                                return v1311;
                            }
                            F32X4 => {
                                let v648 = constructor_put_in_vreg(ctx, v640);
                                let v1315 = constructor_pulley_vceil32x4(ctx, v648);
                                let v1316 = constructor_output_vreg(ctx, v1315);
                                let v1317 = Some(v1316);
                                // Rule at src/isa/pulley_shared/lower.isle line 1692.
                                return v1317;
                            }
                            F64X2 => {
                                let v648 = constructor_put_in_vreg(ctx, v640);
                                let v1312 = constructor_pulley_vceil64x2(ctx, v648);
                                let v1313 = constructor_output_vreg(ctx, v1312);
                                let v1314 = Some(v1313);
                                // Rule at src/isa/pulley_shared/lower.isle line 1690.
                                return v1314;
                            }
                            _ => {}
                        }
                    }
                }
                &Opcode::Floor => {
                    let v102 = C::first_result(ctx, arg0);
                    if let Some(v103) = v102 {
                        let v104 = C::value_type(ctx, v103);
                        match v104 {
                            F32 => {
                                let v1099 = constructor_put_in_freg(ctx, v640);
                                let v1294 = constructor_pulley_ffloor32(ctx, v1099);
                                let v1295 = constructor_output_freg(ctx, v1294);
                                let v1296 = Some(v1295);
                                // Rule at src/isa/pulley_shared/lower.isle line 1679.
                                return v1296;
                            }
                            F64 => {
                                let v1099 = constructor_put_in_freg(ctx, v640);
                                let v1297 = constructor_pulley_ffloor64(ctx, v1099);
                                let v1298 = constructor_output_freg(ctx, v1297);
                                let v1299 = Some(v1298);
                                // Rule at src/isa/pulley_shared/lower.isle line 1680.
                                return v1299;
                            }
                            F32X4 => {
                                let v648 = constructor_put_in_vreg(ctx, v640);
                                let v1300 = constructor_pulley_vfloor32x4(ctx, v648);
                                let v1301 = constructor_output_vreg(ctx, v1300);
                                let v1302 = Some(v1301);
                                // Rule at src/isa/pulley_shared/lower.isle line 1681.
                                return v1302;
                            }
                            F64X2 => {
                                let v648 = constructor_put_in_vreg(ctx, v640);
                                let v1303 = constructor_pulley_vfloor64x2(ctx, v648);
                                let v1304 = constructor_output_vreg(ctx, v1303);
                                let v1305 = Some(v1304);
                                // Rule at src/isa/pulley_shared/lower.isle line 1683.
                                return v1305;
                            }
                            _ => {}
                        }
                    }
                }
                &Opcode::Trunc => {
                    let v102 = C::first_result(ctx, arg0);
                    if let Some(v103) = v102 {
                        let v104 = C::value_type(ctx, v103);
                        match v104 {
                            F32 => {
                                let v1099 = constructor_put_in_freg(ctx, v640);
                                let v1282 = constructor_pulley_ftrunc32(ctx, v1099);
                                let v1283 = constructor_output_freg(ctx, v1282);
                                let v1284 = Some(v1283);
                                // Rule at src/isa/pulley_shared/lower.isle line 1672.
                                return v1284;
                            }
                            F64 => {
                                let v1099 = constructor_put_in_freg(ctx, v640);
                                let v1285 = constructor_pulley_ftrunc64(ctx, v1099);
                                let v1286 = constructor_output_freg(ctx, v1285);
                                let v1287 = Some(v1286);
                                // Rule at src/isa/pulley_shared/lower.isle line 1673.
                                return v1287;
                            }
                            F32X4 => {
                                let v648 = constructor_put_in_vreg(ctx, v640);
                                let v1288 = constructor_pulley_vtrunc32x4(ctx, v648);
                                let v1289 = constructor_output_vreg(ctx, v1288);
                                let v1290 = Some(v1289);
                                // Rule at src/isa/pulley_shared/lower.isle line 1674.
                                return v1290;
                            }
                            F64X2 => {
                                let v648 = constructor_put_in_vreg(ctx, v640);
                                let v1291 = constructor_pulley_vtrunc64x2(ctx, v648);
                                let v1292 = constructor_output_vreg(ctx, v1291);
                                let v1293 = Some(v1292);
                                // Rule at src/isa/pulley_shared/lower.isle line 1675.
                                return v1293;
                            }
                            _ => {}
                        }
                    }
                }
                &Opcode::Nearest => {
                    let v102 = C::first_result(ctx, arg0);
                    if let Some(v103) = v102 {
                        let v104 = C::value_type(ctx, v103);
                        match v104 {
                            F32 => {
                                let v1099 = constructor_put_in_freg(ctx, v640);
                                let v1318 = constructor_pulley_fnearest32(ctx, v1099);
                                let v1319 = constructor_output_freg(ctx, v1318);
                                let v1320 = Some(v1319);
                                // Rule at src/isa/pulley_shared/lower.isle line 1697.
                                return v1320;
                            }
                            F64 => {
                                let v1099 = constructor_put_in_freg(ctx, v640);
                                let v1321 = constructor_pulley_fnearest64(ctx, v1099);
                                let v1322 = constructor_output_freg(ctx, v1321);
                                let v1323 = Some(v1322);
                                // Rule at src/isa/pulley_shared/lower.isle line 1698.
                                return v1323;
                            }
                            F32X4 => {
                                let v648 = constructor_put_in_vreg(ctx, v640);
                                let v1324 = constructor_pulley_vnearest32x4(ctx, v648);
                                let v1325 = constructor_output_vreg(ctx, v1324);
                                let v1326 = Some(v1325);
                                // Rule at src/isa/pulley_shared/lower.isle line 1699.
                                return v1326;
                            }
                            F64X2 => {
                                let v648 = constructor_put_in_vreg(ctx, v640);
                                let v1327 = constructor_pulley_vnearest64x2(ctx, v648);
                                let v1328 = constructor_output_vreg(ctx, v1327);
                                let v1329 = Some(v1328);
                                // Rule at src/isa/pulley_shared/lower.isle line 1701.
                                return v1329;
                            }
                            _ => {}
                        }
                    }
                }
                &Opcode::ScalarToVector => {
                    let v724 = C::value_type(ctx, v640);
                    match v724 {
                        I8 => {
                            let v1587 = constructor_pulley_vconst128(ctx, 0x0_u128);
                            let v1588 = constructor_put_in_xreg(ctx, v640);
                            let v1590 = constructor_pulley_vinsertx8(ctx, v1587, v1588, 0x0_u8);
                            let v1591 = constructor_output_vreg(ctx, v1590);
                            let v1592 = Some(v1591);
                            // Rule at src/isa/pulley_shared/lower.isle line 1881.
                            return v1592;
                        }
                        I16 => {
                            let v1587 = constructor_pulley_vconst128(ctx, 0x0_u128);
                            let v1588 = constructor_put_in_xreg(ctx, v640);
                            let v1593 = constructor_pulley_vinsertx16(ctx, v1587, v1588, 0x0_u8);
                            let v1594 = constructor_output_vreg(ctx, v1593);
                            let v1595 = Some(v1594);
                            // Rule at src/isa/pulley_shared/lower.isle line 1883.
                            return v1595;
                        }
                        I32 => {
                            let v1587 = constructor_pulley_vconst128(ctx, 0x0_u128);
                            let v1588 = constructor_put_in_xreg(ctx, v640);
                            let v1596 = constructor_pulley_vinsertx32(ctx, v1587, v1588, 0x0_u8);
                            let v1597 = constructor_output_vreg(ctx, v1596);
                            let v1598 = Some(v1597);
                            // Rule at src/isa/pulley_shared/lower.isle line 1885.
                            return v1598;
                        }
                        I64 => {
                            let v1587 = constructor_pulley_vconst128(ctx, 0x0_u128);
                            let v1588 = constructor_put_in_xreg(ctx, v640);
                            let v1599 = constructor_pulley_vinsertx64(ctx, v1587, v1588, 0x0_u8);
                            let v1600 = constructor_output_vreg(ctx, v1599);
                            let v1601 = Some(v1600);
                            // Rule at src/isa/pulley_shared/lower.isle line 1887.
                            return v1601;
                        }
                        F32 => {
                            let v1587 = constructor_pulley_vconst128(ctx, 0x0_u128);
                            let v1602 = constructor_put_in_freg(ctx, v640);
                            let v1603 = constructor_pulley_vinsertf32(ctx, v1587, v1602, 0x0_u8);
                            let v1604 = constructor_output_vreg(ctx, v1603);
                            let v1605 = Some(v1604);
                            // Rule at src/isa/pulley_shared/lower.isle line 1889.
                            return v1605;
                        }
                        F64 => {
                            let v1587 = constructor_pulley_vconst128(ctx, 0x0_u128);
                            let v1602 = constructor_put_in_freg(ctx, v640);
                            let v1606 = constructor_pulley_vinsertf64(ctx, v1587, v1602, 0x0_u8);
                            let v1607 = constructor_output_vreg(ctx, v1606);
                            let v1608 = Some(v1607);
                            // Rule at src/isa/pulley_shared/lower.isle line 1891.
                            return v1608;
                        }
                        _ => {}
                    }
                }
                &Opcode::Bmask => {
                    let v724 = C::value_type(ctx, v640);
                    if v724 == I64 {
                        let v641 = constructor_put_in_xreg(ctx, v640);
                        let v735 = constructor_pulley_xbmask64(ctx, v641);
                        let v736 = constructor_output_xreg(ctx, v735);
                        let v737 = Some(v736);
                        // Rule at src/isa/pulley_shared/lower.isle line 700.
                        return v737;
                    }
                    let v102 = C::first_result(ctx, arg0);
                    if let Some(v103) = v102 {
                        let v104 = C::value_type(ctx, v103);
                        if v104 == I64 {
                            let v731 = constructor_zext64(ctx, v640);
                            let v732 = constructor_pulley_xbmask64(ctx, v731);
                            let v733 = constructor_output_xreg(ctx, v732);
                            let v734 = Some(v733);
                            // Rule at src/isa/pulley_shared/lower.isle line 698.
                            return v734;
                        }
                        let v123 = C::ty_int(ctx, v104);
                        if let Some(v124) = v123 {
                            let v140 = C::fits_in_32(ctx, v124);
                            if let Some(v141) = v140 {
                                let v725 = C::fits_in_32(ctx, v724);
                                if let Some(v726) = v725 {
                                    let v727 = constructor_zext32(ctx, v640);
                                    let v728 = constructor_pulley_xbmask32(ctx, v727);
                                    let v729 = constructor_output_xreg(ctx, v728);
                                    let v730 = Some(v729);
                                    // Rule at src/isa/pulley_shared/lower.isle line 696.
                                    return v730;
                                }
                            }
                        }
                    }
                }
                &Opcode::Ireduce => {
                    let v102 = C::first_result(ctx, arg0);
                    if let Some(v103) = v102 {
                        let v104 = C::value_type(ctx, v103);
                        let v1004 = C::fits_in_64(ctx, v104);
                        if let Some(v1005) = v1004 {
                            let v1006 = constructor_output_value(ctx, v640);
                            let v1007 = Some(v1006);
                            // Rule at src/isa/pulley_shared/lower.isle line 1394.
                            return v1007;
                        }
                    }
                }
                &Opcode::SwidenLow => {
                    let v724 = C::value_type(ctx, v640);
                    match v724 {
                        I8X16 => {
                            let v648 = constructor_put_in_vreg(ctx, v640);
                            let v1472 = constructor_pulley_vwidenlow8x16_s(ctx, v648);
                            let v1473 = constructor_output_vreg(ctx, v1472);
                            let v1474 = Some(v1473);
                            // Rule at src/isa/pulley_shared/lower.isle line 1800.
                            return v1474;
                        }
                        I16X8 => {
                            let v648 = constructor_put_in_vreg(ctx, v640);
                            let v1475 = constructor_pulley_vwidenlow16x8_s(ctx, v648);
                            let v1476 = constructor_output_vreg(ctx, v1475);
                            let v1477 = Some(v1476);
                            // Rule at src/isa/pulley_shared/lower.isle line 1801.
                            return v1477;
                        }
                        I32X4 => {
                            let v648 = constructor_put_in_vreg(ctx, v640);
                            let v1478 = constructor_pulley_vwidenlow32x4_s(ctx, v648);
                            let v1479 = constructor_output_vreg(ctx, v1478);
                            let v1480 = Some(v1479);
                            // Rule at src/isa/pulley_shared/lower.isle line 1802.
                            return v1480;
                        }
                        _ => {}
                    }
                }
                &Opcode::SwidenHigh => {
                    let v724 = C::value_type(ctx, v640);
                    match v724 {
                        I8X16 => {
                            let v648 = constructor_put_in_vreg(ctx, v640);
                            let v1481 = constructor_pulley_vwidenhigh8x16_s(ctx, v648);
                            let v1482 = constructor_output_vreg(ctx, v1481);
                            let v1483 = Some(v1482);
                            // Rule at src/isa/pulley_shared/lower.isle line 1806.
                            return v1483;
                        }
                        I16X8 => {
                            let v648 = constructor_put_in_vreg(ctx, v640);
                            let v1484 = constructor_pulley_vwidenhigh16x8_s(ctx, v648);
                            let v1485 = constructor_output_vreg(ctx, v1484);
                            let v1486 = Some(v1485);
                            // Rule at src/isa/pulley_shared/lower.isle line 1807.
                            return v1486;
                        }
                        I32X4 => {
                            let v648 = constructor_put_in_vreg(ctx, v640);
                            let v1487 = constructor_pulley_vwidenhigh32x4_s(ctx, v648);
                            let v1488 = constructor_output_vreg(ctx, v1487);
                            let v1489 = Some(v1488);
                            // Rule at src/isa/pulley_shared/lower.isle line 1808.
                            return v1489;
                        }
                        _ => {}
                    }
                }
                &Opcode::UwidenLow => {
                    let v724 = C::value_type(ctx, v640);
                    match v724 {
                        I8X16 => {
                            let v648 = constructor_put_in_vreg(ctx, v640);
                            let v1490 = constructor_pulley_vwidenlow8x16_u(ctx, v648);
                            let v1491 = constructor_output_vreg(ctx, v1490);
                            let v1492 = Some(v1491);
                            // Rule at src/isa/pulley_shared/lower.isle line 1812.
                            return v1492;
                        }
                        I16X8 => {
                            let v648 = constructor_put_in_vreg(ctx, v640);
                            let v1493 = constructor_pulley_vwidenlow16x8_u(ctx, v648);
                            let v1494 = constructor_output_vreg(ctx, v1493);
                            let v1495 = Some(v1494);
                            // Rule at src/isa/pulley_shared/lower.isle line 1813.
                            return v1495;
                        }
                        I32X4 => {
                            let v648 = constructor_put_in_vreg(ctx, v640);
                            let v1496 = constructor_pulley_vwidenlow32x4_u(ctx, v648);
                            let v1497 = constructor_output_vreg(ctx, v1496);
                            let v1498 = Some(v1497);
                            // Rule at src/isa/pulley_shared/lower.isle line 1814.
                            return v1498;
                        }
                        _ => {}
                    }
                }
                &Opcode::UwidenHigh => {
                    let v724 = C::value_type(ctx, v640);
                    match v724 {
                        I8X16 => {
                            let v648 = constructor_put_in_vreg(ctx, v640);
                            let v1499 = constructor_pulley_vwidenhigh8x16_u(ctx, v648);
                            let v1500 = constructor_output_vreg(ctx, v1499);
                            let v1501 = Some(v1500);
                            // Rule at src/isa/pulley_shared/lower.isle line 1818.
                            return v1501;
                        }
                        I16X8 => {
                            let v648 = constructor_put_in_vreg(ctx, v640);
                            let v1502 = constructor_pulley_vwidenhigh16x8_u(ctx, v648);
                            let v1503 = constructor_output_vreg(ctx, v1502);
                            let v1504 = Some(v1503);
                            // Rule at src/isa/pulley_shared/lower.isle line 1819.
                            return v1504;
                        }
                        I32X4 => {
                            let v648 = constructor_put_in_vreg(ctx, v640);
                            let v1505 = constructor_pulley_vwidenhigh32x4_u(ctx, v648);
                            let v1506 = constructor_output_vreg(ctx, v1505);
                            let v1507 = Some(v1506);
                            // Rule at src/isa/pulley_shared/lower.isle line 1820.
                            return v1507;
                        }
                        _ => {}
                    }
                }
                &Opcode::Uextend => {
                    let v102 = C::first_result(ctx, arg0);
                    if let Some(v103) = v102 {
                        let v104 = C::value_type(ctx, v103);
                        match v104 {
                            I64 => {
                                let v731 = constructor_zext64(ctx, v640);
                                let v979 = constructor_output_xreg(ctx, v731);
                                let v980 = Some(v979);
                                // Rule at src/isa/pulley_shared/lower.isle line 1372.
                                return v980;
                            }
                            I128 => {
                                let v731 = constructor_zext64(ctx, v640);
                                let v982 = constructor_pulley_xzero(ctx);
                                let v981 = C::xreg_to_reg(ctx, v731);
                                let v983 = C::xreg_to_reg(ctx, v982);
                                let v984 = C::value_regs(ctx, v981, v983);
                                let v985 = C::output(ctx, v984);
                                let v986 = Some(v985);
                                // Rule at src/isa/pulley_shared/lower.isle line 1375.
                                return v986;
                            }
                            _ => {}
                        }
                        let v446 = C::fits_in_32(ctx, v104);
                        if let Some(v447) = v446 {
                            let v727 = constructor_zext32(ctx, v640);
                            let v977 = constructor_output_xreg(ctx, v727);
                            let v978 = Some(v977);
                            // Rule at src/isa/pulley_shared/lower.isle line 1369.
                            return v978;
                        }
                    }
                }
                &Opcode::Sextend => {
                    let v102 = C::first_result(ctx, arg0);
                    if let Some(v103) = v102 {
                        let v104 = C::value_type(ctx, v103);
                        match v104 {
                            I64 => {
                                let v990 = constructor_sext64(ctx, v640);
                                let v991 = constructor_output_xreg(ctx, v990);
                                let v992 = Some(v991);
                                // Rule at src/isa/pulley_shared/lower.isle line 1383.
                                return v992;
                            }
                            I128 => {
                                let v994 = C::u64_try_into_u8(ctx, 0x3f_u64);
                                if let Some(v995) = v994 {
                                    let v996 = C::u6_from_u8(ctx, v995);
                                    if let Some(v997) = v996 {
                                        let v990 = constructor_sext64(ctx, v640);
                                        let v998 = constructor_pulley_xshr64_s_u6(ctx, v990, v997);
                                        let v999 = C::xreg_to_reg(ctx, v990);
                                        let v1000 = C::xreg_to_reg(ctx, v998);
                                        let v1001 = C::value_regs(ctx, v999, v1000);
                                        let v1002 = C::output(ctx, v1001);
                                        let v1003 = Some(v1002);
                                        // Rule at src/isa/pulley_shared/lower.isle line 1386.
                                        return v1003;
                                    }
                                }
                            }
                            _ => {}
                        }
                        let v446 = C::fits_in_32(ctx, v104);
                        if let Some(v447) = v446 {
                            let v987 = constructor_sext32(ctx, v640);
                            let v988 = constructor_output_xreg(ctx, v987);
                            let v989 = Some(v988);
                            // Rule at src/isa/pulley_shared/lower.isle line 1380.
                            return v989;
                        }
                    }
                }
                &Opcode::Fpromote => {
                    let v102 = C::first_result(ctx, arg0);
                    if let Some(v103) = v102 {
                        let v104 = C::value_type(ctx, v103);
                        if v104 == F64 {
                            let v724 = C::value_type(ctx, v640);
                            if v724 == F32 {
                                let v1099 = constructor_put_in_freg(ctx, v640);
                                let v1199 = constructor_pulley_f64_from_f32(ctx, v1099);
                                let v1200 = constructor_output_freg(ctx, v1199);
                                let v1201 = Some(v1200);
                                // Rule at src/isa/pulley_shared/lower.isle line 1617.
                                return v1201;
                            }
                        }
                    }
                }
                &Opcode::Fdemote => {
                    let v102 = C::first_result(ctx, arg0);
                    if let Some(v103) = v102 {
                        let v104 = C::value_type(ctx, v103);
                        if v104 == F32 {
                            let v724 = C::value_type(ctx, v640);
                            if v724 == F64 {
                                let v1099 = constructor_put_in_freg(ctx, v640);
                                let v1196 = constructor_pulley_f32_from_f64(ctx, v1099);
                                let v1197 = constructor_output_freg(ctx, v1196);
                                let v1198 = Some(v1197);
                                // Rule at src/isa/pulley_shared/lower.isle line 1612.
                                return v1198;
                            }
                        }
                    }
                }
                &Opcode::Fvdemote => {
                    let v724 = C::value_type(ctx, v640);
                    if v724 == F64X2 {
                        let v648 = constructor_put_in_vreg(ctx, v640);
                        let v1530 = constructor_pulley_vfdemote(ctx, v648);
                        let v1531 = constructor_output_vreg(ctx, v1530);
                        let v1532 = Some(v1531);
                        // Rule at src/isa/pulley_shared/lower.isle line 1843.
                        return v1532;
                    }
                }
                &Opcode::FvpromoteLow => {
                    let v724 = C::value_type(ctx, v640);
                    if v724 == F32X4 {
                        let v648 = constructor_put_in_vreg(ctx, v640);
                        let v1527 = constructor_pulley_vfpromotelow(ctx, v648);
                        let v1528 = constructor_output_vreg(ctx, v1527);
                        let v1529 = Some(v1528);
                        // Rule at src/isa/pulley_shared/lower.isle line 1839.
                        return v1529;
                    }
                }
                &Opcode::FcvtToUint => {
                    let v102 = C::first_result(ctx, arg0);
                    if let Some(v103) = v102 {
                        let v104 = C::value_type(ctx, v103);
                        match v104 {
                            I32 => {
                                let v724 = C::value_type(ctx, v640);
                                match v724 {
                                    F32 => {
                                        let v1099 = constructor_put_in_freg(ctx, v640);
                                        let v1100 = constructor_pulley_x32_from_f32_u(ctx, v1099);
                                        let v1101 = constructor_output_xreg(ctx, v1100);
                                        let v1102 = Some(v1101);
                                        // Rule at src/isa/pulley_shared/lower.isle line 1510.
                                        return v1102;
                                    }
                                    F64 => {
                                        let v1099 = constructor_put_in_freg(ctx, v640);
                                        let v1103 = constructor_pulley_x32_from_f64_u(ctx, v1099);
                                        let v1104 = constructor_output_xreg(ctx, v1103);
                                        let v1105 = Some(v1104);
                                        // Rule at src/isa/pulley_shared/lower.isle line 1513.
                                        return v1105;
                                    }
                                    _ => {}
                                }
                            }
                            I64 => {
                                let v724 = C::value_type(ctx, v640);
                                match v724 {
                                    F32 => {
                                        let v1099 = constructor_put_in_freg(ctx, v640);
                                        let v1106 = constructor_pulley_x64_from_f32_u(ctx, v1099);
                                        let v1107 = constructor_output_xreg(ctx, v1106);
                                        let v1108 = Some(v1107);
                                        // Rule at src/isa/pulley_shared/lower.isle line 1516.
                                        return v1108;
                                    }
                                    F64 => {
                                        let v1099 = constructor_put_in_freg(ctx, v640);
                                        let v1109 = constructor_pulley_x64_from_f64_u(ctx, v1099);
                                        let v1110 = constructor_output_xreg(ctx, v1109);
                                        let v1111 = Some(v1110);
                                        // Rule at src/isa/pulley_shared/lower.isle line 1519.
                                        return v1111;
                                    }
                                    _ => {}
                                }
                            }
                            _ => {}
                        }
                    }
                }
                &Opcode::FcvtToSint => {
                    let v102 = C::first_result(ctx, arg0);
                    if let Some(v103) = v102 {
                        let v104 = C::value_type(ctx, v103);
                        match v104 {
                            I32 => {
                                let v724 = C::value_type(ctx, v640);
                                match v724 {
                                    F32 => {
                                        let v1099 = constructor_put_in_freg(ctx, v640);
                                        let v1112 = constructor_pulley_x32_from_f32_s(ctx, v1099);
                                        let v1113 = constructor_output_xreg(ctx, v1112);
                                        let v1114 = Some(v1113);
                                        // Rule at src/isa/pulley_shared/lower.isle line 1522.
                                        return v1114;
                                    }
                                    F64 => {
                                        let v1099 = constructor_put_in_freg(ctx, v640);
                                        let v1115 = constructor_pulley_x32_from_f64_s(ctx, v1099);
                                        let v1116 = constructor_output_xreg(ctx, v1115);
                                        let v1117 = Some(v1116);
                                        // Rule at src/isa/pulley_shared/lower.isle line 1525.
                                        return v1117;
                                    }
                                    _ => {}
                                }
                            }
                            I64 => {
                                let v724 = C::value_type(ctx, v640);
                                match v724 {
                                    F32 => {
                                        let v1099 = constructor_put_in_freg(ctx, v640);
                                        let v1118 = constructor_pulley_x64_from_f32_s(ctx, v1099);
                                        let v1119 = constructor_output_xreg(ctx, v1118);
                                        let v1120 = Some(v1119);
                                        // Rule at src/isa/pulley_shared/lower.isle line 1528.
                                        return v1120;
                                    }
                                    F64 => {
                                        let v1099 = constructor_put_in_freg(ctx, v640);
                                        let v1121 = constructor_pulley_x64_from_f64_s(ctx, v1099);
                                        let v1122 = constructor_output_xreg(ctx, v1121);
                                        let v1123 = Some(v1122);
                                        // Rule at src/isa/pulley_shared/lower.isle line 1531.
                                        return v1123;
                                    }
                                    _ => {}
                                }
                            }
                            _ => {}
                        }
                    }
                }
                &Opcode::FcvtToUintSat => {
                    let v102 = C::first_result(ctx, arg0);
                    if let Some(v103) = v102 {
                        let v104 = C::value_type(ctx, v103);
                        match v104 {
                            I32 => {
                                let v724 = C::value_type(ctx, v640);
                                match v724 {
                                    F32 => {
                                        let v1099 = constructor_put_in_freg(ctx, v640);
                                        let v1160 = constructor_pulley_x32_from_f32_u_sat(ctx, v1099);
                                        let v1161 = constructor_output_xreg(ctx, v1160);
                                        let v1162 = Some(v1161);
                                        // Rule at src/isa/pulley_shared/lower.isle line 1574.
                                        return v1162;
                                    }
                                    F64 => {
                                        let v1099 = constructor_put_in_freg(ctx, v640);
                                        let v1163 = constructor_pulley_x32_from_f64_u_sat(ctx, v1099);
                                        let v1164 = constructor_output_xreg(ctx, v1163);
                                        let v1165 = Some(v1164);
                                        // Rule at src/isa/pulley_shared/lower.isle line 1577.
                                        return v1165;
                                    }
                                    _ => {}
                                }
                            }
                            I64 => {
                                let v724 = C::value_type(ctx, v640);
                                match v724 {
                                    F32 => {
                                        let v1099 = constructor_put_in_freg(ctx, v640);
                                        let v1166 = constructor_pulley_x64_from_f32_u_sat(ctx, v1099);
                                        let v1167 = constructor_output_xreg(ctx, v1166);
                                        let v1168 = Some(v1167);
                                        // Rule at src/isa/pulley_shared/lower.isle line 1580.
                                        return v1168;
                                    }
                                    F64 => {
                                        let v1099 = constructor_put_in_freg(ctx, v640);
                                        let v1169 = constructor_pulley_x64_from_f64_u_sat(ctx, v1099);
                                        let v1170 = constructor_output_xreg(ctx, v1169);
                                        let v1171 = Some(v1170);
                                        // Rule at src/isa/pulley_shared/lower.isle line 1583.
                                        return v1171;
                                    }
                                    _ => {}
                                }
                            }
                            I32X4 => {
                                let v724 = C::value_type(ctx, v640);
                                if v724 == F32X4 {
                                    let v648 = constructor_put_in_vreg(ctx, v640);
                                    let v1187 = constructor_pulley_vi32x4_from_f32x4_u(ctx, v648);
                                    let v1188 = constructor_output_vreg(ctx, v1187);
                                    let v1189 = Some(v1188);
                                    // Rule at src/isa/pulley_shared/lower.isle line 1601.
                                    return v1189;
                                }
                            }
                            I64X2 => {
                                let v724 = C::value_type(ctx, v640);
                                if v724 == F64X2 {
                                    let v648 = constructor_put_in_vreg(ctx, v640);
                                    let v1193 = constructor_pulley_vi64x2_from_f64x2_u(ctx, v648);
                                    let v1194 = constructor_output_vreg(ctx, v1193);
                                    let v1195 = Some(v1194);
                                    // Rule at src/isa/pulley_shared/lower.isle line 1607.
                                    return v1195;
                                }
                            }
                            _ => {}
                        }
                    }
                }
                &Opcode::FcvtToSintSat => {
                    let v102 = C::first_result(ctx, arg0);
                    if let Some(v103) = v102 {
                        let v104 = C::value_type(ctx, v103);
                        match v104 {
                            I32 => {
                                let v724 = C::value_type(ctx, v640);
                                match v724 {
                                    F32 => {
                                        let v1099 = constructor_put_in_freg(ctx, v640);
                                        let v1172 = constructor_pulley_x32_from_f32_s_sat(ctx, v1099);
                                        let v1173 = constructor_output_xreg(ctx, v1172);
                                        let v1174 = Some(v1173);
                                        // Rule at src/isa/pulley_shared/lower.isle line 1586.
                                        return v1174;
                                    }
                                    F64 => {
                                        let v1099 = constructor_put_in_freg(ctx, v640);
                                        let v1175 = constructor_pulley_x32_from_f64_s_sat(ctx, v1099);
                                        let v1176 = constructor_output_xreg(ctx, v1175);
                                        let v1177 = Some(v1176);
                                        // Rule at src/isa/pulley_shared/lower.isle line 1589.
                                        return v1177;
                                    }
                                    _ => {}
                                }
                            }
                            I64 => {
                                let v724 = C::value_type(ctx, v640);
                                match v724 {
                                    F32 => {
                                        let v1099 = constructor_put_in_freg(ctx, v640);
                                        let v1178 = constructor_pulley_x64_from_f32_s_sat(ctx, v1099);
                                        let v1179 = constructor_output_xreg(ctx, v1178);
                                        let v1180 = Some(v1179);
                                        // Rule at src/isa/pulley_shared/lower.isle line 1592.
                                        return v1180;
                                    }
                                    F64 => {
                                        let v1099 = constructor_put_in_freg(ctx, v640);
                                        let v1181 = constructor_pulley_x64_from_f64_s_sat(ctx, v1099);
                                        let v1182 = constructor_output_xreg(ctx, v1181);
                                        let v1183 = Some(v1182);
                                        // Rule at src/isa/pulley_shared/lower.isle line 1595.
                                        return v1183;
                                    }
                                    _ => {}
                                }
                            }
                            I32X4 => {
                                let v724 = C::value_type(ctx, v640);
                                if v724 == F32X4 {
                                    let v648 = constructor_put_in_vreg(ctx, v640);
                                    let v1184 = constructor_pulley_vi32x4_from_f32x4_s(ctx, v648);
                                    let v1185 = constructor_output_vreg(ctx, v1184);
                                    let v1186 = Some(v1185);
                                    // Rule at src/isa/pulley_shared/lower.isle line 1598.
                                    return v1186;
                                }
                            }
                            I64X2 => {
                                let v724 = C::value_type(ctx, v640);
                                if v724 == F64X2 {
                                    let v648 = constructor_put_in_vreg(ctx, v640);
                                    let v1190 = constructor_pulley_vi64x2_from_f64x2_s(ctx, v648);
                                    let v1191 = constructor_output_vreg(ctx, v1190);
                                    let v1192 = Some(v1191);
                                    // Rule at src/isa/pulley_shared/lower.isle line 1604.
                                    return v1192;
                                }
                            }
                            _ => {}
                        }
                    }
                }
                &Opcode::FcvtFromUint => {
                    let v102 = C::first_result(ctx, arg0);
                    if let Some(v103) = v102 {
                        let v104 = C::value_type(ctx, v103);
                        match v104 {
                            F32 => {
                                let v724 = C::value_type(ctx, v640);
                                if v724 == I64 {
                                    let v641 = constructor_put_in_xreg(ctx, v640);
                                    let v1127 = constructor_pulley_f32_from_x64_u(ctx, v641);
                                    let v1128 = constructor_output_freg(ctx, v1127);
                                    let v1129 = Some(v1128);
                                    // Rule at src/isa/pulley_shared/lower.isle line 1539.
                                    return v1129;
                                }
                                let v725 = C::fits_in_32(ctx, v724);
                                if let Some(v726) = v725 {
                                    let v727 = constructor_zext32(ctx, v640);
                                    let v1124 = constructor_pulley_f32_from_x32_u(ctx, v727);
                                    let v1125 = constructor_output_freg(ctx, v1124);
                                    let v1126 = Some(v1125);
                                    // Rule at src/isa/pulley_shared/lower.isle line 1536.
                                    return v1126;
                                }
                            }
                            F64 => {
                                let v724 = C::value_type(ctx, v640);
                                if v724 == I64 {
                                    let v641 = constructor_put_in_xreg(ctx, v640);
                                    let v1133 = constructor_pulley_f64_from_x64_u(ctx, v641);
                                    let v1134 = constructor_output_freg(ctx, v1133);
                                    let v1135 = Some(v1134);
                                    // Rule at src/isa/pulley_shared/lower.isle line 1545.
                                    return v1135;
                                }
                                let v725 = C::fits_in_32(ctx, v724);
                                if let Some(v726) = v725 {
                                    let v727 = constructor_zext32(ctx, v640);
                                    let v1130 = constructor_pulley_f64_from_x32_u(ctx, v727);
                                    let v1131 = constructor_output_freg(ctx, v1130);
                                    let v1132 = Some(v1131);
                                    // Rule at src/isa/pulley_shared/lower.isle line 1542.
                                    return v1132;
                                }
                            }
                            F32X4 => {
                                let v724 = C::value_type(ctx, v640);
                                if v724 == I32X4 {
                                    let v648 = constructor_put_in_vreg(ctx, v640);
                                    let v1151 = constructor_pulley_vf32x4_from_i32x4_u(ctx, v648);
                                    let v1152 = constructor_output_vreg(ctx, v1151);
                                    let v1153 = Some(v1152);
                                    // Rule at src/isa/pulley_shared/lower.isle line 1563.
                                    return v1153;
                                }
                            }
                            F64X2 => {
                                let v724 = C::value_type(ctx, v640);
                                if v724 == I64X2 {
                                    let v648 = constructor_put_in_vreg(ctx, v640);
                                    let v1157 = constructor_pulley_vf64x2_from_i64x2_u(ctx, v648);
                                    let v1158 = constructor_output_vreg(ctx, v1157);
                                    let v1159 = Some(v1158);
                                    // Rule at src/isa/pulley_shared/lower.isle line 1569.
                                    return v1159;
                                }
                            }
                            _ => {}
                        }
                    }
                }
                &Opcode::FcvtFromSint => {
                    let v102 = C::first_result(ctx, arg0);
                    if let Some(v103) = v102 {
                        let v104 = C::value_type(ctx, v103);
                        match v104 {
                            F32 => {
                                let v724 = C::value_type(ctx, v640);
                                if v724 == I64 {
                                    let v641 = constructor_put_in_xreg(ctx, v640);
                                    let v1139 = constructor_pulley_f32_from_x64_s(ctx, v641);
                                    let v1140 = constructor_output_freg(ctx, v1139);
                                    let v1141 = Some(v1140);
                                    // Rule at src/isa/pulley_shared/lower.isle line 1551.
                                    return v1141;
                                }
                                let v725 = C::fits_in_32(ctx, v724);
                                if let Some(v726) = v725 {
                                    let v987 = constructor_sext32(ctx, v640);
                                    let v1136 = constructor_pulley_f32_from_x32_s(ctx, v987);
                                    let v1137 = constructor_output_freg(ctx, v1136);
                                    let v1138 = Some(v1137);
                                    // Rule at src/isa/pulley_shared/lower.isle line 1548.
                                    return v1138;
                                }
                            }
                            F64 => {
                                let v724 = C::value_type(ctx, v640);
                                if v724 == I64 {
                                    let v641 = constructor_put_in_xreg(ctx, v640);
                                    let v1145 = constructor_pulley_f64_from_x64_s(ctx, v641);
                                    let v1146 = constructor_output_freg(ctx, v1145);
                                    let v1147 = Some(v1146);
                                    // Rule at src/isa/pulley_shared/lower.isle line 1557.
                                    return v1147;
                                }
                                let v725 = C::fits_in_32(ctx, v724);
                                if let Some(v726) = v725 {
                                    let v987 = constructor_sext32(ctx, v640);
                                    let v1142 = constructor_pulley_f64_from_x32_s(ctx, v987);
                                    let v1143 = constructor_output_freg(ctx, v1142);
                                    let v1144 = Some(v1143);
                                    // Rule at src/isa/pulley_shared/lower.isle line 1554.
                                    return v1144;
                                }
                            }
                            F32X4 => {
                                let v724 = C::value_type(ctx, v640);
                                if v724 == I32X4 {
                                    let v648 = constructor_put_in_vreg(ctx, v640);
                                    let v1148 = constructor_pulley_vf32x4_from_i32x4_s(ctx, v648);
                                    let v1149 = constructor_output_vreg(ctx, v1148);
                                    let v1150 = Some(v1149);
                                    // Rule at src/isa/pulley_shared/lower.isle line 1560.
                                    return v1150;
                                }
                            }
                            F64X2 => {
                                let v724 = C::value_type(ctx, v640);
                                if v724 == I64X2 {
                                    let v648 = constructor_put_in_vreg(ctx, v640);
                                    let v1154 = constructor_pulley_vf64x2_from_i64x2_s(ctx, v648);
                                    let v1155 = constructor_output_vreg(ctx, v1154);
                                    let v1156 = Some(v1155);
                                    // Rule at src/isa/pulley_shared/lower.isle line 1566.
                                    return v1156;
                                }
                            }
                            _ => {}
                        }
                    }
                }
                &Opcode::Isplit => {
                    let v724 = C::value_type(ctx, v640);
                    if v724 == I128 {
                        let v1013 = C::put_in_regs(ctx, v640);
                        let v1014 = C::value_regs_get(ctx, v1013, 0x0_usize);
                        let v1015 = C::xreg_new(ctx, v1014);
                        let v1016 = C::put_in_regs(ctx, v640);
                        let v1017 = C::value_regs_get(ctx, v1016, 0x1_usize);
                        let v1018 = C::xreg_new(ctx, v1017);
                        let v1019 = C::xreg_to_reg(ctx, v1015);
                        let v1020 = C::value_reg(ctx, v1019);
                        let v1021 = C::xreg_to_reg(ctx, v1018);
                        let v1022 = C::value_reg(ctx, v1021);
                        let v1023 = C::output_pair(ctx, v1020, v1022);
                        let v1024 = Some(v1023);
                        // Rule at src/isa/pulley_shared/lower.isle line 1404.
                        return v1024;
                    }
                }
                _ => {}
            }
        }
        &InstructionData::UnaryConst {
            opcode: ref v1384,
            constant_handle: v1385,
        } => {
            if let &Opcode::Vconst = v1384 {
                let v102 = C::first_result(ctx, arg0);
                if let Some(v103) = v102 {
                    let v104 = C::value_type(ctx, v103);
                    let v592 = C::ty_vec128(ctx, v104);
                    if let Some(v593) = v592 {
                        let v1386 = C::u128_from_constant(ctx, v1385);
                        if let Some(v1387) = v1386 {
                            let v1388 = constructor_pulley_vconst128(ctx, v1387);
                            let v1389 = constructor_output_vreg(ctx, v1388);
                            let v1390 = Some(v1389);
                            // Rule at src/isa/pulley_shared/lower.isle line 1741.
                            return v1390;
                        }
                    }
                }
            }
        }
        &InstructionData::UnaryGlobalValue {
            opcode: ref v1631,
            global_value: v1632,
        } => {
            if let &Opcode::SymbolValue = v1631 {
                let v1633 = C::symbol_value_data(ctx, v1632);
                if let Some(v1634) = v1633 {
                    let v1638 = C::box_external_name(ctx, v1634.0);
                    let v1639 = constructor_load_ext_name(ctx, v1638, v1634.2, &v1634.1);
                    let v1640 = constructor_output_xreg(ctx, v1639);
                    let v1641 = Some(v1640);
                    // Rule at src/isa/pulley_shared/lower.isle line 1910.
                    return v1641;
                }
            }
        }
        &InstructionData::UnaryIeee32 {
            opcode: ref v111,
            imm: v112,
        } => {
            if let &Opcode::F32const = v111 {
                let v113 = C::u32_from_ieee32(ctx, v112);
                let v114 = constructor_pulley_fconst32(ctx, v113);
                let v115 = constructor_output_freg(ctx, v114);
                let v116 = Some(v115);
                // Rule at src/isa/pulley_shared/lower.isle line 238.
                return v116;
            }
        }
        &InstructionData::UnaryIeee64 {
            opcode: ref v117,
            imm: v118,
        } => {
            if let &Opcode::F64const = v117 {
                let v119 = C::u64_from_ieee64(ctx, v118);
                let v120 = constructor_pulley_fconst64(ctx, v119);
                let v121 = constructor_output_freg(ctx, v120);
                let v122 = Some(v121);
                // Rule at src/isa/pulley_shared/lower.isle line 242.
                return v122;
            }
        }
        &InstructionData::UnaryImm {
            opcode: ref v105,
            imm: v106,
        } => {
            if let &Opcode::Iconst = v105 {
                let v102 = C::first_result(ctx, arg0);
                if let Some(v103) = v102 {
                    let v104 = C::value_type(ctx, v103);
                    let v107 = C::i64_sextend_imm64(ctx, v104, v106);
                    let v108 = constructor_imm(ctx, v107);
                    let v109 = constructor_output_reg(ctx, v108);
                    let v110 = Some(v109);
                    // Rule at src/isa/pulley_shared/lower.isle line 234.
                    return v110;
                }
            }
        }
        _ => {}
    }
    None
}

// Generated as internal constructor for term lower_cond.
pub fn constructor_lower_cond<C: Context>(
    ctx: &mut C,
    arg0: Value,
) -> Cond {
    let v9 = C::def_inst(ctx, arg0);
    if let Some(v10) = v9 {
        let v11 = C::inst_data_value(ctx, v10);
        match &v11.1 {
            &InstructionData::IntCompare {
                opcode: ref v17,
                args: ref v18,
                cond: ref v19,
            } => {
                if let &Opcode::Icmp = v17 {
                    let v20 = C::unpack_value_array_2(ctx, v18);
                    let v23 = C::value_type(ctx, v20.1);
                    match v23 {
                        I32 => {
                            let v24 = &constructor_lower_cond_icmp32(ctx, v19, v20.0, v20.1);
                            // Rule at src/isa/pulley_shared/lower.isle line 24.
                            return v24.clone();
                        }
                        I64 => {
                            let v25 = &constructor_lower_cond_icmp64(ctx, v19, v20.0, v20.1);
                            // Rule at src/isa/pulley_shared/lower.isle line 25.
                            return v25.clone();
                        }
                        _ => {}
                    }
                }
            }
            &InstructionData::Unary {
                opcode: ref v14,
                arg: v15,
            } => {
                if let &Opcode::Uextend = v14 {
                    let v16 = &constructor_lower_cond(ctx, v15);
                    // Rule at src/isa/pulley_shared/lower.isle line 22.
                    return v16.clone();
                }
            }
            _ => {}
        }
    }
    let v1 = C::value_type(ctx, arg0);
    if v1 == I64 {
        let v6 = constructor_put_in_xreg(ctx, arg0);
        let v8 = Cond::IfXneq64I32 {
            src1: v6,
            src2: 0_i32,
        };
        // Rule at src/isa/pulley_shared/lower.isle line 18.
        return v8;
    }
    let v2 = C::fits_in_32(ctx, v1);
    if let Some(v3) = v2 {
        let v4 = constructor_zext32(ctx, arg0);
        let v5 = Cond::If32 {
            reg: v4,
        };
        // Rule at src/isa/pulley_shared/lower.isle line 17.
        return v5;
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "lower_cond", "src/isa/pulley_shared/lower.isle line 16")
}

// Generated as internal constructor for term lower_cond_icmp32.
pub fn constructor_lower_cond_icmp32<C: Context>(
    ctx: &mut C,
    arg0: &IntCC,
    arg1: Value,
    arg2: Value,
) -> Cond {
    match arg0 {
        &IntCC::Equal => {
            let v17 = C::i64_from_iconst(ctx, arg2);
            if let Some(v18) = v17 {
                let v19 = C::i64_from_i32(ctx, v18);
                if let Some(v20) = v19 {
                    let v3 = constructor_put_in_xreg(ctx, arg1);
                    let v21 = Cond::IfXeq32I32 {
                        src1: v3,
                        src2: v20,
                    };
                    // Rule at src/isa/pulley_shared/lower.isle line 40.
                    return v21;
                }
            }
            let v3 = constructor_put_in_xreg(ctx, arg1);
            let v4 = constructor_put_in_xreg(ctx, arg2);
            let v5 = Cond::IfXeq32 {
                src1: v3,
                src2: v4,
            };
            // Rule at src/isa/pulley_shared/lower.isle line 28.
            return v5;
        }
        &IntCC::NotEqual => {
            let v17 = C::i64_from_iconst(ctx, arg2);
            if let Some(v18) = v17 {
                let v19 = C::i64_from_i32(ctx, v18);
                if let Some(v20) = v19 {
                    let v3 = constructor_put_in_xreg(ctx, arg1);
                    let v22 = Cond::IfXneq32I32 {
                        src1: v3,
                        src2: v20,
                    };
                    // Rule at src/isa/pulley_shared/lower.isle line 42.
                    return v22;
                }
            }
            let v3 = constructor_put_in_xreg(ctx, arg1);
            let v4 = constructor_put_in_xreg(ctx, arg2);
            let v6 = Cond::IfXneq32 {
                src1: v3,
                src2: v4,
            };
            // Rule at src/isa/pulley_shared/lower.isle line 29.
            return v6;
        }
        &IntCC::SignedGreaterThan => {
            let v17 = C::i64_from_iconst(ctx, arg2);
            if let Some(v18) = v17 {
                let v19 = C::i64_from_i32(ctx, v18);
                if let Some(v20) = v19 {
                    let v3 = constructor_put_in_xreg(ctx, arg1);
                    let v25 = Cond::IfXsgt32I32 {
                        src1: v3,
                        src2: v20,
                    };
                    // Rule at src/isa/pulley_shared/lower.isle line 48.
                    return v25;
                }
            }
            let v11 = constructor_put_in_xreg(ctx, arg2);
            let v12 = constructor_put_in_xreg(ctx, arg1);
            let v13 = Cond::IfXslt32 {
                src1: v11,
                src2: v12,
            };
            // Rule at src/isa/pulley_shared/lower.isle line 35.
            return v13;
        }
        &IntCC::SignedGreaterThanOrEqual => {
            let v17 = C::i64_from_iconst(ctx, arg2);
            if let Some(v18) = v17 {
                let v19 = C::i64_from_i32(ctx, v18);
                if let Some(v20) = v19 {
                    let v3 = constructor_put_in_xreg(ctx, arg1);
                    let v26 = Cond::IfXsgteq32I32 {
                        src1: v3,
                        src2: v20,
                    };
                    // Rule at src/isa/pulley_shared/lower.isle line 50.
                    return v26;
                }
            }
            let v11 = constructor_put_in_xreg(ctx, arg2);
            let v12 = constructor_put_in_xreg(ctx, arg1);
            let v14 = Cond::IfXslteq32 {
                src1: v11,
                src2: v12,
            };
            // Rule at src/isa/pulley_shared/lower.isle line 36.
            return v14;
        }
        &IntCC::SignedLessThan => {
            let v17 = C::i64_from_iconst(ctx, arg2);
            if let Some(v18) = v17 {
                let v19 = C::i64_from_i32(ctx, v18);
                if let Some(v20) = v19 {
                    let v3 = constructor_put_in_xreg(ctx, arg1);
                    let v23 = Cond::IfXslt32I32 {
                        src1: v3,
                        src2: v20,
                    };
                    // Rule at src/isa/pulley_shared/lower.isle line 44.
                    return v23;
                }
            }
            let v3 = constructor_put_in_xreg(ctx, arg1);
            let v4 = constructor_put_in_xreg(ctx, arg2);
            let v7 = Cond::IfXslt32 {
                src1: v3,
                src2: v4,
            };
            // Rule at src/isa/pulley_shared/lower.isle line 30.
            return v7;
        }
        &IntCC::SignedLessThanOrEqual => {
            let v17 = C::i64_from_iconst(ctx, arg2);
            if let Some(v18) = v17 {
                let v19 = C::i64_from_i32(ctx, v18);
                if let Some(v20) = v19 {
                    let v3 = constructor_put_in_xreg(ctx, arg1);
                    let v24 = Cond::IfXslteq32I32 {
                        src1: v3,
                        src2: v20,
                    };
                    // Rule at src/isa/pulley_shared/lower.isle line 46.
                    return v24;
                }
            }
            let v3 = constructor_put_in_xreg(ctx, arg1);
            let v4 = constructor_put_in_xreg(ctx, arg2);
            let v8 = Cond::IfXslteq32 {
                src1: v3,
                src2: v4,
            };
            // Rule at src/isa/pulley_shared/lower.isle line 31.
            return v8;
        }
        &IntCC::UnsignedGreaterThan => {
            let v27 = C::def_inst(ctx, arg2);
            if let Some(v28) = v27 {
                let v29 = C::inst_data_value(ctx, v28);
                if let &InstructionData::UnaryImm {
                    opcode: ref v32,
                    imm: v33,
                } = &v29.1 {
                    if let &Opcode::Iconst = v32 {
                        let v34 = C::u64_from_imm64(ctx, v33);
                        let v35 = C::u64_from_u32(ctx, v34);
                        if let Some(v36) = v35 {
                            let v3 = constructor_put_in_xreg(ctx, arg1);
                            let v39 = Cond::IfXugt32I32 {
                                src1: v3,
                                src2: v36,
                            };
                            // Rule at src/isa/pulley_shared/lower.isle line 56.
                            return v39;
                        }
                    }
                }
            }
            let v11 = constructor_put_in_xreg(ctx, arg2);
            let v12 = constructor_put_in_xreg(ctx, arg1);
            let v15 = Cond::IfXult32 {
                src1: v11,
                src2: v12,
            };
            // Rule at src/isa/pulley_shared/lower.isle line 37.
            return v15;
        }
        &IntCC::UnsignedGreaterThanOrEqual => {
            let v27 = C::def_inst(ctx, arg2);
            if let Some(v28) = v27 {
                let v29 = C::inst_data_value(ctx, v28);
                if let &InstructionData::UnaryImm {
                    opcode: ref v32,
                    imm: v33,
                } = &v29.1 {
                    if let &Opcode::Iconst = v32 {
                        let v34 = C::u64_from_imm64(ctx, v33);
                        let v35 = C::u64_from_u32(ctx, v34);
                        if let Some(v36) = v35 {
                            let v3 = constructor_put_in_xreg(ctx, arg1);
                            let v40 = Cond::IfXugteq32I32 {
                                src1: v3,
                                src2: v36,
                            };
                            // Rule at src/isa/pulley_shared/lower.isle line 58.
                            return v40;
                        }
                    }
                }
            }
            let v11 = constructor_put_in_xreg(ctx, arg2);
            let v12 = constructor_put_in_xreg(ctx, arg1);
            let v16 = Cond::IfXulteq32 {
                src1: v11,
                src2: v12,
            };
            // Rule at src/isa/pulley_shared/lower.isle line 38.
            return v16;
        }
        &IntCC::UnsignedLessThan => {
            let v27 = C::def_inst(ctx, arg2);
            if let Some(v28) = v27 {
                let v29 = C::inst_data_value(ctx, v28);
                if let &InstructionData::UnaryImm {
                    opcode: ref v32,
                    imm: v33,
                } = &v29.1 {
                    if let &Opcode::Iconst = v32 {
                        let v34 = C::u64_from_imm64(ctx, v33);
                        let v35 = C::u64_from_u32(ctx, v34);
                        if let Some(v36) = v35 {
                            let v3 = constructor_put_in_xreg(ctx, arg1);
                            let v37 = Cond::IfXult32I32 {
                                src1: v3,
                                src2: v36,
                            };
                            // Rule at src/isa/pulley_shared/lower.isle line 52.
                            return v37;
                        }
                    }
                }
            }
            let v3 = constructor_put_in_xreg(ctx, arg1);
            let v4 = constructor_put_in_xreg(ctx, arg2);
            let v9 = Cond::IfXult32 {
                src1: v3,
                src2: v4,
            };
            // Rule at src/isa/pulley_shared/lower.isle line 32.
            return v9;
        }
        &IntCC::UnsignedLessThanOrEqual => {
            let v27 = C::def_inst(ctx, arg2);
            if let Some(v28) = v27 {
                let v29 = C::inst_data_value(ctx, v28);
                if let &InstructionData::UnaryImm {
                    opcode: ref v32,
                    imm: v33,
                } = &v29.1 {
                    if let &Opcode::Iconst = v32 {
                        let v34 = C::u64_from_imm64(ctx, v33);
                        let v35 = C::u64_from_u32(ctx, v34);
                        if let Some(v36) = v35 {
                            let v3 = constructor_put_in_xreg(ctx, arg1);
                            let v38 = Cond::IfXulteq32I32 {
                                src1: v3,
                                src2: v36,
                            };
                            // Rule at src/isa/pulley_shared/lower.isle line 54.
                            return v38;
                        }
                    }
                }
            }
            let v3 = constructor_put_in_xreg(ctx, arg1);
            let v4 = constructor_put_in_xreg(ctx, arg2);
            let v10 = Cond::IfXulteq32 {
                src1: v3,
                src2: v4,
            };
            // Rule at src/isa/pulley_shared/lower.isle line 33.
            return v10;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "lower_cond_icmp32", "src/isa/pulley_shared/lower.isle line 27")
}

// Generated as internal constructor for term lower_cond_icmp64.
pub fn constructor_lower_cond_icmp64<C: Context>(
    ctx: &mut C,
    arg0: &IntCC,
    arg1: Value,
    arg2: Value,
) -> Cond {
    match arg0 {
        &IntCC::Equal => {
            let v17 = C::i64_from_iconst(ctx, arg2);
            if let Some(v18) = v17 {
                let v19 = C::i64_from_i32(ctx, v18);
                if let Some(v20) = v19 {
                    let v3 = constructor_put_in_xreg(ctx, arg1);
                    let v21 = Cond::IfXeq64I32 {
                        src1: v3,
                        src2: v20,
                    };
                    // Rule at src/isa/pulley_shared/lower.isle line 74.
                    return v21;
                }
            }
            let v3 = constructor_put_in_xreg(ctx, arg1);
            let v4 = constructor_put_in_xreg(ctx, arg2);
            let v5 = Cond::IfXeq64 {
                src1: v3,
                src2: v4,
            };
            // Rule at src/isa/pulley_shared/lower.isle line 62.
            return v5;
        }
        &IntCC::NotEqual => {
            let v17 = C::i64_from_iconst(ctx, arg2);
            if let Some(v18) = v17 {
                let v19 = C::i64_from_i32(ctx, v18);
                if let Some(v20) = v19 {
                    let v3 = constructor_put_in_xreg(ctx, arg1);
                    let v22 = Cond::IfXneq64I32 {
                        src1: v3,
                        src2: v20,
                    };
                    // Rule at src/isa/pulley_shared/lower.isle line 76.
                    return v22;
                }
            }
            let v3 = constructor_put_in_xreg(ctx, arg1);
            let v4 = constructor_put_in_xreg(ctx, arg2);
            let v6 = Cond::IfXneq64 {
                src1: v3,
                src2: v4,
            };
            // Rule at src/isa/pulley_shared/lower.isle line 63.
            return v6;
        }
        &IntCC::SignedGreaterThan => {
            let v17 = C::i64_from_iconst(ctx, arg2);
            if let Some(v18) = v17 {
                let v19 = C::i64_from_i32(ctx, v18);
                if let Some(v20) = v19 {
                    let v3 = constructor_put_in_xreg(ctx, arg1);
                    let v25 = Cond::IfXsgt64I32 {
                        src1: v3,
                        src2: v20,
                    };
                    // Rule at src/isa/pulley_shared/lower.isle line 82.
                    return v25;
                }
            }
            let v11 = constructor_put_in_xreg(ctx, arg2);
            let v12 = constructor_put_in_xreg(ctx, arg1);
            let v13 = Cond::IfXslt64 {
                src1: v11,
                src2: v12,
            };
            // Rule at src/isa/pulley_shared/lower.isle line 69.
            return v13;
        }
        &IntCC::SignedGreaterThanOrEqual => {
            let v17 = C::i64_from_iconst(ctx, arg2);
            if let Some(v18) = v17 {
                let v19 = C::i64_from_i32(ctx, v18);
                if let Some(v20) = v19 {
                    let v3 = constructor_put_in_xreg(ctx, arg1);
                    let v26 = Cond::IfXsgteq64I32 {
                        src1: v3,
                        src2: v20,
                    };
                    // Rule at src/isa/pulley_shared/lower.isle line 84.
                    return v26;
                }
            }
            let v11 = constructor_put_in_xreg(ctx, arg2);
            let v12 = constructor_put_in_xreg(ctx, arg1);
            let v14 = Cond::IfXslteq64 {
                src1: v11,
                src2: v12,
            };
            // Rule at src/isa/pulley_shared/lower.isle line 70.
            return v14;
        }
        &IntCC::SignedLessThan => {
            let v17 = C::i64_from_iconst(ctx, arg2);
            if let Some(v18) = v17 {
                let v19 = C::i64_from_i32(ctx, v18);
                if let Some(v20) = v19 {
                    let v3 = constructor_put_in_xreg(ctx, arg1);
                    let v23 = Cond::IfXslt64I32 {
                        src1: v3,
                        src2: v20,
                    };
                    // Rule at src/isa/pulley_shared/lower.isle line 78.
                    return v23;
                }
            }
            let v3 = constructor_put_in_xreg(ctx, arg1);
            let v4 = constructor_put_in_xreg(ctx, arg2);
            let v7 = Cond::IfXslt64 {
                src1: v3,
                src2: v4,
            };
            // Rule at src/isa/pulley_shared/lower.isle line 64.
            return v7;
        }
        &IntCC::SignedLessThanOrEqual => {
            let v17 = C::i64_from_iconst(ctx, arg2);
            if let Some(v18) = v17 {
                let v19 = C::i64_from_i32(ctx, v18);
                if let Some(v20) = v19 {
                    let v3 = constructor_put_in_xreg(ctx, arg1);
                    let v24 = Cond::IfXslteq64I32 {
                        src1: v3,
                        src2: v20,
                    };
                    // Rule at src/isa/pulley_shared/lower.isle line 80.
                    return v24;
                }
            }
            let v3 = constructor_put_in_xreg(ctx, arg1);
            let v4 = constructor_put_in_xreg(ctx, arg2);
            let v8 = Cond::IfXslteq64 {
                src1: v3,
                src2: v4,
            };
            // Rule at src/isa/pulley_shared/lower.isle line 65.
            return v8;
        }
        &IntCC::UnsignedGreaterThan => {
            let v27 = C::def_inst(ctx, arg2);
            if let Some(v28) = v27 {
                let v29 = C::inst_data_value(ctx, v28);
                if let &InstructionData::UnaryImm {
                    opcode: ref v32,
                    imm: v33,
                } = &v29.1 {
                    if let &Opcode::Iconst = v32 {
                        let v34 = C::u64_from_imm64(ctx, v33);
                        let v35 = C::u64_from_u32(ctx, v34);
                        if let Some(v36) = v35 {
                            let v3 = constructor_put_in_xreg(ctx, arg1);
                            let v39 = Cond::IfXugt64I32 {
                                src1: v3,
                                src2: v36,
                            };
                            // Rule at src/isa/pulley_shared/lower.isle line 90.
                            return v39;
                        }
                    }
                }
            }
            let v11 = constructor_put_in_xreg(ctx, arg2);
            let v12 = constructor_put_in_xreg(ctx, arg1);
            let v15 = Cond::IfXult64 {
                src1: v11,
                src2: v12,
            };
            // Rule at src/isa/pulley_shared/lower.isle line 71.
            return v15;
        }
        &IntCC::UnsignedGreaterThanOrEqual => {
            let v27 = C::def_inst(ctx, arg2);
            if let Some(v28) = v27 {
                let v29 = C::inst_data_value(ctx, v28);
                if let &InstructionData::UnaryImm {
                    opcode: ref v32,
                    imm: v33,
                } = &v29.1 {
                    if let &Opcode::Iconst = v32 {
                        let v34 = C::u64_from_imm64(ctx, v33);
                        let v35 = C::u64_from_u32(ctx, v34);
                        if let Some(v36) = v35 {
                            let v3 = constructor_put_in_xreg(ctx, arg1);
                            let v40 = Cond::IfXugteq64I32 {
                                src1: v3,
                                src2: v36,
                            };
                            // Rule at src/isa/pulley_shared/lower.isle line 92.
                            return v40;
                        }
                    }
                }
            }
            let v11 = constructor_put_in_xreg(ctx, arg2);
            let v12 = constructor_put_in_xreg(ctx, arg1);
            let v16 = Cond::IfXulteq64 {
                src1: v11,
                src2: v12,
            };
            // Rule at src/isa/pulley_shared/lower.isle line 72.
            return v16;
        }
        &IntCC::UnsignedLessThan => {
            let v27 = C::def_inst(ctx, arg2);
            if let Some(v28) = v27 {
                let v29 = C::inst_data_value(ctx, v28);
                if let &InstructionData::UnaryImm {
                    opcode: ref v32,
                    imm: v33,
                } = &v29.1 {
                    if let &Opcode::Iconst = v32 {
                        let v34 = C::u64_from_imm64(ctx, v33);
                        let v35 = C::u64_from_u32(ctx, v34);
                        if let Some(v36) = v35 {
                            let v3 = constructor_put_in_xreg(ctx, arg1);
                            let v37 = Cond::IfXult64I32 {
                                src1: v3,
                                src2: v36,
                            };
                            // Rule at src/isa/pulley_shared/lower.isle line 86.
                            return v37;
                        }
                    }
                }
            }
            let v3 = constructor_put_in_xreg(ctx, arg1);
            let v4 = constructor_put_in_xreg(ctx, arg2);
            let v9 = Cond::IfXult64 {
                src1: v3,
                src2: v4,
            };
            // Rule at src/isa/pulley_shared/lower.isle line 66.
            return v9;
        }
        &IntCC::UnsignedLessThanOrEqual => {
            let v27 = C::def_inst(ctx, arg2);
            if let Some(v28) = v27 {
                let v29 = C::inst_data_value(ctx, v28);
                if let &InstructionData::UnaryImm {
                    opcode: ref v32,
                    imm: v33,
                } = &v29.1 {
                    if let &Opcode::Iconst = v32 {
                        let v34 = C::u64_from_imm64(ctx, v33);
                        let v35 = C::u64_from_u32(ctx, v34);
                        if let Some(v36) = v35 {
                            let v3 = constructor_put_in_xreg(ctx, arg1);
                            let v38 = Cond::IfXulteq64I32 {
                                src1: v3,
                                src2: v36,
                            };
                            // Rule at src/isa/pulley_shared/lower.isle line 88.
                            return v38;
                        }
                    }
                }
            }
            let v3 = constructor_put_in_xreg(ctx, arg1);
            let v4 = constructor_put_in_xreg(ctx, arg2);
            let v10 = Cond::IfXulteq64 {
                src1: v3,
                src2: v4,
            };
            // Rule at src/isa/pulley_shared/lower.isle line 67.
            return v10;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "lower_cond_icmp64", "src/isa/pulley_shared/lower.isle line 61")
}

// Generated as internal constructor for term lower_branch.
pub fn constructor_lower_branch<C: Context>(
    ctx: &mut C,
    arg0: Inst,
    arg1: &MachLabelSlice,
) -> Option<Unit> {
    let v1 = C::inst_data_value(ctx, arg0);
    match &v1.1 {
        &InstructionData::BranchTable {
            opcode: ref v26,
            arg: v27,
            table: v28,
        } => {
            if let &Opcode::BrTable = v26 {
                let v29 = C::jump_table_targets(ctx, arg1);
                if let Some(v30) = v29 {
                    let v33 = constructor_put_in_xreg(ctx, v27);
                    let v34 = constructor_gen_br_table(ctx, v33, v30.0, &v30.1);
                    let v35 = Some(v34);
                    // Rule at src/isa/pulley_shared/lower.isle line 108.
                    return v35;
                }
            }
        }
        &InstructionData::Brif {
            opcode: ref v12,
            arg: v13,
            blocks: ref v14,
        } => {
            if let &Opcode::Brif = v12 {
                let v18 = C::two_targets(ctx, arg1);
                if let Some(v19) = v18 {
                    let v22 = &constructor_lower_cond(ctx, v13);
                    let v23 = &constructor_pulley_br_if(ctx, v22, v19.0, v19.1);
                    let v24 = constructor_emit_side_effect(ctx, v23);
                    let v25 = Some(v24);
                    // Rule at src/isa/pulley_shared/lower.isle line 104.
                    return v25;
                }
            }
        }
        &InstructionData::Jump {
            opcode: ref v4,
            destination: v5,
        } => {
            if let &Opcode::Jump = v4 {
                let v7 = C::single_target(ctx, arg1);
                if let Some(v8) = v7 {
                    let v9 = &constructor_pulley_jump(ctx, v8);
                    let v10 = constructor_emit_side_effect(ctx, v9);
                    let v11 = Some(v10);
                    // Rule at src/isa/pulley_shared/lower.isle line 100.
                    return v11;
                }
            }
        }
        &InstructionData::TryCall {
            opcode: ref v36,
            args: v37,
            func_ref: v38,
            exception: v39,
        } => {
            if let &Opcode::TryCall = v36 {
                let v41 = C::func_ref_data(ctx, v38);
                if let &RelocDistance::Near = &v41.2 {
                    let v46 = C::abi_sig(ctx, v41.0);
                    let v47 = C::try_call_info(ctx, v39, arg1);
                    let v40 = C::value_list_slice(ctx, v37);
                    let v48 = &C::put_in_regs_vec(ctx, v40);
                    let v49 = C::gen_call_args(ctx, v46, v48);
                    let v50 = C::gen_try_call_rets(ctx, v46);
                    let v51 = C::gen_call_info(ctx, v46, v41.1, v49, v50, v47, v41.3);
                    let v52 = &constructor_call_impl(ctx, v51);
                    let v53 = constructor_emit_side_effect(ctx, v52);
                    let v54 = Some(v53);
                    // Rule at src/isa/pulley_shared/lower.isle line 179.
                    return v54;
                }
                if v41.3 == false {
                    let v46 = C::abi_sig(ctx, v41.0);
                    let v47 = C::try_call_info(ctx, v39, arg1);
                    let v40 = C::value_list_slice(ctx, v37);
                    let v48 = &C::put_in_regs_vec(ctx, v40);
                    let v49 = C::gen_call_args(ctx, v46, v48);
                    let v50 = C::gen_try_call_rets(ctx, v46);
                    let v55 = C::gen_call_host_info(ctx, v46, v41.1, v49, v50, v47);
                    let v56 = &constructor_indirect_call_host_impl(ctx, v55);
                    let v57 = constructor_emit_side_effect(ctx, v56);
                    let v58 = Some(v57);
                    // Rule at src/isa/pulley_shared/lower.isle line 188.
                    return v58;
                }
            }
        }
        &InstructionData::TryCallIndirect {
            opcode: ref v59,
            args: v60,
            exception: v61,
        } => {
            if let &Opcode::TryCallIndirect = v59 {
                let v62 = C::value_list_slice(ctx, v60);
                let v63 = C::value_slice_unwrap(ctx, v62);
                if let Some(v64) = v63 {
                    let v67 = C::exception_sig(ctx, v61);
                    let v68 = C::abi_sig(ctx, v67);
                    let v69 = C::try_call_info(ctx, v61, arg1);
                    let v70 = C::put_in_reg(ctx, v64.0);
                    let v71 = &C::put_in_regs_vec(ctx, v64.1);
                    let v72 = C::gen_call_args(ctx, v68, v71);
                    let v73 = C::gen_try_call_rets(ctx, v68);
                    let v74 = C::gen_call_ind_info(ctx, v68, v70, v72, v73, v69);
                    let v75 = &constructor_indirect_call_impl(ctx, v74);
                    let v76 = constructor_emit_side_effect(ctx, v75);
                    let v77 = Some(v76);
                    // Rule at src/isa/pulley_shared/lower.isle line 197.
                    return v77;
                }
            }
        }
        _ => {}
    }
    None
}

// Generated as internal constructor for term u8_from_negated_iconst.
pub fn constructor_u8_from_negated_iconst<C: Context>(
    ctx: &mut C,
    arg0: Value,
) -> Option<u8> {
    let v1 = C::i64_from_iconst(ctx, arg0);
    if let Some(v2) = v1 {
        let v3 = C::i64_from_i32(ctx, v2);
        if let Some(v4) = v3 {
            let v5 = C::i32_into_i64(ctx, v4);
            let v6 = C::i64_checked_neg(ctx, v5);
            if let Some(v7) = v6 {
                let v8 = C::i64_try_into_u8(ctx, v7);
                if let Some(v9) = v8 {
                    let v10 = Some(v9);
                    // Rule at src/isa/pulley_shared/lower.isle line 277.
                    return v10;
                }
            }
        }
    }
    None
}

// Generated as internal constructor for term u32_from_negated_iconst.
pub fn constructor_u32_from_negated_iconst<C: Context>(
    ctx: &mut C,
    arg0: Value,
) -> Option<u32> {
    let v1 = C::i64_from_iconst(ctx, arg0);
    if let Some(v2) = v1 {
        let v3 = C::i64_from_i32(ctx, v2);
        if let Some(v4) = v3 {
            let v5 = C::i32_into_i64(ctx, v4);
            let v6 = C::i64_checked_neg(ctx, v5);
            if let Some(v7) = v6 {
                let v8 = C::i64_try_into_u32(ctx, v7);
                if let Some(v9) = v8 {
                    let v10 = Some(v9);
                    // Rule at src/isa/pulley_shared/lower.isle line 285.
                    return v10;
                }
            }
        }
    }
    None
}

// Generated as internal constructor for term u6_shift_from_iconst.
pub fn constructor_u6_shift_from_iconst<C: Context>(
    ctx: &mut C,
    arg0: Value,
) -> Option<U6> {
    let v1 = C::def_inst(ctx, arg0);
    if let Some(v2) = v1 {
        let v3 = C::inst_data_value(ctx, v2);
        if let &InstructionData::UnaryImm {
            opcode: ref v6,
            imm: v7,
        } = &v3.1 {
            if let &Opcode::Iconst = v6 {
                let v8 = C::u64_from_imm64(ctx, v7);
                let v10 = C::u64_and(ctx, v8, 0x3f_u64);
                let v11 = C::u64_try_into_u8(ctx, v10);
                if let Some(v12) = v11 {
                    let v13 = C::u6_from_u8(ctx, v12);
                    if let Some(v14) = v13 {
                        let v15 = Some(v14);
                        // Rule at src/isa/pulley_shared/lower.isle line 526.
                        return v15;
                    }
                }
            }
        }
    }
    None
}

// Generated as internal constructor for term lower_icmp.
pub fn constructor_lower_icmp<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: &IntCC,
    arg2: Value,
    arg3: Value,
) -> XReg {
    if arg0 == I128 {
        let v58 = &C::intcc_unsigned(ctx, arg1);
        if let &IntCC::UnsignedLessThan = v58 {
            let v32 = C::put_in_regs(ctx, arg2);
            let v34 = C::value_regs_get(ctx, v32, 0x0_usize);
            let v35 = C::xreg_new(ctx, v34);
            let v59 = C::put_in_regs(ctx, arg2);
            let v60 = C::value_regs_get(ctx, v59, 0x1_usize);
            let v61 = C::xreg_new(ctx, v60);
            let v62 = C::put_in_regs(ctx, arg3);
            let v63 = C::value_regs_get(ctx, v62, 0x0_usize);
            let v64 = C::xreg_new(ctx, v63);
            let v65 = C::put_in_regs(ctx, arg3);
            let v66 = C::value_regs_get(ctx, v65, 0x1_usize);
            let v67 = C::xreg_new(ctx, v66);
            let v68 = constructor_lower_icmp128_hi(ctx, arg1, v61, v67);
            let v69 = constructor_pulley_xult64(ctx, v35, v64);
            let v70 = constructor_pulley_xbxor64(ctx, v61, v67);
            let v50 = constructor_pulley_xconst8(ctx, 0_i8);
            let v71 = constructor_pulley_xeq64(ctx, v70, v50);
            let v72 = constructor_pulley_xselect32(ctx, v71, v69, v68);
            // Rule at src/isa/pulley_shared/lower.isle line 831.
            return v72;
        }
        match arg1 {
            &IntCC::SignedGreaterThanOrEqual => {
                let v54 = &C::intcc_complement(ctx, arg1);
                let v55 = constructor_lower_icmp(ctx, I128, v54, arg2, arg3);
                let v57 = constructor_pulley_xbxor32_s8(ctx, v55, 1_i8);
                // Rule at src/isa/pulley_shared/lower.isle line 820.
                return v57;
            }
            &IntCC::SignedLessThanOrEqual => {
                let v54 = &C::intcc_complement(ctx, arg1);
                let v55 = constructor_lower_icmp(ctx, I128, v54, arg2, arg3);
                let v57 = constructor_pulley_xbxor32_s8(ctx, v55, 1_i8);
                // Rule at src/isa/pulley_shared/lower.isle line 818.
                return v57;
            }
            &IntCC::UnsignedGreaterThanOrEqual => {
                let v54 = &C::intcc_complement(ctx, arg1);
                let v55 = constructor_lower_icmp(ctx, I128, v54, arg2, arg3);
                let v57 = constructor_pulley_xbxor32_s8(ctx, v55, 1_i8);
                // Rule at src/isa/pulley_shared/lower.isle line 824.
                return v57;
            }
            &IntCC::UnsignedLessThanOrEqual => {
                let v54 = &C::intcc_complement(ctx, arg1);
                let v55 = constructor_lower_icmp(ctx, I128, v54, arg2, arg3);
                let v57 = constructor_pulley_xbxor32_s8(ctx, v55, 1_i8);
                // Rule at src/isa/pulley_shared/lower.isle line 822.
                return v57;
            }
            _ => {}
        }
    }
    match arg1 {
        &IntCC::Equal => {
            let v12 = C::fits_in_32(ctx, arg0);
            if let Some(v13) = v12 {
                let v14 = constructor_zext32(ctx, arg2);
                let v15 = constructor_zext32(ctx, arg3);
                let v16 = constructor_pulley_xeq32(ctx, v14, v15);
                // Rule at src/isa/pulley_shared/lower.isle line 764.
                return v16;
            }
            match arg0 {
                I64 => {
                    let v4 = constructor_put_in_xreg(ctx, arg2);
                    let v5 = constructor_put_in_xreg(ctx, arg3);
                    let v6 = constructor_pulley_xeq64(ctx, v4, v5);
                    // Rule at src/isa/pulley_shared/lower.isle line 746.
                    return v6;
                }
                I128 => {
                    let v32 = C::put_in_regs(ctx, arg2);
                    let v34 = C::value_regs_get(ctx, v32, 0x0_usize);
                    let v35 = C::xreg_new(ctx, v34);
                    let v36 = C::put_in_regs(ctx, arg3);
                    let v37 = C::value_regs_get(ctx, v36, 0x0_usize);
                    let v38 = C::xreg_new(ctx, v37);
                    let v39 = constructor_pulley_xbxor64(ctx, v35, v38);
                    let v40 = C::put_in_regs(ctx, arg2);
                    let v42 = C::value_regs_get(ctx, v40, 0x1_usize);
                    let v43 = C::xreg_new(ctx, v42);
                    let v44 = C::put_in_regs(ctx, arg3);
                    let v45 = C::value_regs_get(ctx, v44, 0x1_usize);
                    let v46 = C::xreg_new(ctx, v45);
                    let v47 = constructor_pulley_xbxor64(ctx, v43, v46);
                    let v48 = constructor_pulley_xbor64(ctx, v39, v47);
                    let v50 = constructor_pulley_xconst8(ctx, 0_i8);
                    let v51 = constructor_pulley_xeq64(ctx, v48, v50);
                    // Rule at src/isa/pulley_shared/lower.isle line 802.
                    return v51;
                }
                _ => {}
            }
        }
        &IntCC::NotEqual => {
            let v12 = C::fits_in_32(ctx, arg0);
            if let Some(v13) = v12 {
                let v14 = constructor_zext32(ctx, arg2);
                let v15 = constructor_zext32(ctx, arg3);
                let v17 = constructor_pulley_xneq32(ctx, v14, v15);
                // Rule at src/isa/pulley_shared/lower.isle line 767.
                return v17;
            }
            match arg0 {
                I64 => {
                    let v4 = constructor_put_in_xreg(ctx, arg2);
                    let v5 = constructor_put_in_xreg(ctx, arg3);
                    let v7 = constructor_pulley_xneq64(ctx, v4, v5);
                    // Rule at src/isa/pulley_shared/lower.isle line 749.
                    return v7;
                }
                I128 => {
                    let v32 = C::put_in_regs(ctx, arg2);
                    let v34 = C::value_regs_get(ctx, v32, 0x0_usize);
                    let v35 = C::xreg_new(ctx, v34);
                    let v36 = C::put_in_regs(ctx, arg3);
                    let v37 = C::value_regs_get(ctx, v36, 0x0_usize);
                    let v38 = C::xreg_new(ctx, v37);
                    let v39 = constructor_pulley_xbxor64(ctx, v35, v38);
                    let v40 = C::put_in_regs(ctx, arg2);
                    let v42 = C::value_regs_get(ctx, v40, 0x1_usize);
                    let v43 = C::xreg_new(ctx, v42);
                    let v44 = C::put_in_regs(ctx, arg3);
                    let v45 = C::value_regs_get(ctx, v44, 0x1_usize);
                    let v46 = C::xreg_new(ctx, v45);
                    let v47 = constructor_pulley_xbxor64(ctx, v43, v46);
                    let v48 = constructor_pulley_xbor64(ctx, v39, v47);
                    let v50 = constructor_pulley_xconst8(ctx, 0_i8);
                    let v52 = constructor_pulley_xneq64(ctx, v48, v50);
                    // Rule at src/isa/pulley_shared/lower.isle line 806.
                    return v52;
                }
                _ => {}
            }
        }
        &IntCC::SignedGreaterThan => {
            let v25 = constructor_lower_icmp(ctx, arg0, &IntCC::SignedLessThan, arg3, arg2);
            // Rule at src/isa/pulley_shared/lower.isle line 784.
            return v25;
        }
        &IntCC::SignedGreaterThanOrEqual => {
            let v27 = constructor_lower_icmp(ctx, arg0, &IntCC::SignedLessThanOrEqual, arg3, arg2);
            // Rule at src/isa/pulley_shared/lower.isle line 786.
            return v27;
        }
        &IntCC::SignedLessThan => {
            let v12 = C::fits_in_32(ctx, arg0);
            if let Some(v13) = v12 {
                let v18 = constructor_sext32(ctx, arg2);
                let v19 = constructor_sext32(ctx, arg3);
                let v20 = constructor_pulley_xslt32(ctx, v18, v19);
                // Rule at src/isa/pulley_shared/lower.isle line 770.
                return v20;
            }
            if arg0 == I64 {
                let v4 = constructor_put_in_xreg(ctx, arg2);
                let v5 = constructor_put_in_xreg(ctx, arg3);
                let v8 = constructor_pulley_xslt64(ctx, v4, v5);
                // Rule at src/isa/pulley_shared/lower.isle line 752.
                return v8;
            }
        }
        &IntCC::SignedLessThanOrEqual => {
            let v12 = C::fits_in_32(ctx, arg0);
            if let Some(v13) = v12 {
                let v18 = constructor_sext32(ctx, arg2);
                let v19 = constructor_sext32(ctx, arg3);
                let v21 = constructor_pulley_xslteq32(ctx, v18, v19);
                // Rule at src/isa/pulley_shared/lower.isle line 773.
                return v21;
            }
            if arg0 == I64 {
                let v4 = constructor_put_in_xreg(ctx, arg2);
                let v5 = constructor_put_in_xreg(ctx, arg3);
                let v9 = constructor_pulley_xslteq64(ctx, v4, v5);
                // Rule at src/isa/pulley_shared/lower.isle line 755.
                return v9;
            }
        }
        &IntCC::UnsignedGreaterThan => {
            let v29 = constructor_lower_icmp(ctx, arg0, &IntCC::UnsignedLessThan, arg3, arg2);
            // Rule at src/isa/pulley_shared/lower.isle line 788.
            return v29;
        }
        &IntCC::UnsignedGreaterThanOrEqual => {
            let v31 = constructor_lower_icmp(ctx, arg0, &IntCC::UnsignedLessThanOrEqual, arg3, arg2);
            // Rule at src/isa/pulley_shared/lower.isle line 790.
            return v31;
        }
        &IntCC::UnsignedLessThan => {
            let v12 = C::fits_in_32(ctx, arg0);
            if let Some(v13) = v12 {
                let v14 = constructor_zext32(ctx, arg2);
                let v15 = constructor_zext32(ctx, arg3);
                let v22 = constructor_pulley_xult32(ctx, v14, v15);
                // Rule at src/isa/pulley_shared/lower.isle line 776.
                return v22;
            }
            if arg0 == I64 {
                let v4 = constructor_put_in_xreg(ctx, arg2);
                let v5 = constructor_put_in_xreg(ctx, arg3);
                let v10 = constructor_pulley_xult64(ctx, v4, v5);
                // Rule at src/isa/pulley_shared/lower.isle line 758.
                return v10;
            }
        }
        &IntCC::UnsignedLessThanOrEqual => {
            let v12 = C::fits_in_32(ctx, arg0);
            if let Some(v13) = v12 {
                let v14 = constructor_zext32(ctx, arg2);
                let v15 = constructor_zext32(ctx, arg3);
                let v23 = constructor_pulley_xulteq32(ctx, v14, v15);
                // Rule at src/isa/pulley_shared/lower.isle line 779.
                return v23;
            }
            if arg0 == I64 {
                let v4 = constructor_put_in_xreg(ctx, arg2);
                let v5 = constructor_put_in_xreg(ctx, arg3);
                let v11 = constructor_pulley_xulteq64(ctx, v4, v5);
                // Rule at src/isa/pulley_shared/lower.isle line 761.
                return v11;
            }
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "lower_icmp", "src/isa/pulley_shared/lower.isle line 744")
}

// Generated as internal constructor for term lower_icmp128_hi.
pub fn constructor_lower_icmp128_hi<C: Context>(
    ctx: &mut C,
    arg0: &IntCC,
    arg1: XReg,
    arg2: XReg,
) -> XReg {
    match arg0 {
        &IntCC::SignedLessThan => {
            let v3 = constructor_pulley_xslt64(ctx, arg1, arg2);
            // Rule at src/isa/pulley_shared/lower.isle line 845.
            return v3;
        }
        &IntCC::UnsignedLessThan => {
            let v4 = constructor_pulley_xult64(ctx, arg1, arg2);
            // Rule at src/isa/pulley_shared/lower.isle line 846.
            return v4;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "lower_icmp128_hi", "src/isa/pulley_shared/lower.isle line 844")
}

// Generated as internal constructor for term lower_vcmp.
pub fn constructor_lower_vcmp<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: &IntCC,
    arg2: Value,
    arg3: Value,
) -> VReg {
    match arg1 {
        &IntCC::Equal => {
            match arg0 {
                I8X16 => {
                    let v4 = constructor_put_in_vreg(ctx, arg2);
                    let v5 = constructor_put_in_vreg(ctx, arg3);
                    let v6 = constructor_pulley_veq8x16(ctx, v4, v5);
                    // Rule at src/isa/pulley_shared/lower.isle line 856.
                    return v6;
                }
                I16X8 => {
                    let v4 = constructor_put_in_vreg(ctx, arg2);
                    let v5 = constructor_put_in_vreg(ctx, arg3);
                    let v12 = constructor_pulley_veq16x8(ctx, v4, v5);
                    // Rule at src/isa/pulley_shared/lower.isle line 862.
                    return v12;
                }
                I32X4 => {
                    let v4 = constructor_put_in_vreg(ctx, arg2);
                    let v5 = constructor_put_in_vreg(ctx, arg3);
                    let v18 = constructor_pulley_veq32x4(ctx, v4, v5);
                    // Rule at src/isa/pulley_shared/lower.isle line 868.
                    return v18;
                }
                I64X2 => {
                    let v4 = constructor_put_in_vreg(ctx, arg2);
                    let v5 = constructor_put_in_vreg(ctx, arg3);
                    let v24 = constructor_pulley_veq64x2(ctx, v4, v5);
                    // Rule at src/isa/pulley_shared/lower.isle line 874.
                    return v24;
                }
                _ => {}
            }
        }
        &IntCC::NotEqual => {
            match arg0 {
                I8X16 => {
                    let v4 = constructor_put_in_vreg(ctx, arg2);
                    let v5 = constructor_put_in_vreg(ctx, arg3);
                    let v7 = constructor_pulley_vneq8x16(ctx, v4, v5);
                    // Rule at src/isa/pulley_shared/lower.isle line 857.
                    return v7;
                }
                I16X8 => {
                    let v4 = constructor_put_in_vreg(ctx, arg2);
                    let v5 = constructor_put_in_vreg(ctx, arg3);
                    let v13 = constructor_pulley_vneq16x8(ctx, v4, v5);
                    // Rule at src/isa/pulley_shared/lower.isle line 863.
                    return v13;
                }
                I32X4 => {
                    let v4 = constructor_put_in_vreg(ctx, arg2);
                    let v5 = constructor_put_in_vreg(ctx, arg3);
                    let v19 = constructor_pulley_vneq32x4(ctx, v4, v5);
                    // Rule at src/isa/pulley_shared/lower.isle line 869.
                    return v19;
                }
                I64X2 => {
                    let v4 = constructor_put_in_vreg(ctx, arg2);
                    let v5 = constructor_put_in_vreg(ctx, arg3);
                    let v25 = constructor_pulley_vneq64x2(ctx, v4, v5);
                    // Rule at src/isa/pulley_shared/lower.isle line 875.
                    return v25;
                }
                _ => {}
            }
        }
        &IntCC::SignedGreaterThan => {
            let v30 = &C::intcc_swap_args(ctx, arg1);
            let v31 = constructor_lower_vcmp(ctx, arg0, v30, arg3, arg2);
            // Rule at src/isa/pulley_shared/lower.isle line 882.
            return v31;
        }
        &IntCC::SignedGreaterThanOrEqual => {
            let v30 = &C::intcc_swap_args(ctx, arg1);
            let v31 = constructor_lower_vcmp(ctx, arg0, v30, arg3, arg2);
            // Rule at src/isa/pulley_shared/lower.isle line 884.
            return v31;
        }
        &IntCC::SignedLessThan => {
            match arg0 {
                I8X16 => {
                    let v4 = constructor_put_in_vreg(ctx, arg2);
                    let v5 = constructor_put_in_vreg(ctx, arg3);
                    let v8 = constructor_pulley_vslt8x16(ctx, v4, v5);
                    // Rule at src/isa/pulley_shared/lower.isle line 858.
                    return v8;
                }
                I16X8 => {
                    let v4 = constructor_put_in_vreg(ctx, arg2);
                    let v5 = constructor_put_in_vreg(ctx, arg3);
                    let v14 = constructor_pulley_vslt16x8(ctx, v4, v5);
                    // Rule at src/isa/pulley_shared/lower.isle line 864.
                    return v14;
                }
                I32X4 => {
                    let v4 = constructor_put_in_vreg(ctx, arg2);
                    let v5 = constructor_put_in_vreg(ctx, arg3);
                    let v20 = constructor_pulley_vslt32x4(ctx, v4, v5);
                    // Rule at src/isa/pulley_shared/lower.isle line 870.
                    return v20;
                }
                I64X2 => {
                    let v4 = constructor_put_in_vreg(ctx, arg2);
                    let v5 = constructor_put_in_vreg(ctx, arg3);
                    let v26 = constructor_pulley_vslt64x2(ctx, v4, v5);
                    // Rule at src/isa/pulley_shared/lower.isle line 876.
                    return v26;
                }
                _ => {}
            }
        }
        &IntCC::SignedLessThanOrEqual => {
            match arg0 {
                I8X16 => {
                    let v4 = constructor_put_in_vreg(ctx, arg2);
                    let v5 = constructor_put_in_vreg(ctx, arg3);
                    let v9 = constructor_pulley_vslteq8x16(ctx, v4, v5);
                    // Rule at src/isa/pulley_shared/lower.isle line 859.
                    return v9;
                }
                I16X8 => {
                    let v4 = constructor_put_in_vreg(ctx, arg2);
                    let v5 = constructor_put_in_vreg(ctx, arg3);
                    let v15 = constructor_pulley_vslteq16x8(ctx, v4, v5);
                    // Rule at src/isa/pulley_shared/lower.isle line 865.
                    return v15;
                }
                I32X4 => {
                    let v4 = constructor_put_in_vreg(ctx, arg2);
                    let v5 = constructor_put_in_vreg(ctx, arg3);
                    let v21 = constructor_pulley_vslteq32x4(ctx, v4, v5);
                    // Rule at src/isa/pulley_shared/lower.isle line 871.
                    return v21;
                }
                I64X2 => {
                    let v4 = constructor_put_in_vreg(ctx, arg2);
                    let v5 = constructor_put_in_vreg(ctx, arg3);
                    let v27 = constructor_pulley_vslteq64x2(ctx, v4, v5);
                    // Rule at src/isa/pulley_shared/lower.isle line 877.
                    return v27;
                }
                _ => {}
            }
        }
        &IntCC::UnsignedGreaterThan => {
            let v30 = &C::intcc_swap_args(ctx, arg1);
            let v31 = constructor_lower_vcmp(ctx, arg0, v30, arg3, arg2);
            // Rule at src/isa/pulley_shared/lower.isle line 886.
            return v31;
        }
        &IntCC::UnsignedGreaterThanOrEqual => {
            let v30 = &C::intcc_swap_args(ctx, arg1);
            let v31 = constructor_lower_vcmp(ctx, arg0, v30, arg3, arg2);
            // Rule at src/isa/pulley_shared/lower.isle line 888.
            return v31;
        }
        &IntCC::UnsignedLessThan => {
            match arg0 {
                I8X16 => {
                    let v4 = constructor_put_in_vreg(ctx, arg2);
                    let v5 = constructor_put_in_vreg(ctx, arg3);
                    let v10 = constructor_pulley_vult8x16(ctx, v4, v5);
                    // Rule at src/isa/pulley_shared/lower.isle line 860.
                    return v10;
                }
                I16X8 => {
                    let v4 = constructor_put_in_vreg(ctx, arg2);
                    let v5 = constructor_put_in_vreg(ctx, arg3);
                    let v16 = constructor_pulley_vult16x8(ctx, v4, v5);
                    // Rule at src/isa/pulley_shared/lower.isle line 866.
                    return v16;
                }
                I32X4 => {
                    let v4 = constructor_put_in_vreg(ctx, arg2);
                    let v5 = constructor_put_in_vreg(ctx, arg3);
                    let v22 = constructor_pulley_vult32x4(ctx, v4, v5);
                    // Rule at src/isa/pulley_shared/lower.isle line 872.
                    return v22;
                }
                I64X2 => {
                    let v4 = constructor_put_in_vreg(ctx, arg2);
                    let v5 = constructor_put_in_vreg(ctx, arg3);
                    let v28 = constructor_pulley_vult64x2(ctx, v4, v5);
                    // Rule at src/isa/pulley_shared/lower.isle line 878.
                    return v28;
                }
                _ => {}
            }
        }
        &IntCC::UnsignedLessThanOrEqual => {
            match arg0 {
                I8X16 => {
                    let v4 = constructor_put_in_vreg(ctx, arg2);
                    let v5 = constructor_put_in_vreg(ctx, arg3);
                    let v11 = constructor_pulley_vulteq8x16(ctx, v4, v5);
                    // Rule at src/isa/pulley_shared/lower.isle line 861.
                    return v11;
                }
                I16X8 => {
                    let v4 = constructor_put_in_vreg(ctx, arg2);
                    let v5 = constructor_put_in_vreg(ctx, arg3);
                    let v17 = constructor_pulley_vulteq16x8(ctx, v4, v5);
                    // Rule at src/isa/pulley_shared/lower.isle line 867.
                    return v17;
                }
                I32X4 => {
                    let v4 = constructor_put_in_vreg(ctx, arg2);
                    let v5 = constructor_put_in_vreg(ctx, arg3);
                    let v23 = constructor_pulley_vulteq32x4(ctx, v4, v5);
                    // Rule at src/isa/pulley_shared/lower.isle line 873.
                    return v23;
                }
                I64X2 => {
                    let v4 = constructor_put_in_vreg(ctx, arg2);
                    let v5 = constructor_put_in_vreg(ctx, arg3);
                    let v29 = constructor_pulley_vulteq64x2(ctx, v4, v5);
                    // Rule at src/isa/pulley_shared/lower.isle line 879.
                    return v29;
                }
                _ => {}
            }
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "lower_vcmp", "src/isa/pulley_shared/lower.isle line 855")
}

// Generated as internal constructor for term lower_fcmp.
pub fn constructor_lower_fcmp<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: &FloatCC,
    arg2: Value,
    arg3: Value,
) -> XReg {
    match arg1 {
        &FloatCC::Equal => {
            match arg0 {
                F32 => {
                    let v4 = constructor_put_in_freg(ctx, arg2);
                    let v5 = constructor_put_in_freg(ctx, arg3);
                    let v6 = constructor_pulley_feq32(ctx, v4, v5);
                    // Rule at src/isa/pulley_shared/lower.isle line 903.
                    return v6;
                }
                F64 => {
                    let v4 = constructor_put_in_freg(ctx, arg2);
                    let v5 = constructor_put_in_freg(ctx, arg3);
                    let v7 = constructor_pulley_feq64(ctx, v4, v5);
                    // Rule at src/isa/pulley_shared/lower.isle line 904.
                    return v7;
                }
                _ => {}
            }
        }
        &FloatCC::GreaterThan => {
            let v23 = constructor_lower_fcmp(ctx, arg0, &FloatCC::LessThan, arg3, arg2);
            // Rule at src/isa/pulley_shared/lower.isle line 922.
            return v23;
        }
        &FloatCC::GreaterThanOrEqual => {
            let v25 = constructor_lower_fcmp(ctx, arg0, &FloatCC::LessThanOrEqual, arg3, arg2);
            // Rule at src/isa/pulley_shared/lower.isle line 924.
            return v25;
        }
        &FloatCC::LessThan => {
            match arg0 {
                F32 => {
                    let v4 = constructor_put_in_freg(ctx, arg2);
                    let v5 = constructor_put_in_freg(ctx, arg3);
                    let v10 = constructor_pulley_flt32(ctx, v4, v5);
                    // Rule at src/isa/pulley_shared/lower.isle line 907.
                    return v10;
                }
                F64 => {
                    let v4 = constructor_put_in_freg(ctx, arg2);
                    let v5 = constructor_put_in_freg(ctx, arg3);
                    let v11 = constructor_pulley_flt64(ctx, v4, v5);
                    // Rule at src/isa/pulley_shared/lower.isle line 908.
                    return v11;
                }
                _ => {}
            }
        }
        &FloatCC::LessThanOrEqual => {
            match arg0 {
                F32 => {
                    let v4 = constructor_put_in_freg(ctx, arg2);
                    let v5 = constructor_put_in_freg(ctx, arg3);
                    let v12 = constructor_pulley_flteq32(ctx, v4, v5);
                    // Rule at src/isa/pulley_shared/lower.isle line 909.
                    return v12;
                }
                F64 => {
                    let v4 = constructor_put_in_freg(ctx, arg2);
                    let v5 = constructor_put_in_freg(ctx, arg3);
                    let v13 = constructor_pulley_flteq64(ctx, v4, v5);
                    // Rule at src/isa/pulley_shared/lower.isle line 910.
                    return v13;
                }
                _ => {}
            }
        }
        &FloatCC::NotEqual => {
            match arg0 {
                F32 => {
                    let v4 = constructor_put_in_freg(ctx, arg2);
                    let v5 = constructor_put_in_freg(ctx, arg3);
                    let v8 = constructor_pulley_fneq32(ctx, v4, v5);
                    // Rule at src/isa/pulley_shared/lower.isle line 905.
                    return v8;
                }
                F64 => {
                    let v4 = constructor_put_in_freg(ctx, arg2);
                    let v5 = constructor_put_in_freg(ctx, arg3);
                    let v9 = constructor_pulley_fneq64(ctx, v4, v5);
                    // Rule at src/isa/pulley_shared/lower.isle line 906.
                    return v9;
                }
                _ => {}
            }
        }
        &FloatCC::Ordered => {
            let v15 = constructor_lower_fcmp(ctx, arg0, &FloatCC::Equal, arg2, arg2);
            let v16 = constructor_lower_fcmp(ctx, arg0, &FloatCC::Equal, arg3, arg3);
            let v17 = constructor_pulley_xband32(ctx, v15, v16);
            // Rule at src/isa/pulley_shared/lower.isle line 913.
            return v17;
        }
        &FloatCC::OrderedNotEqual => {
            let v19 = constructor_lower_fcmp(ctx, arg0, &FloatCC::LessThan, arg2, arg3);
            let v21 = constructor_lower_fcmp(ctx, arg0, &FloatCC::GreaterThan, arg2, arg3);
            let v22 = constructor_pulley_xbor32(ctx, v19, v21);
            // Rule at src/isa/pulley_shared/lower.isle line 917.
            return v22;
        }
        _ => {}
    }
    let v26 = C::floatcc_unordered(ctx, arg1);
    if v26 == true {
        let v27 = &C::floatcc_complement(ctx, arg1);
        let v28 = constructor_lower_fcmp(ctx, arg0, v27, arg2, arg3);
        let v30 = constructor_pulley_xbxor32_s8(ctx, v28, 1_i8);
        // Rule at src/isa/pulley_shared/lower.isle line 928.
        return v30;
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "lower_fcmp", "src/isa/pulley_shared/lower.isle line 901")
}

// Generated as internal constructor for term lower_vfcmp.
pub fn constructor_lower_vfcmp<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: &FloatCC,
    arg2: Value,
    arg3: Value,
) -> VReg {
    match arg1 {
        &FloatCC::Equal => {
            match arg0 {
                F32X4 => {
                    let v4 = constructor_put_in_vreg(ctx, arg2);
                    let v5 = constructor_put_in_vreg(ctx, arg3);
                    let v6 = constructor_pulley_veqf32x4(ctx, v4, v5);
                    // Rule at src/isa/pulley_shared/lower.isle line 936.
                    return v6;
                }
                F64X2 => {
                    let v4 = constructor_put_in_vreg(ctx, arg2);
                    let v5 = constructor_put_in_vreg(ctx, arg3);
                    let v7 = constructor_pulley_veqf64x2(ctx, v4, v5);
                    // Rule at src/isa/pulley_shared/lower.isle line 937.
                    return v7;
                }
                _ => {}
            }
        }
        &FloatCC::GreaterThan => {
            let v19 = constructor_lower_vfcmp(ctx, arg0, &FloatCC::LessThan, arg3, arg2);
            // Rule at src/isa/pulley_shared/lower.isle line 955.
            return v19;
        }
        &FloatCC::GreaterThanOrEqual => {
            let v21 = constructor_lower_vfcmp(ctx, arg0, &FloatCC::LessThanOrEqual, arg3, arg2);
            // Rule at src/isa/pulley_shared/lower.isle line 957.
            return v21;
        }
        &FloatCC::LessThan => {
            match arg0 {
                F32X4 => {
                    let v4 = constructor_put_in_vreg(ctx, arg2);
                    let v5 = constructor_put_in_vreg(ctx, arg3);
                    let v10 = constructor_pulley_vltf32x4(ctx, v4, v5);
                    // Rule at src/isa/pulley_shared/lower.isle line 940.
                    return v10;
                }
                F64X2 => {
                    let v4 = constructor_put_in_vreg(ctx, arg2);
                    let v5 = constructor_put_in_vreg(ctx, arg3);
                    let v11 = constructor_pulley_vltf64x2(ctx, v4, v5);
                    // Rule at src/isa/pulley_shared/lower.isle line 941.
                    return v11;
                }
                _ => {}
            }
        }
        &FloatCC::LessThanOrEqual => {
            match arg0 {
                F32X4 => {
                    let v4 = constructor_put_in_vreg(ctx, arg2);
                    let v5 = constructor_put_in_vreg(ctx, arg3);
                    let v12 = constructor_pulley_vlteqf32x4(ctx, v4, v5);
                    // Rule at src/isa/pulley_shared/lower.isle line 942.
                    return v12;
                }
                F64X2 => {
                    let v4 = constructor_put_in_vreg(ctx, arg2);
                    let v5 = constructor_put_in_vreg(ctx, arg3);
                    let v13 = constructor_pulley_vlteqf64x2(ctx, v4, v5);
                    // Rule at src/isa/pulley_shared/lower.isle line 943.
                    return v13;
                }
                _ => {}
            }
        }
        &FloatCC::NotEqual => {
            match arg0 {
                F32X4 => {
                    let v4 = constructor_put_in_vreg(ctx, arg2);
                    let v5 = constructor_put_in_vreg(ctx, arg3);
                    let v8 = constructor_pulley_vneqf32x4(ctx, v4, v5);
                    // Rule at src/isa/pulley_shared/lower.isle line 938.
                    return v8;
                }
                F64X2 => {
                    let v4 = constructor_put_in_vreg(ctx, arg2);
                    let v5 = constructor_put_in_vreg(ctx, arg3);
                    let v9 = constructor_pulley_vneqf64x2(ctx, v4, v5);
                    // Rule at src/isa/pulley_shared/lower.isle line 939.
                    return v9;
                }
                _ => {}
            }
        }
        &FloatCC::Unordered => {
            let v15 = constructor_lower_vfcmp(ctx, arg0, &FloatCC::NotEqual, arg2, arg2);
            let v16 = constructor_lower_vfcmp(ctx, arg0, &FloatCC::NotEqual, arg3, arg3);
            let v17 = constructor_pulley_vbor128(ctx, v15, v16);
            // Rule at src/isa/pulley_shared/lower.isle line 945.
            return v17;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "lower_vfcmp", "src/isa/pulley_shared/lower.isle line 934")
}

// Generated as internal constructor for term gen_xload.
pub fn constructor_gen_xload<C: Context>(
    ctx: &mut C,
    arg0: Value,
    arg1: Offset32,
    arg2: MemFlagsData,
    arg3: Type,
    arg4: &ExtKind,
) -> XReg {
    let v15 = &constructor_wasm_g32(ctx, arg0, arg1, arg2, arg3);
    if let Some(v16) = v15 {
        let v17 = constructor_gen_xload_g32(ctx, v16, arg3, arg4);
        // Rule at src/isa/pulley_shared/lower.isle line 1131.
        return v17;
    }
    let v6 = &C::endianness(ctx, arg2);
    match v6 {
        &Endianness::Little => {
            let v10 = &C::memflags_trapping(ctx, arg2);
            if let Some(v11) = v10 {
                let v12 = &constructor_addrz(ctx, arg0, arg1);
                let v13 = constructor_emit_addrz_xload_le(ctx, v12, arg3, arg4, v11);
                // Rule at src/isa/pulley_shared/lower.isle line 1087.
                return v13;
            }
            let v5 = C::memflags_nontrapping(ctx, arg2);
            if v5 == true {
                let v7 = &constructor_addro32(ctx, arg0, arg1);
                let v9 = constructor_emit_addro32_xload_le(ctx, v7, arg3, arg4);
                // Rule at src/isa/pulley_shared/lower.isle line 1062.
                return v9;
            }
        }
        &Endianness::Big => {
            let v10 = &C::memflags_trapping(ctx, arg2);
            if let Some(v11) = v10 {
                let v12 = &constructor_addrz(ctx, arg0, arg1);
                let v14 = constructor_emit_addrz_xload_be(ctx, v12, arg3, arg4, v11);
                // Rule at src/isa/pulley_shared/lower.isle line 1091.
                return v14;
            }
            let v5 = C::memflags_nontrapping(ctx, arg2);
            if v5 == true {
                let v7 = &constructor_addro32(ctx, arg0, arg1);
                let v8 = constructor_emit_addro32_xload_be(ctx, v7, arg3, arg4);
                // Rule at src/isa/pulley_shared/lower.isle line 1041.
                return v8;
            }
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "gen_xload", "src/isa/pulley_shared/lower.isle line 1035")
}

// Generated as internal constructor for term emit_addro32_xload_be.
pub fn constructor_emit_addro32_xload_be<C: Context>(
    ctx: &mut C,
    arg0: &AddrO32,
    arg1: Type,
    arg2: &ExtKind,
) -> XReg {
    match arg1 {
        I8 => {
            let v4 = constructor_emit_addro32_xload_le(ctx, arg0, I8, arg2);
            // Rule at src/isa/pulley_shared/lower.isle line 1047.
            return v4;
        }
        I16 => {
            match arg2 {
                &ExtKind::None => {
                    let v5 = constructor_pulley_xload16be_u32_o32(ctx, arg0);
                    // Rule at src/isa/pulley_shared/lower.isle line 1048.
                    return v5;
                }
                &ExtKind::Sign32 => {
                    let v6 = constructor_pulley_xload16be_s32_o32(ctx, arg0);
                    // Rule at src/isa/pulley_shared/lower.isle line 1049.
                    return v6;
                }
                &ExtKind::Sign64 => {
                    let v6 = constructor_pulley_xload16be_s32_o32(ctx, arg0);
                    let v7 = constructor_pulley_sext32(ctx, v6);
                    // Rule at src/isa/pulley_shared/lower.isle line 1051.
                    return v7;
                }
                &ExtKind::Zero32 => {
                    let v5 = constructor_pulley_xload16be_u32_o32(ctx, arg0);
                    // Rule at src/isa/pulley_shared/lower.isle line 1050.
                    return v5;
                }
                &ExtKind::Zero64 => {
                    let v5 = constructor_pulley_xload16be_u32_o32(ctx, arg0);
                    let v8 = constructor_pulley_zext32(ctx, v5);
                    // Rule at src/isa/pulley_shared/lower.isle line 1052.
                    return v8;
                }
                _ => {}
            }
        }
        I32 => {
            match arg2 {
                &ExtKind::None => {
                    let v9 = constructor_pulley_xload32be_o32(ctx, arg0);
                    // Rule at src/isa/pulley_shared/lower.isle line 1053.
                    return v9;
                }
                &ExtKind::Sign32 => {
                    let v9 = constructor_pulley_xload32be_o32(ctx, arg0);
                    // Rule at src/isa/pulley_shared/lower.isle line 1054.
                    return v9;
                }
                &ExtKind::Sign64 => {
                    let v9 = constructor_pulley_xload32be_o32(ctx, arg0);
                    let v10 = constructor_pulley_sext32(ctx, v9);
                    // Rule at src/isa/pulley_shared/lower.isle line 1056.
                    return v10;
                }
                &ExtKind::Zero32 => {
                    let v9 = constructor_pulley_xload32be_o32(ctx, arg0);
                    // Rule at src/isa/pulley_shared/lower.isle line 1055.
                    return v9;
                }
                &ExtKind::Zero64 => {
                    let v9 = constructor_pulley_xload32be_o32(ctx, arg0);
                    let v11 = constructor_pulley_zext32(ctx, v9);
                    // Rule at src/isa/pulley_shared/lower.isle line 1057.
                    return v11;
                }
                _ => {}
            }
        }
        I64 => {
            let v12 = constructor_pulley_xload64be_o32(ctx, arg0);
            // Rule at src/isa/pulley_shared/lower.isle line 1058.
            return v12;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "emit_addro32_xload_be", "src/isa/pulley_shared/lower.isle line 1046")
}

// Generated as internal constructor for term emit_addro32_xload_le.
pub fn constructor_emit_addro32_xload_le<C: Context>(
    ctx: &mut C,
    arg0: &AddrO32,
    arg1: Type,
    arg2: &ExtKind,
) -> XReg {
    match arg1 {
        I8 => {
            match arg2 {
                &ExtKind::None => {
                    let v3 = constructor_pulley_xload8_u32_o32(ctx, arg0);
                    // Rule at src/isa/pulley_shared/lower.isle line 1068.
                    return v3;
                }
                &ExtKind::Sign32 => {
                    let v4 = constructor_pulley_xload8_s32_o32(ctx, arg0);
                    // Rule at src/isa/pulley_shared/lower.isle line 1069.
                    return v4;
                }
                &ExtKind::Sign64 => {
                    let v4 = constructor_pulley_xload8_s32_o32(ctx, arg0);
                    let v5 = constructor_pulley_sext32(ctx, v4);
                    // Rule at src/isa/pulley_shared/lower.isle line 1071.
                    return v5;
                }
                &ExtKind::Zero32 => {
                    let v3 = constructor_pulley_xload8_u32_o32(ctx, arg0);
                    // Rule at src/isa/pulley_shared/lower.isle line 1070.
                    return v3;
                }
                &ExtKind::Zero64 => {
                    let v3 = constructor_pulley_xload8_u32_o32(ctx, arg0);
                    let v6 = constructor_pulley_zext32(ctx, v3);
                    // Rule at src/isa/pulley_shared/lower.isle line 1072.
                    return v6;
                }
                _ => {}
            }
        }
        I16 => {
            match arg2 {
                &ExtKind::None => {
                    let v7 = constructor_pulley_xload16le_u32_o32(ctx, arg0);
                    // Rule at src/isa/pulley_shared/lower.isle line 1073.
                    return v7;
                }
                &ExtKind::Sign32 => {
                    let v8 = constructor_pulley_xload16le_s32_o32(ctx, arg0);
                    // Rule at src/isa/pulley_shared/lower.isle line 1074.
                    return v8;
                }
                &ExtKind::Sign64 => {
                    let v8 = constructor_pulley_xload16le_s32_o32(ctx, arg0);
                    let v9 = constructor_pulley_sext32(ctx, v8);
                    // Rule at src/isa/pulley_shared/lower.isle line 1076.
                    return v9;
                }
                &ExtKind::Zero32 => {
                    let v7 = constructor_pulley_xload16le_u32_o32(ctx, arg0);
                    // Rule at src/isa/pulley_shared/lower.isle line 1075.
                    return v7;
                }
                &ExtKind::Zero64 => {
                    let v7 = constructor_pulley_xload16le_u32_o32(ctx, arg0);
                    let v10 = constructor_pulley_zext32(ctx, v7);
                    // Rule at src/isa/pulley_shared/lower.isle line 1077.
                    return v10;
                }
                _ => {}
            }
        }
        I32 => {
            match arg2 {
                &ExtKind::None => {
                    let v11 = constructor_pulley_xload32le_o32(ctx, arg0);
                    // Rule at src/isa/pulley_shared/lower.isle line 1078.
                    return v11;
                }
                &ExtKind::Sign32 => {
                    let v11 = constructor_pulley_xload32le_o32(ctx, arg0);
                    // Rule at src/isa/pulley_shared/lower.isle line 1079.
                    return v11;
                }
                &ExtKind::Sign64 => {
                    let v11 = constructor_pulley_xload32le_o32(ctx, arg0);
                    let v12 = constructor_pulley_sext32(ctx, v11);
                    // Rule at src/isa/pulley_shared/lower.isle line 1081.
                    return v12;
                }
                &ExtKind::Zero32 => {
                    let v11 = constructor_pulley_xload32le_o32(ctx, arg0);
                    // Rule at src/isa/pulley_shared/lower.isle line 1080.
                    return v11;
                }
                &ExtKind::Zero64 => {
                    let v11 = constructor_pulley_xload32le_o32(ctx, arg0);
                    let v13 = constructor_pulley_zext32(ctx, v11);
                    // Rule at src/isa/pulley_shared/lower.isle line 1082.
                    return v13;
                }
                _ => {}
            }
        }
        I64 => {
            let v14 = constructor_pulley_xload64le_o32(ctx, arg0);
            // Rule at src/isa/pulley_shared/lower.isle line 1083.
            return v14;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "emit_addro32_xload_le", "src/isa/pulley_shared/lower.isle line 1067")
}

// Generated as internal constructor for term emit_addrz_xload_le.
pub fn constructor_emit_addrz_xload_le<C: Context>(
    ctx: &mut C,
    arg0: &AddrZ,
    arg1: Type,
    arg2: &ExtKind,
    arg3: &TrapCode,
) -> XReg {
    match arg1 {
        I8 => {
            match arg2 {
                &ExtKind::None => {
                    let v4 = constructor_pulley_xload8_u32_z(ctx, arg0, arg3);
                    // Rule at src/isa/pulley_shared/lower.isle line 1097.
                    return v4;
                }
                &ExtKind::Sign32 => {
                    let v5 = constructor_pulley_xload8_s32_z(ctx, arg0, arg3);
                    // Rule at src/isa/pulley_shared/lower.isle line 1098.
                    return v5;
                }
                &ExtKind::Sign64 => {
                    let v5 = constructor_pulley_xload8_s32_z(ctx, arg0, arg3);
                    let v6 = constructor_pulley_sext32(ctx, v5);
                    // Rule at src/isa/pulley_shared/lower.isle line 1100.
                    return v6;
                }
                &ExtKind::Zero32 => {
                    let v4 = constructor_pulley_xload8_u32_z(ctx, arg0, arg3);
                    // Rule at src/isa/pulley_shared/lower.isle line 1099.
                    return v4;
                }
                &ExtKind::Zero64 => {
                    let v4 = constructor_pulley_xload8_u32_z(ctx, arg0, arg3);
                    let v7 = constructor_pulley_zext32(ctx, v4);
                    // Rule at src/isa/pulley_shared/lower.isle line 1101.
                    return v7;
                }
                _ => {}
            }
        }
        I16 => {
            match arg2 {
                &ExtKind::None => {
                    let v8 = constructor_pulley_xload16le_u32_z(ctx, arg0, arg3);
                    // Rule at src/isa/pulley_shared/lower.isle line 1102.
                    return v8;
                }
                &ExtKind::Sign32 => {
                    let v9 = constructor_pulley_xload16le_s32_z(ctx, arg0, arg3);
                    // Rule at src/isa/pulley_shared/lower.isle line 1103.
                    return v9;
                }
                &ExtKind::Sign64 => {
                    let v9 = constructor_pulley_xload16le_s32_z(ctx, arg0, arg3);
                    let v10 = constructor_pulley_sext32(ctx, v9);
                    // Rule at src/isa/pulley_shared/lower.isle line 1105.
                    return v10;
                }
                &ExtKind::Zero32 => {
                    let v8 = constructor_pulley_xload16le_u32_z(ctx, arg0, arg3);
                    // Rule at src/isa/pulley_shared/lower.isle line 1104.
                    return v8;
                }
                &ExtKind::Zero64 => {
                    let v8 = constructor_pulley_xload16le_u32_z(ctx, arg0, arg3);
                    let v11 = constructor_pulley_zext32(ctx, v8);
                    // Rule at src/isa/pulley_shared/lower.isle line 1106.
                    return v11;
                }
                _ => {}
            }
        }
        I32 => {
            match arg2 {
                &ExtKind::None => {
                    let v12 = constructor_pulley_xload32le_z(ctx, arg0, arg3);
                    // Rule at src/isa/pulley_shared/lower.isle line 1107.
                    return v12;
                }
                &ExtKind::Sign32 => {
                    let v12 = constructor_pulley_xload32le_z(ctx, arg0, arg3);
                    // Rule at src/isa/pulley_shared/lower.isle line 1108.
                    return v12;
                }
                &ExtKind::Sign64 => {
                    let v12 = constructor_pulley_xload32le_z(ctx, arg0, arg3);
                    let v13 = constructor_pulley_sext32(ctx, v12);
                    // Rule at src/isa/pulley_shared/lower.isle line 1110.
                    return v13;
                }
                &ExtKind::Zero32 => {
                    let v12 = constructor_pulley_xload32le_z(ctx, arg0, arg3);
                    // Rule at src/isa/pulley_shared/lower.isle line 1109.
                    return v12;
                }
                &ExtKind::Zero64 => {
                    let v12 = constructor_pulley_xload32le_z(ctx, arg0, arg3);
                    let v14 = constructor_pulley_zext32(ctx, v12);
                    // Rule at src/isa/pulley_shared/lower.isle line 1111.
                    return v14;
                }
                _ => {}
            }
        }
        I64 => {
            let v15 = constructor_pulley_xload64le_z(ctx, arg0, arg3);
            // Rule at src/isa/pulley_shared/lower.isle line 1112.
            return v15;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "emit_addrz_xload_le", "src/isa/pulley_shared/lower.isle line 1096")
}

// Generated as internal constructor for term emit_addrz_xload_be.
pub fn constructor_emit_addrz_xload_be<C: Context>(
    ctx: &mut C,
    arg0: &AddrZ,
    arg1: Type,
    arg2: &ExtKind,
    arg3: &TrapCode,
) -> XReg {
    match arg1 {
        I8 => {
            let v5 = constructor_emit_addrz_xload_le(ctx, arg0, I8, arg2, arg3);
            // Rule at src/isa/pulley_shared/lower.isle line 1115.
            return v5;
        }
        I16 => {
            match arg2 {
                &ExtKind::None => {
                    let v6 = constructor_pulley_xload16be_u32_z(ctx, arg0, arg3);
                    // Rule at src/isa/pulley_shared/lower.isle line 1116.
                    return v6;
                }
                &ExtKind::Sign32 => {
                    let v7 = constructor_pulley_xload16be_s32_z(ctx, arg0, arg3);
                    // Rule at src/isa/pulley_shared/lower.isle line 1117.
                    return v7;
                }
                &ExtKind::Sign64 => {
                    let v7 = constructor_pulley_xload16be_s32_z(ctx, arg0, arg3);
                    let v8 = constructor_pulley_sext32(ctx, v7);
                    // Rule at src/isa/pulley_shared/lower.isle line 1119.
                    return v8;
                }
                &ExtKind::Zero32 => {
                    let v6 = constructor_pulley_xload16be_u32_z(ctx, arg0, arg3);
                    // Rule at src/isa/pulley_shared/lower.isle line 1118.
                    return v6;
                }
                &ExtKind::Zero64 => {
                    let v6 = constructor_pulley_xload16be_u32_z(ctx, arg0, arg3);
                    let v9 = constructor_pulley_zext32(ctx, v6);
                    // Rule at src/isa/pulley_shared/lower.isle line 1120.
                    return v9;
                }
                _ => {}
            }
        }
        I32 => {
            match arg2 {
                &ExtKind::None => {
                    let v10 = constructor_pulley_xload32be_z(ctx, arg0, arg3);
                    // Rule at src/isa/pulley_shared/lower.isle line 1121.
                    return v10;
                }
                &ExtKind::Sign32 => {
                    let v10 = constructor_pulley_xload32be_z(ctx, arg0, arg3);
                    // Rule at src/isa/pulley_shared/lower.isle line 1122.
                    return v10;
                }
                &ExtKind::Sign64 => {
                    let v10 = constructor_pulley_xload32be_z(ctx, arg0, arg3);
                    let v11 = constructor_pulley_sext32(ctx, v10);
                    // Rule at src/isa/pulley_shared/lower.isle line 1124.
                    return v11;
                }
                &ExtKind::Zero32 => {
                    let v10 = constructor_pulley_xload32be_z(ctx, arg0, arg3);
                    // Rule at src/isa/pulley_shared/lower.isle line 1123.
                    return v10;
                }
                &ExtKind::Zero64 => {
                    let v10 = constructor_pulley_xload32be_z(ctx, arg0, arg3);
                    let v12 = constructor_pulley_zext32(ctx, v10);
                    // Rule at src/isa/pulley_shared/lower.isle line 1125.
                    return v12;
                }
                _ => {}
            }
        }
        I64 => {
            let v13 = constructor_pulley_xload64be_z(ctx, arg0, arg3);
            // Rule at src/isa/pulley_shared/lower.isle line 1126.
            return v13;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "emit_addrz_xload_be", "src/isa/pulley_shared/lower.isle line 1114")
}

// Generated as internal constructor for term gen_xload_g32.
pub fn constructor_gen_xload_g32<C: Context>(
    ctx: &mut C,
    arg0: &G32,
    arg1: Type,
    arg2: &ExtKind,
) -> XReg {
    let v5 = &constructor_addrg32bne(ctx, arg0);
    if let Some(v6) = v5 {
        let v7 = &constructor_gen_addrg32bne(ctx, v6);
        let v8 = constructor_emit_addrg32bne_xload(ctx, v7, arg1, arg2);
        // Rule at src/isa/pulley_shared/lower.isle line 1158.
        return v8;
    }
    let v3 = &constructor_gen_addrg32(ctx, arg0);
    let v4 = constructor_emit_addrg32_xload(ctx, v3, arg1, arg2);
    // Rule at src/isa/pulley_shared/lower.isle line 1137.
    return v4;
}

// Generated as internal constructor for term emit_addrg32_xload.
pub fn constructor_emit_addrg32_xload<C: Context>(
    ctx: &mut C,
    arg0: &AddrG32,
    arg1: Type,
    arg2: &ExtKind,
) -> XReg {
    match arg1 {
        I8 => {
            match arg2 {
                &ExtKind::None => {
                    let v3 = constructor_pulley_xload8_u32_g32(ctx, arg0);
                    // Rule at src/isa/pulley_shared/lower.isle line 1140.
                    return v3;
                }
                &ExtKind::Sign32 => {
                    let v4 = constructor_pulley_xload8_s32_g32(ctx, arg0);
                    // Rule at src/isa/pulley_shared/lower.isle line 1141.
                    return v4;
                }
                &ExtKind::Sign64 => {
                    let v4 = constructor_pulley_xload8_s32_g32(ctx, arg0);
                    let v5 = constructor_pulley_sext32(ctx, v4);
                    // Rule at src/isa/pulley_shared/lower.isle line 1143.
                    return v5;
                }
                &ExtKind::Zero32 => {
                    let v3 = constructor_pulley_xload8_u32_g32(ctx, arg0);
                    // Rule at src/isa/pulley_shared/lower.isle line 1142.
                    return v3;
                }
                &ExtKind::Zero64 => {
                    let v3 = constructor_pulley_xload8_u32_g32(ctx, arg0);
                    let v6 = constructor_pulley_zext32(ctx, v3);
                    // Rule at src/isa/pulley_shared/lower.isle line 1144.
                    return v6;
                }
                _ => {}
            }
        }
        I16 => {
            match arg2 {
                &ExtKind::None => {
                    let v7 = constructor_pulley_xload16le_u32_g32(ctx, arg0);
                    // Rule at src/isa/pulley_shared/lower.isle line 1145.
                    return v7;
                }
                &ExtKind::Sign32 => {
                    let v8 = constructor_pulley_xload16le_s32_g32(ctx, arg0);
                    // Rule at src/isa/pulley_shared/lower.isle line 1146.
                    return v8;
                }
                &ExtKind::Sign64 => {
                    let v8 = constructor_pulley_xload16le_s32_g32(ctx, arg0);
                    let v9 = constructor_pulley_sext32(ctx, v8);
                    // Rule at src/isa/pulley_shared/lower.isle line 1148.
                    return v9;
                }
                &ExtKind::Zero32 => {
                    let v7 = constructor_pulley_xload16le_u32_g32(ctx, arg0);
                    // Rule at src/isa/pulley_shared/lower.isle line 1147.
                    return v7;
                }
                &ExtKind::Zero64 => {
                    let v7 = constructor_pulley_xload16le_u32_g32(ctx, arg0);
                    let v10 = constructor_pulley_zext32(ctx, v7);
                    // Rule at src/isa/pulley_shared/lower.isle line 1149.
                    return v10;
                }
                _ => {}
            }
        }
        I32 => {
            match arg2 {
                &ExtKind::None => {
                    let v11 = constructor_pulley_xload32le_g32(ctx, arg0);
                    // Rule at src/isa/pulley_shared/lower.isle line 1150.
                    return v11;
                }
                &ExtKind::Sign32 => {
                    let v11 = constructor_pulley_xload32le_g32(ctx, arg0);
                    // Rule at src/isa/pulley_shared/lower.isle line 1151.
                    return v11;
                }
                &ExtKind::Sign64 => {
                    let v11 = constructor_pulley_xload32le_g32(ctx, arg0);
                    let v12 = constructor_pulley_sext32(ctx, v11);
                    // Rule at src/isa/pulley_shared/lower.isle line 1153.
                    return v12;
                }
                &ExtKind::Zero32 => {
                    let v11 = constructor_pulley_xload32le_g32(ctx, arg0);
                    // Rule at src/isa/pulley_shared/lower.isle line 1152.
                    return v11;
                }
                &ExtKind::Zero64 => {
                    let v11 = constructor_pulley_xload32le_g32(ctx, arg0);
                    let v13 = constructor_pulley_zext32(ctx, v11);
                    // Rule at src/isa/pulley_shared/lower.isle line 1154.
                    return v13;
                }
                _ => {}
            }
        }
        I64 => {
            let v14 = constructor_pulley_xload64le_g32(ctx, arg0);
            // Rule at src/isa/pulley_shared/lower.isle line 1155.
            return v14;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "emit_addrg32_xload", "src/isa/pulley_shared/lower.isle line 1139")
}

// Generated as internal constructor for term emit_addrg32bne_xload.
pub fn constructor_emit_addrg32bne_xload<C: Context>(
    ctx: &mut C,
    arg0: &AddrG32Bne,
    arg1: Type,
    arg2: &ExtKind,
) -> XReg {
    match arg1 {
        I8 => {
            match arg2 {
                &ExtKind::None => {
                    let v3 = constructor_pulley_xload8_u32_g32bne(ctx, arg0);
                    // Rule at src/isa/pulley_shared/lower.isle line 1163.
                    return v3;
                }
                &ExtKind::Sign32 => {
                    let v4 = constructor_pulley_xload8_s32_g32bne(ctx, arg0);
                    // Rule at src/isa/pulley_shared/lower.isle line 1164.
                    return v4;
                }
                &ExtKind::Sign64 => {
                    let v4 = constructor_pulley_xload8_s32_g32bne(ctx, arg0);
                    let v5 = constructor_pulley_sext32(ctx, v4);
                    // Rule at src/isa/pulley_shared/lower.isle line 1166.
                    return v5;
                }
                &ExtKind::Zero32 => {
                    let v3 = constructor_pulley_xload8_u32_g32bne(ctx, arg0);
                    // Rule at src/isa/pulley_shared/lower.isle line 1165.
                    return v3;
                }
                &ExtKind::Zero64 => {
                    let v3 = constructor_pulley_xload8_u32_g32bne(ctx, arg0);
                    let v6 = constructor_pulley_zext32(ctx, v3);
                    // Rule at src/isa/pulley_shared/lower.isle line 1167.
                    return v6;
                }
                _ => {}
            }
        }
        I16 => {
            match arg2 {
                &ExtKind::None => {
                    let v7 = constructor_pulley_xload16le_u32_g32bne(ctx, arg0);
                    // Rule at src/isa/pulley_shared/lower.isle line 1168.
                    return v7;
                }
                &ExtKind::Sign32 => {
                    let v8 = constructor_pulley_xload16le_s32_g32bne(ctx, arg0);
                    // Rule at src/isa/pulley_shared/lower.isle line 1169.
                    return v8;
                }
                &ExtKind::Sign64 => {
                    let v8 = constructor_pulley_xload16le_s32_g32bne(ctx, arg0);
                    let v9 = constructor_pulley_sext32(ctx, v8);
                    // Rule at src/isa/pulley_shared/lower.isle line 1171.
                    return v9;
                }
                &ExtKind::Zero32 => {
                    let v7 = constructor_pulley_xload16le_u32_g32bne(ctx, arg0);
                    // Rule at src/isa/pulley_shared/lower.isle line 1170.
                    return v7;
                }
                &ExtKind::Zero64 => {
                    let v7 = constructor_pulley_xload16le_u32_g32bne(ctx, arg0);
                    let v10 = constructor_pulley_zext32(ctx, v7);
                    // Rule at src/isa/pulley_shared/lower.isle line 1172.
                    return v10;
                }
                _ => {}
            }
        }
        I32 => {
            match arg2 {
                &ExtKind::None => {
                    let v11 = constructor_pulley_xload32le_g32bne(ctx, arg0);
                    // Rule at src/isa/pulley_shared/lower.isle line 1173.
                    return v11;
                }
                &ExtKind::Sign32 => {
                    let v11 = constructor_pulley_xload32le_g32bne(ctx, arg0);
                    // Rule at src/isa/pulley_shared/lower.isle line 1174.
                    return v11;
                }
                &ExtKind::Sign64 => {
                    let v11 = constructor_pulley_xload32le_g32bne(ctx, arg0);
                    let v12 = constructor_pulley_sext32(ctx, v11);
                    // Rule at src/isa/pulley_shared/lower.isle line 1176.
                    return v12;
                }
                &ExtKind::Zero32 => {
                    let v11 = constructor_pulley_xload32le_g32bne(ctx, arg0);
                    // Rule at src/isa/pulley_shared/lower.isle line 1175.
                    return v11;
                }
                &ExtKind::Zero64 => {
                    let v11 = constructor_pulley_xload32le_g32bne(ctx, arg0);
                    let v13 = constructor_pulley_zext32(ctx, v11);
                    // Rule at src/isa/pulley_shared/lower.isle line 1177.
                    return v13;
                }
                _ => {}
            }
        }
        I64 => {
            let v14 = constructor_pulley_xload64le_g32bne(ctx, arg0);
            // Rule at src/isa/pulley_shared/lower.isle line 1178.
            return v14;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "emit_addrg32bne_xload", "src/isa/pulley_shared/lower.isle line 1162")
}

// Generated as internal constructor for term gen_fload.
pub fn constructor_gen_fload<C: Context>(
    ctx: &mut C,
    arg0: Value,
    arg1: Offset32,
    arg2: MemFlagsData,
    arg3: Type,
) -> FReg {
    let v13 = &constructor_wasm_g32(ctx, arg0, arg1, arg2, arg3);
    if let Some(v14) = v13 {
        let v15 = &constructor_gen_addrg32(ctx, v14);
        let v16 = constructor_emit_addrg32_fload(ctx, v15, arg3);
        // Rule at src/isa/pulley_shared/lower.isle line 1209.
        return v16;
    }
    let v7 = &C::memflags_trapping(ctx, arg2);
    if let Some(v8) = v7 {
        let v9 = &C::endianness(ctx, arg2);
        match v9 {
            &Endianness::Little => {
                let v10 = &constructor_addrz(ctx, arg0, arg1);
                let v11 = constructor_emit_addrz_fload_le(ctx, v10, arg3, v8);
                // Rule at src/isa/pulley_shared/lower.isle line 1191.
                return v11;
            }
            &Endianness::Big => {
                let v10 = &constructor_addrz(ctx, arg0, arg1);
                let v12 = constructor_emit_addrz_fload_be(ctx, v10, arg3, v8);
                // Rule at src/isa/pulley_shared/lower.isle line 1195.
                return v12;
            }
            _ => {}
        }
    }
    let v4 = C::memflags_nontrapping(ctx, arg2);
    if v4 == true {
        let v5 = &constructor_amode(ctx, arg0, arg1);
        let v6 = constructor_pulley_fload(ctx, v5, arg3, arg2);
        // Rule at src/isa/pulley_shared/lower.isle line 1185.
        return v6;
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "gen_fload", "src/isa/pulley_shared/lower.isle line 1181")
}

// Generated as internal constructor for term emit_addrz_fload_le.
pub fn constructor_emit_addrz_fload_le<C: Context>(
    ctx: &mut C,
    arg0: &AddrZ,
    arg1: Type,
    arg2: &TrapCode,
) -> FReg {
    match arg1 {
        F32 => {
            let v3 = constructor_pulley_fload32le_z(ctx, arg0, arg2);
            // Rule at src/isa/pulley_shared/lower.isle line 1201.
            return v3;
        }
        F64 => {
            let v4 = constructor_pulley_fload64le_z(ctx, arg0, arg2);
            // Rule at src/isa/pulley_shared/lower.isle line 1202.
            return v4;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "emit_addrz_fload_le", "src/isa/pulley_shared/lower.isle line 1200")
}

// Generated as internal constructor for term emit_addrz_fload_be.
pub fn constructor_emit_addrz_fload_be<C: Context>(
    ctx: &mut C,
    arg0: &AddrZ,
    arg1: Type,
    arg2: &TrapCode,
) -> FReg {
    match arg1 {
        F32 => {
            let v3 = constructor_pulley_fload32be_z(ctx, arg0, arg2);
            // Rule at src/isa/pulley_shared/lower.isle line 1204.
            return v3;
        }
        F64 => {
            let v4 = constructor_pulley_fload64be_z(ctx, arg0, arg2);
            // Rule at src/isa/pulley_shared/lower.isle line 1205.
            return v4;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "emit_addrz_fload_be", "src/isa/pulley_shared/lower.isle line 1203")
}

// Generated as internal constructor for term emit_addrg32_fload.
pub fn constructor_emit_addrg32_fload<C: Context>(
    ctx: &mut C,
    arg0: &AddrG32,
    arg1: Type,
) -> FReg {
    match arg1 {
        F32 => {
            let v2 = constructor_pulley_fload32le_g32(ctx, arg0);
            // Rule at src/isa/pulley_shared/lower.isle line 1214.
            return v2;
        }
        F64 => {
            let v3 = constructor_pulley_fload64le_g32(ctx, arg0);
            // Rule at src/isa/pulley_shared/lower.isle line 1215.
            return v3;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "emit_addrg32_fload", "src/isa/pulley_shared/lower.isle line 1213")
}

// Generated as internal constructor for term gen_vload.
pub fn constructor_gen_vload<C: Context>(
    ctx: &mut C,
    arg0: Value,
    arg1: Offset32,
    arg2: MemFlagsData,
    arg3: Type,
    arg4: &VExtKind,
) -> VReg {
    if let &VExtKind::None = arg4 {
        let v14 = C::ty_vec128(ctx, arg3);
        if let Some(v15) = v14 {
            let v16 = &constructor_wasm_g32(ctx, arg0, arg1, arg2, v15);
            if let Some(v17) = v16 {
                let v18 = &constructor_gen_addrg32(ctx, v17);
                let v19 = constructor_pulley_vload128le_g32(ctx, v18);
                // Rule at src/isa/pulley_shared/lower.isle line 1251.
                return v19;
            }
        }
    }
    let v8 = &C::memflags_trapping(ctx, arg2);
    if let Some(v9) = v8 {
        let v10 = &C::endianness(ctx, arg2);
        match v10 {
            &Endianness::Little => {
                let v11 = &constructor_addrz(ctx, arg0, arg1);
                let v12 = constructor_emit_addrz_vload_le(ctx, v11, arg3, arg4, v9);
                // Rule at src/isa/pulley_shared/lower.isle line 1228.
                return v12;
            }
            &Endianness::Big => {
                let v11 = &constructor_addrz(ctx, arg0, arg1);
                let v13 = constructor_emit_addrz_vload_be(ctx, v11, arg3, arg4, v9);
                // Rule at src/isa/pulley_shared/lower.isle line 1232.
                return v13;
            }
            _ => {}
        }
    }
    if let &VExtKind::None = arg4 {
        let v5 = C::memflags_nontrapping(ctx, arg2);
        if v5 == true {
            let v6 = &constructor_amode(ctx, arg0, arg1);
            let v7 = constructor_pulley_vload(ctx, v6, arg3, arg2);
            // Rule at src/isa/pulley_shared/lower.isle line 1223.
            return v7;
        }
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "gen_vload", "src/isa/pulley_shared/lower.isle line 1218")
}

// Generated as internal constructor for term emit_addrz_vload_le.
pub fn constructor_emit_addrz_vload_le<C: Context>(
    ctx: &mut C,
    arg0: &AddrZ,
    arg1: Type,
    arg2: &VExtKind,
    arg3: &TrapCode,
) -> VReg {
    let v2 = C::ty_vec128(ctx, arg1);
    if let Some(v3) = v2 {
        match arg2 {
            &VExtKind::None => {
                let v6 = constructor_pulley_vload128le_z(ctx, arg0, arg3);
                // Rule at src/isa/pulley_shared/lower.isle line 1238.
                return v6;
            }
            &VExtKind::S8x8 => {
                let v7 = constructor_pulley_vload8x8_s_z(ctx, arg0, arg3);
                // Rule at src/isa/pulley_shared/lower.isle line 1239.
                return v7;
            }
            &VExtKind::U8x8 => {
                let v8 = constructor_pulley_vload8x8_u_z(ctx, arg0, arg3);
                // Rule at src/isa/pulley_shared/lower.isle line 1240.
                return v8;
            }
            &VExtKind::S16x4 => {
                let v9 = constructor_pulley_vload16x4le_s_z(ctx, arg0, arg3);
                // Rule at src/isa/pulley_shared/lower.isle line 1241.
                return v9;
            }
            &VExtKind::U16x4 => {
                let v10 = constructor_pulley_vload16x4le_u_z(ctx, arg0, arg3);
                // Rule at src/isa/pulley_shared/lower.isle line 1242.
                return v10;
            }
            &VExtKind::S32x2 => {
                let v11 = constructor_pulley_vload32x2le_s_z(ctx, arg0, arg3);
                // Rule at src/isa/pulley_shared/lower.isle line 1243.
                return v11;
            }
            &VExtKind::U32x2 => {
                let v12 = constructor_pulley_vload32x2le_u_z(ctx, arg0, arg3);
                // Rule at src/isa/pulley_shared/lower.isle line 1244.
                return v12;
            }
            _ => {}
        }
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "emit_addrz_vload_le", "src/isa/pulley_shared/lower.isle line 1237")
}

// Generated as internal constructor for term emit_addrz_vload_be.
pub fn constructor_emit_addrz_vload_be<C: Context>(
    ctx: &mut C,
    arg0: &AddrZ,
    arg1: Type,
    arg2: &VExtKind,
    arg3: &TrapCode,
) -> VReg {
    let v2 = C::ty_vec128(ctx, arg1);
    if let Some(v3) = v2 {
        if let &VExtKind::None = arg2 {
            let v6 = constructor_pulley_vload128be_z(ctx, arg0, arg3);
            // Rule at src/isa/pulley_shared/lower.isle line 1247.
            return v6;
        }
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "emit_addrz_vload_be", "src/isa/pulley_shared/lower.isle line 1246")
}

// Generated as internal constructor for term emit_store_i128.
pub fn constructor_emit_store_i128<C: Context>(
    ctx: &mut C,
    arg0: MemFlagsData,
    arg1: XReg,
    arg2: XReg,
    arg3: &Amode,
    arg4: &Amode,
) -> SideEffectNoResult {
    let v5 = &C::endianness(ctx, arg0);
    match v5 {
        &Endianness::Little => {
            let v7 = &constructor_pulley_xstore(ctx, arg3, arg1, I64, arg0);
            let v8 = constructor_side_effect(ctx, v7);
            let v9 = &constructor_pulley_xstore(ctx, arg4, arg2, I64, arg0);
            // Rule at src/isa/pulley_shared/lower.isle line 1289.
            return v9.clone();
        }
        &Endianness::Big => {
            let v10 = &constructor_pulley_xstore(ctx, arg3, arg2, I64, arg0);
            let v11 = constructor_side_effect(ctx, v10);
            let v12 = &constructor_pulley_xstore(ctx, arg4, arg1, I64, arg0);
            // Rule at src/isa/pulley_shared/lower.isle line 1293.
            return v12.clone();
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "emit_store_i128", "src/isa/pulley_shared/lower.isle line 1288")
}

// Generated as internal constructor for term gen_store.
pub fn constructor_gen_store<C: Context>(
    ctx: &mut C,
    arg0: Value,
    arg1: Value,
    arg2: Offset32,
    arg3: MemFlagsData,
    arg4: Type,
) -> SideEffectNoResult {
    let v25 = &constructor_wasm_g32(ctx, arg1, arg2, arg3, arg4);
    if let Some(v26) = v25 {
        let v27 = &constructor_gen_addrg32(ctx, v26);
        let v28 = &constructor_emit_addrg32_store(ctx, v27, arg0, arg4);
        // Rule at src/isa/pulley_shared/lower.isle line 1343.
        return v28.clone();
    }
    let v19 = &C::memflags_trapping(ctx, arg3);
    if let Some(v20) = v19 {
        let v21 = &C::endianness(ctx, arg3);
        match v21 {
            &Endianness::Little => {
                let v22 = &constructor_addrz(ctx, arg1, arg2);
                let v23 = &constructor_emit_addrz_store_le(ctx, v22, arg0, arg4, v20);
                // Rule at src/isa/pulley_shared/lower.isle line 1315.
                return v23.clone();
            }
            &Endianness::Big => {
                let v22 = &constructor_addrz(ctx, arg1, arg2);
                let v24 = &constructor_emit_addrz_store_be(ctx, v22, arg0, arg4, v20);
                // Rule at src/isa/pulley_shared/lower.isle line 1319.
                return v24.clone();
            }
            _ => {}
        }
    }
    let v7 = C::memflags_nontrapping(ctx, arg3);
    if v7 == true {
        let v15 = C::ty_vec128(ctx, arg4);
        if let Some(v16) = v15 {
            let v8 = &constructor_amode(ctx, arg1, arg2);
            let v17 = constructor_put_in_vreg(ctx, arg0);
            let v18 = &constructor_pulley_vstore(ctx, v8, v17, v16, arg3);
            // Rule at src/isa/pulley_shared/lower.isle line 1310.
            return v18.clone();
        }
        let v11 = C::ty_scalar_float(ctx, arg4);
        if let Some(v12) = v11 {
            let v8 = &constructor_amode(ctx, arg1, arg2);
            let v13 = constructor_put_in_freg(ctx, arg0);
            let v14 = &constructor_pulley_fstore(ctx, v8, v13, v12, arg3);
            // Rule at src/isa/pulley_shared/lower.isle line 1307.
            return v14.clone();
        }
        let v5 = C::ty_int(ctx, arg4);
        if let Some(v6) = v5 {
            let v8 = &constructor_amode(ctx, arg1, arg2);
            let v9 = constructor_put_in_xreg(ctx, arg0);
            let v10 = &constructor_pulley_xstore(ctx, v8, v9, v6, arg3);
            // Rule at src/isa/pulley_shared/lower.isle line 1304.
            return v10.clone();
        }
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "gen_store", "src/isa/pulley_shared/lower.isle line 1301")
}

// Generated as internal constructor for term emit_addrz_store_le.
pub fn constructor_emit_addrz_store_le<C: Context>(
    ctx: &mut C,
    arg0: &AddrZ,
    arg1: Value,
    arg2: Type,
    arg3: &TrapCode,
) -> SideEffectNoResult {
    let v12 = C::ty_vec128(ctx, arg2);
    if let Some(v13) = v12 {
        let v14 = constructor_put_in_vreg(ctx, arg1);
        let v15 = &constructor_pulley_vstore128le_z(ctx, arg0, v14, arg3);
        // Rule at src/isa/pulley_shared/lower.isle line 1331.
        return v15.clone();
    }
    match arg2 {
        I8 => {
            let v4 = constructor_put_in_xreg(ctx, arg1);
            let v5 = &constructor_pulley_xstore8_z(ctx, arg0, v4, arg3);
            // Rule at src/isa/pulley_shared/lower.isle line 1325.
            return v5.clone();
        }
        I16 => {
            let v4 = constructor_put_in_xreg(ctx, arg1);
            let v6 = &constructor_pulley_xstore16le_z(ctx, arg0, v4, arg3);
            // Rule at src/isa/pulley_shared/lower.isle line 1326.
            return v6.clone();
        }
        I32 => {
            let v4 = constructor_put_in_xreg(ctx, arg1);
            let v7 = &constructor_pulley_xstore32le_z(ctx, arg0, v4, arg3);
            // Rule at src/isa/pulley_shared/lower.isle line 1327.
            return v7.clone();
        }
        I64 => {
            let v4 = constructor_put_in_xreg(ctx, arg1);
            let v8 = &constructor_pulley_xstore64le_z(ctx, arg0, v4, arg3);
            // Rule at src/isa/pulley_shared/lower.isle line 1328.
            return v8.clone();
        }
        F32 => {
            let v9 = constructor_put_in_freg(ctx, arg1);
            let v10 = &constructor_pulley_fstore32le_z(ctx, arg0, v9, arg3);
            // Rule at src/isa/pulley_shared/lower.isle line 1329.
            return v10.clone();
        }
        F64 => {
            let v9 = constructor_put_in_freg(ctx, arg1);
            let v11 = &constructor_pulley_fstore64le_z(ctx, arg0, v9, arg3);
            // Rule at src/isa/pulley_shared/lower.isle line 1330.
            return v11.clone();
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "emit_addrz_store_le", "src/isa/pulley_shared/lower.isle line 1324")
}

// Generated as internal constructor for term emit_addrz_store_be.
pub fn constructor_emit_addrz_store_be<C: Context>(
    ctx: &mut C,
    arg0: &AddrZ,
    arg1: Value,
    arg2: Type,
    arg3: &TrapCode,
) -> SideEffectNoResult {
    let v12 = C::ty_vec128(ctx, arg2);
    if let Some(v13) = v12 {
        let v14 = constructor_put_in_vreg(ctx, arg1);
        let v15 = &constructor_pulley_vstore128be_z(ctx, arg0, v14, arg3);
        // Rule at src/isa/pulley_shared/lower.isle line 1340.
        return v15.clone();
    }
    match arg2 {
        I8 => {
            let v4 = constructor_put_in_xreg(ctx, arg1);
            let v5 = &constructor_pulley_xstore8_z(ctx, arg0, v4, arg3);
            // Rule at src/isa/pulley_shared/lower.isle line 1334.
            return v5.clone();
        }
        I16 => {
            let v4 = constructor_put_in_xreg(ctx, arg1);
            let v6 = &constructor_pulley_xstore16be_z(ctx, arg0, v4, arg3);
            // Rule at src/isa/pulley_shared/lower.isle line 1335.
            return v6.clone();
        }
        I32 => {
            let v4 = constructor_put_in_xreg(ctx, arg1);
            let v7 = &constructor_pulley_xstore32be_z(ctx, arg0, v4, arg3);
            // Rule at src/isa/pulley_shared/lower.isle line 1336.
            return v7.clone();
        }
        I64 => {
            let v4 = constructor_put_in_xreg(ctx, arg1);
            let v8 = &constructor_pulley_xstore64be_z(ctx, arg0, v4, arg3);
            // Rule at src/isa/pulley_shared/lower.isle line 1337.
            return v8.clone();
        }
        F32 => {
            let v9 = constructor_put_in_freg(ctx, arg1);
            let v10 = &constructor_pulley_fstore32be_z(ctx, arg0, v9, arg3);
            // Rule at src/isa/pulley_shared/lower.isle line 1338.
            return v10.clone();
        }
        F64 => {
            let v9 = constructor_put_in_freg(ctx, arg1);
            let v11 = &constructor_pulley_fstore64be_z(ctx, arg0, v9, arg3);
            // Rule at src/isa/pulley_shared/lower.isle line 1339.
            return v11.clone();
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "emit_addrz_store_be", "src/isa/pulley_shared/lower.isle line 1333")
}

// Generated as internal constructor for term emit_addrg32_store.
pub fn constructor_emit_addrg32_store<C: Context>(
    ctx: &mut C,
    arg0: &AddrG32,
    arg1: Value,
    arg2: Type,
) -> SideEffectNoResult {
    let v11 = C::ty_vec128(ctx, arg2);
    if let Some(v12) = v11 {
        let v13 = constructor_put_in_vreg(ctx, arg1);
        let v14 = &constructor_pulley_vstore128le_g32(ctx, arg0, v13);
        // Rule at src/isa/pulley_shared/lower.isle line 1354.
        return v14.clone();
    }
    match arg2 {
        I8 => {
            let v3 = constructor_put_in_xreg(ctx, arg1);
            let v4 = &constructor_pulley_xstore8_g32(ctx, arg0, v3);
            // Rule at src/isa/pulley_shared/lower.isle line 1348.
            return v4.clone();
        }
        I16 => {
            let v3 = constructor_put_in_xreg(ctx, arg1);
            let v5 = &constructor_pulley_xstore16le_g32(ctx, arg0, v3);
            // Rule at src/isa/pulley_shared/lower.isle line 1349.
            return v5.clone();
        }
        I32 => {
            let v3 = constructor_put_in_xreg(ctx, arg1);
            let v6 = &constructor_pulley_xstore32le_g32(ctx, arg0, v3);
            // Rule at src/isa/pulley_shared/lower.isle line 1350.
            return v6.clone();
        }
        I64 => {
            let v3 = constructor_put_in_xreg(ctx, arg1);
            let v7 = &constructor_pulley_xstore64le_g32(ctx, arg0, v3);
            // Rule at src/isa/pulley_shared/lower.isle line 1351.
            return v7.clone();
        }
        F32 => {
            let v8 = constructor_put_in_freg(ctx, arg1);
            let v9 = &constructor_pulley_fstore32le_g32(ctx, arg0, v8);
            // Rule at src/isa/pulley_shared/lower.isle line 1352.
            return v9.clone();
        }
        F64 => {
            let v8 = constructor_put_in_freg(ctx, arg1);
            let v10 = &constructor_pulley_fstore64le_g32(ctx, arg0, v8);
            // Rule at src/isa/pulley_shared/lower.isle line 1353.
            return v10.clone();
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "emit_addrg32_store", "src/isa/pulley_shared/lower.isle line 1347")
}

// Generated as internal constructor for term lower_stack_addr.
pub fn constructor_lower_stack_addr<C: Context>(
    ctx: &mut C,
    arg0: StackSlot,
    arg1: Offset32,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = C::writable_xreg_to_writable_reg(ctx, v2);
    let v4 = &C::abi_stackslot_addr(ctx, v3, arg0, arg1);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at src/isa/pulley_shared/lower.isle line 1362.
    return v6;
}

// Generated as internal constructor for term emit_cond.
pub fn constructor_emit_cond<C: Context>(
    ctx: &mut C,
    arg0: &Cond,
) -> XReg {
    match arg0 {
        &Cond::If32 {
            reg: v1,
        } => {
            // Rule at src/isa/pulley_shared/lower.isle line 1448.
            return v1;
        }
        &Cond::IfNot32 {
            reg: v2,
        } => {
            let v4 = constructor_pulley_xconst8(ctx, 0_i8);
            let v5 = constructor_pulley_xeq32(ctx, v2, v4);
            // Rule at src/isa/pulley_shared/lower.isle line 1449.
            return v5;
        }
        &Cond::IfXeq32 {
            src1: v6,
            src2: v7,
        } => {
            let v8 = constructor_pulley_xeq32(ctx, v6, v7);
            // Rule at src/isa/pulley_shared/lower.isle line 1450.
            return v8;
        }
        &Cond::IfXneq32 {
            src1: v9,
            src2: v10,
        } => {
            let v11 = constructor_pulley_xneq32(ctx, v9, v10);
            // Rule at src/isa/pulley_shared/lower.isle line 1451.
            return v11;
        }
        &Cond::IfXslt32 {
            src1: v12,
            src2: v13,
        } => {
            let v14 = constructor_pulley_xslt32(ctx, v12, v13);
            // Rule at src/isa/pulley_shared/lower.isle line 1452.
            return v14;
        }
        &Cond::IfXslteq32 {
            src1: v15,
            src2: v16,
        } => {
            let v17 = constructor_pulley_xslteq32(ctx, v15, v16);
            // Rule at src/isa/pulley_shared/lower.isle line 1453.
            return v17;
        }
        &Cond::IfXult32 {
            src1: v18,
            src2: v19,
        } => {
            let v20 = constructor_pulley_xult32(ctx, v18, v19);
            // Rule at src/isa/pulley_shared/lower.isle line 1454.
            return v20;
        }
        &Cond::IfXulteq32 {
            src1: v21,
            src2: v22,
        } => {
            let v23 = constructor_pulley_xulteq32(ctx, v21, v22);
            // Rule at src/isa/pulley_shared/lower.isle line 1455.
            return v23;
        }
        &Cond::IfXeq32I32 {
            src1: v42,
            src2: v43,
        } => {
            let v44 = C::i32_into_i64(ctx, v43);
            let v45 = constructor_imm(ctx, v44);
            let v46 = C::xreg_new(ctx, v45);
            let v47 = constructor_pulley_xeq32(ctx, v42, v46);
            // Rule at src/isa/pulley_shared/lower.isle line 1463.
            return v47;
        }
        &Cond::IfXneq32I32 {
            src1: v48,
            src2: v49,
        } => {
            let v50 = C::i32_into_i64(ctx, v49);
            let v51 = constructor_imm(ctx, v50);
            let v52 = C::xreg_new(ctx, v51);
            let v53 = constructor_pulley_xneq32(ctx, v48, v52);
            // Rule at src/isa/pulley_shared/lower.isle line 1464.
            return v53;
        }
        &Cond::IfXslt32I32 {
            src1: v54,
            src2: v55,
        } => {
            let v56 = C::i32_into_i64(ctx, v55);
            let v57 = constructor_imm(ctx, v56);
            let v58 = C::xreg_new(ctx, v57);
            let v59 = constructor_pulley_xslt32(ctx, v54, v58);
            // Rule at src/isa/pulley_shared/lower.isle line 1465.
            return v59;
        }
        &Cond::IfXslteq32I32 {
            src1: v60,
            src2: v61,
        } => {
            let v62 = C::i32_into_i64(ctx, v61);
            let v63 = constructor_imm(ctx, v62);
            let v64 = C::xreg_new(ctx, v63);
            let v65 = constructor_pulley_xslteq32(ctx, v60, v64);
            // Rule at src/isa/pulley_shared/lower.isle line 1466.
            return v65;
        }
        &Cond::IfXult32I32 {
            src1: v66,
            src2: v67,
        } => {
            let v68 = C::u32_into_i64(ctx, v67);
            let v69 = constructor_imm(ctx, v68);
            let v70 = C::xreg_new(ctx, v69);
            let v71 = constructor_pulley_xult32(ctx, v66, v70);
            // Rule at src/isa/pulley_shared/lower.isle line 1467.
            return v71;
        }
        &Cond::IfXulteq32I32 {
            src1: v72,
            src2: v73,
        } => {
            let v74 = C::u32_into_i64(ctx, v73);
            let v75 = constructor_imm(ctx, v74);
            let v76 = C::xreg_new(ctx, v75);
            let v77 = constructor_pulley_xulteq32(ctx, v72, v76);
            // Rule at src/isa/pulley_shared/lower.isle line 1468.
            return v77;
        }
        &Cond::IfXsgt32I32 {
            src1: v78,
            src2: v79,
        } => {
            let v80 = C::i32_into_i64(ctx, v79);
            let v81 = constructor_imm(ctx, v80);
            let v82 = C::xreg_new(ctx, v81);
            let v83 = constructor_pulley_xslt32(ctx, v82, v78);
            // Rule at src/isa/pulley_shared/lower.isle line 1471.
            return v83;
        }
        &Cond::IfXsgteq32I32 {
            src1: v84,
            src2: v85,
        } => {
            let v86 = C::i32_into_i64(ctx, v85);
            let v87 = constructor_imm(ctx, v86);
            let v88 = C::xreg_new(ctx, v87);
            let v89 = constructor_pulley_xslteq32(ctx, v88, v84);
            // Rule at src/isa/pulley_shared/lower.isle line 1472.
            return v89;
        }
        &Cond::IfXugt32I32 {
            src1: v90,
            src2: v91,
        } => {
            let v92 = C::u32_into_i64(ctx, v91);
            let v93 = constructor_imm(ctx, v92);
            let v94 = C::xreg_new(ctx, v93);
            let v95 = constructor_pulley_xult32(ctx, v94, v90);
            // Rule at src/isa/pulley_shared/lower.isle line 1473.
            return v95;
        }
        &Cond::IfXugteq32I32 {
            src1: v96,
            src2: v97,
        } => {
            let v98 = C::u32_into_i64(ctx, v97);
            let v99 = constructor_imm(ctx, v98);
            let v100 = C::xreg_new(ctx, v99);
            let v101 = constructor_pulley_xulteq32(ctx, v100, v96);
            // Rule at src/isa/pulley_shared/lower.isle line 1474.
            return v101;
        }
        &Cond::IfXeq64 {
            src1: v24,
            src2: v25,
        } => {
            let v26 = constructor_pulley_xeq64(ctx, v24, v25);
            // Rule at src/isa/pulley_shared/lower.isle line 1456.
            return v26;
        }
        &Cond::IfXneq64 {
            src1: v27,
            src2: v28,
        } => {
            let v29 = constructor_pulley_xneq64(ctx, v27, v28);
            // Rule at src/isa/pulley_shared/lower.isle line 1457.
            return v29;
        }
        &Cond::IfXslt64 {
            src1: v30,
            src2: v31,
        } => {
            let v32 = constructor_pulley_xslt64(ctx, v30, v31);
            // Rule at src/isa/pulley_shared/lower.isle line 1458.
            return v32;
        }
        &Cond::IfXslteq64 {
            src1: v33,
            src2: v34,
        } => {
            let v35 = constructor_pulley_xslteq64(ctx, v33, v34);
            // Rule at src/isa/pulley_shared/lower.isle line 1459.
            return v35;
        }
        &Cond::IfXult64 {
            src1: v36,
            src2: v37,
        } => {
            let v38 = constructor_pulley_xult64(ctx, v36, v37);
            // Rule at src/isa/pulley_shared/lower.isle line 1460.
            return v38;
        }
        &Cond::IfXulteq64 {
            src1: v39,
            src2: v40,
        } => {
            let v41 = constructor_pulley_xulteq64(ctx, v39, v40);
            // Rule at src/isa/pulley_shared/lower.isle line 1461.
            return v41;
        }
        &Cond::IfXeq64I32 {
            src1: v102,
            src2: v103,
        } => {
            let v104 = C::i32_into_i64(ctx, v103);
            let v105 = constructor_imm(ctx, v104);
            let v106 = C::xreg_new(ctx, v105);
            let v107 = constructor_pulley_xeq64(ctx, v102, v106);
            // Rule at src/isa/pulley_shared/lower.isle line 1476.
            return v107;
        }
        &Cond::IfXneq64I32 {
            src1: v108,
            src2: v109,
        } => {
            let v110 = C::i32_into_i64(ctx, v109);
            let v111 = constructor_imm(ctx, v110);
            let v112 = C::xreg_new(ctx, v111);
            let v113 = constructor_pulley_xneq64(ctx, v108, v112);
            // Rule at src/isa/pulley_shared/lower.isle line 1477.
            return v113;
        }
        &Cond::IfXslt64I32 {
            src1: v114,
            src2: v115,
        } => {
            let v116 = C::i32_into_i64(ctx, v115);
            let v117 = constructor_imm(ctx, v116);
            let v118 = C::xreg_new(ctx, v117);
            let v119 = constructor_pulley_xslt64(ctx, v114, v118);
            // Rule at src/isa/pulley_shared/lower.isle line 1478.
            return v119;
        }
        &Cond::IfXslteq64I32 {
            src1: v120,
            src2: v121,
        } => {
            let v122 = C::i32_into_i64(ctx, v121);
            let v123 = constructor_imm(ctx, v122);
            let v124 = C::xreg_new(ctx, v123);
            let v125 = constructor_pulley_xslteq64(ctx, v120, v124);
            // Rule at src/isa/pulley_shared/lower.isle line 1479.
            return v125;
        }
        &Cond::IfXult64I32 {
            src1: v126,
            src2: v127,
        } => {
            let v128 = C::u32_into_i64(ctx, v127);
            let v129 = constructor_imm(ctx, v128);
            let v130 = C::xreg_new(ctx, v129);
            let v131 = constructor_pulley_xult64(ctx, v126, v130);
            // Rule at src/isa/pulley_shared/lower.isle line 1480.
            return v131;
        }
        &Cond::IfXulteq64I32 {
            src1: v132,
            src2: v133,
        } => {
            let v134 = C::u32_into_i64(ctx, v133);
            let v135 = constructor_imm(ctx, v134);
            let v136 = C::xreg_new(ctx, v135);
            let v137 = constructor_pulley_xulteq64(ctx, v132, v136);
            // Rule at src/isa/pulley_shared/lower.isle line 1481.
            return v137;
        }
        &Cond::IfXsgt64I32 {
            src1: v138,
            src2: v139,
        } => {
            let v140 = C::i32_into_i64(ctx, v139);
            let v141 = constructor_imm(ctx, v140);
            let v142 = C::xreg_new(ctx, v141);
            let v143 = constructor_pulley_xslt64(ctx, v142, v138);
            // Rule at src/isa/pulley_shared/lower.isle line 1484.
            return v143;
        }
        &Cond::IfXsgteq64I32 {
            src1: v144,
            src2: v145,
        } => {
            let v146 = C::i32_into_i64(ctx, v145);
            let v147 = constructor_imm(ctx, v146);
            let v148 = C::xreg_new(ctx, v147);
            let v149 = constructor_pulley_xslteq64(ctx, v148, v144);
            // Rule at src/isa/pulley_shared/lower.isle line 1485.
            return v149;
        }
        &Cond::IfXugt64I32 {
            src1: v150,
            src2: v151,
        } => {
            let v152 = C::u32_into_i64(ctx, v151);
            let v153 = constructor_imm(ctx, v152);
            let v154 = C::xreg_new(ctx, v153);
            let v155 = constructor_pulley_xult64(ctx, v154, v150);
            // Rule at src/isa/pulley_shared/lower.isle line 1486.
            return v155;
        }
        &Cond::IfXugteq64I32 {
            src1: v156,
            src2: v157,
        } => {
            let v158 = C::u32_into_i64(ctx, v157);
            let v159 = constructor_imm(ctx, v158);
            let v160 = C::xreg_new(ctx, v159);
            let v161 = constructor_pulley_xulteq64(ctx, v160, v156);
            // Rule at src/isa/pulley_shared/lower.isle line 1487.
            return v161;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "emit_cond", "src/isa/pulley_shared/lower.isle line 1447")
}

// Generated as internal constructor for term pulley_nop.
pub fn constructor_pulley_nop<C: Context>(
    ctx: &mut C,
) -> SideEffectNoResult {
    let v1 = &constructor_raw_inst_to_inst(ctx, &RawInst::Nop);
    let v2 = SideEffectNoResult::Inst {
        inst: v1.clone(),
    };
    // Rule at <OUT_DIR>/pulley_gen.isle line 1726.
    return v2;
}

// Generated as internal constructor for term pulley_ret.
pub fn constructor_pulley_ret<C: Context>(
    ctx: &mut C,
) -> SideEffectNoResult {
    let v1 = &constructor_raw_inst_to_inst(ctx, &RawInst::Ret);
    let v2 = SideEffectNoResult::Inst {
        inst: v1.clone(),
    };
    // Rule at <OUT_DIR>/pulley_gen.isle line 1728.
    return v2;
}

// Generated as internal constructor for term pulley_xjump.
pub fn constructor_pulley_xjump<C: Context>(
    ctx: &mut C,
    arg0: XReg,
) -> SideEffectNoResult {
    let v1 = RawInst::XJump {
        reg: arg0,
    };
    let v2 = &constructor_raw_inst_to_inst(ctx, &v1);
    let v3 = SideEffectNoResult::Inst {
        inst: v2.clone(),
    };
    // Rule at <OUT_DIR>/pulley_gen.isle line 1730.
    return v3;
}

// Generated as internal constructor for term pulley_xmov.
pub fn constructor_pulley_xmov<C: Context>(
    ctx: &mut C,
    arg0: XReg,
) -> XReg {
    let v1 = constructor_temp_writable_xreg(ctx);
    let v2 = RawInst::Xmov {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_xreg_to_xreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 1732.
    return v5;
}

// Generated as internal constructor for term pulley_xzero.
pub fn constructor_pulley_xzero<C: Context>(
    ctx: &mut C,
) -> XReg {
    let v0 = constructor_temp_writable_xreg(ctx);
    let v1 = RawInst::Xzero {
        dst: v0,
    };
    let v2 = &constructor_raw_inst_to_inst(ctx, &v1);
    let v3 = C::emit(ctx, v2);
    let v4 = C::writable_xreg_to_xreg(ctx, v0);
    // Rule at <OUT_DIR>/pulley_gen.isle line 1739.
    return v4;
}

// Generated as internal constructor for term pulley_xone.
pub fn constructor_pulley_xone<C: Context>(
    ctx: &mut C,
) -> XReg {
    let v0 = constructor_temp_writable_xreg(ctx);
    let v1 = RawInst::Xone {
        dst: v0,
    };
    let v2 = &constructor_raw_inst_to_inst(ctx, &v1);
    let v3 = C::emit(ctx, v2);
    let v4 = C::writable_xreg_to_xreg(ctx, v0);
    // Rule at <OUT_DIR>/pulley_gen.isle line 1746.
    return v4;
}

// Generated as internal constructor for term pulley_xconst8.
pub fn constructor_pulley_xconst8<C: Context>(
    ctx: &mut C,
    arg0: i8,
) -> XReg {
    let v1 = constructor_temp_writable_xreg(ctx);
    let v2 = RawInst::Xconst8 {
        dst: v1,
        imm: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_xreg_to_xreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 1753.
    return v5;
}

// Generated as internal constructor for term pulley_xconst16.
pub fn constructor_pulley_xconst16<C: Context>(
    ctx: &mut C,
    arg0: i16,
) -> XReg {
    let v1 = constructor_temp_writable_xreg(ctx);
    let v2 = RawInst::Xconst16 {
        dst: v1,
        imm: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_xreg_to_xreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 1760.
    return v5;
}

// Generated as internal constructor for term pulley_xconst32.
pub fn constructor_pulley_xconst32<C: Context>(
    ctx: &mut C,
    arg0: i32,
) -> XReg {
    let v1 = constructor_temp_writable_xreg(ctx);
    let v2 = RawInst::Xconst32 {
        dst: v1,
        imm: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_xreg_to_xreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 1767.
    return v5;
}

// Generated as internal constructor for term pulley_xconst64.
pub fn constructor_pulley_xconst64<C: Context>(
    ctx: &mut C,
    arg0: i64,
) -> XReg {
    let v1 = constructor_temp_writable_xreg(ctx);
    let v2 = RawInst::Xconst64 {
        dst: v1,
        imm: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_xreg_to_xreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 1774.
    return v5;
}

// Generated as internal constructor for term pulley_xadd32.
pub fn constructor_pulley_xadd32<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: XReg,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::Xadd32 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 1781.
    return v6;
}

// Generated as internal constructor for term pulley_xadd32_u8.
pub fn constructor_pulley_xadd32_u8<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: u8,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::Xadd32U8 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 1788.
    return v6;
}

// Generated as internal constructor for term pulley_xadd32_u32.
pub fn constructor_pulley_xadd32_u32<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: u32,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::Xadd32U32 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 1795.
    return v6;
}

// Generated as internal constructor for term pulley_xadd64.
pub fn constructor_pulley_xadd64<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: XReg,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::Xadd64 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 1802.
    return v6;
}

// Generated as internal constructor for term pulley_xadd64_u8.
pub fn constructor_pulley_xadd64_u8<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: u8,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::Xadd64U8 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 1809.
    return v6;
}

// Generated as internal constructor for term pulley_xadd64_u32.
pub fn constructor_pulley_xadd64_u32<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: u32,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::Xadd64U32 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 1816.
    return v6;
}

// Generated as internal constructor for term pulley_xmadd32.
pub fn constructor_pulley_xmadd32<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: XReg,
    arg2: XReg,
) -> XReg {
    let v3 = constructor_temp_writable_xreg(ctx);
    let v4 = RawInst::Xmadd32 {
        dst: v3,
        src1: arg0,
        src2: arg1,
        src3: arg2,
    };
    let v5 = &constructor_raw_inst_to_inst(ctx, &v4);
    let v6 = C::emit(ctx, v5);
    let v7 = C::writable_xreg_to_xreg(ctx, v3);
    // Rule at <OUT_DIR>/pulley_gen.isle line 1823.
    return v7;
}

// Generated as internal constructor for term pulley_xmadd64.
pub fn constructor_pulley_xmadd64<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: XReg,
    arg2: XReg,
) -> XReg {
    let v3 = constructor_temp_writable_xreg(ctx);
    let v4 = RawInst::Xmadd64 {
        dst: v3,
        src1: arg0,
        src2: arg1,
        src3: arg2,
    };
    let v5 = &constructor_raw_inst_to_inst(ctx, &v4);
    let v6 = C::emit(ctx, v5);
    let v7 = C::writable_xreg_to_xreg(ctx, v3);
    // Rule at <OUT_DIR>/pulley_gen.isle line 1830.
    return v7;
}

// Generated as internal constructor for term pulley_xsub32.
pub fn constructor_pulley_xsub32<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: XReg,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::Xsub32 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 1837.
    return v6;
}

// Generated as internal constructor for term pulley_xsub32_u8.
pub fn constructor_pulley_xsub32_u8<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: u8,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::Xsub32U8 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 1844.
    return v6;
}

// Generated as internal constructor for term pulley_xsub32_u32.
pub fn constructor_pulley_xsub32_u32<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: u32,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::Xsub32U32 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 1851.
    return v6;
}

// Generated as internal constructor for term pulley_xsub64.
pub fn constructor_pulley_xsub64<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: XReg,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::Xsub64 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 1858.
    return v6;
}

// Generated as internal constructor for term pulley_xsub64_u8.
pub fn constructor_pulley_xsub64_u8<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: u8,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::Xsub64U8 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 1865.
    return v6;
}

// Generated as internal constructor for term pulley_xsub64_u32.
pub fn constructor_pulley_xsub64_u32<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: u32,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::Xsub64U32 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 1872.
    return v6;
}

// Generated as internal constructor for term pulley_xmul32.
pub fn constructor_pulley_xmul32<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: XReg,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::XMul32 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 1879.
    return v6;
}

// Generated as internal constructor for term pulley_xmul32_s8.
pub fn constructor_pulley_xmul32_s8<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: i8,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::Xmul32S8 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 1886.
    return v6;
}

// Generated as internal constructor for term pulley_xmul32_s32.
pub fn constructor_pulley_xmul32_s32<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: i32,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::Xmul32S32 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 1893.
    return v6;
}

// Generated as internal constructor for term pulley_xmul64.
pub fn constructor_pulley_xmul64<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: XReg,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::XMul64 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 1900.
    return v6;
}

// Generated as internal constructor for term pulley_xmul64_s8.
pub fn constructor_pulley_xmul64_s8<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: i8,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::Xmul64S8 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 1907.
    return v6;
}

// Generated as internal constructor for term pulley_xmul64_s32.
pub fn constructor_pulley_xmul64_s32<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: i32,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::Xmul64S32 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 1914.
    return v6;
}

// Generated as internal constructor for term pulley_xctz32.
pub fn constructor_pulley_xctz32<C: Context>(
    ctx: &mut C,
    arg0: XReg,
) -> XReg {
    let v1 = constructor_temp_writable_xreg(ctx);
    let v2 = RawInst::Xctz32 {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_xreg_to_xreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 1921.
    return v5;
}

// Generated as internal constructor for term pulley_xctz64.
pub fn constructor_pulley_xctz64<C: Context>(
    ctx: &mut C,
    arg0: XReg,
) -> XReg {
    let v1 = constructor_temp_writable_xreg(ctx);
    let v2 = RawInst::Xctz64 {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_xreg_to_xreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 1928.
    return v5;
}

// Generated as internal constructor for term pulley_xclz32.
pub fn constructor_pulley_xclz32<C: Context>(
    ctx: &mut C,
    arg0: XReg,
) -> XReg {
    let v1 = constructor_temp_writable_xreg(ctx);
    let v2 = RawInst::Xclz32 {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_xreg_to_xreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 1935.
    return v5;
}

// Generated as internal constructor for term pulley_xclz64.
pub fn constructor_pulley_xclz64<C: Context>(
    ctx: &mut C,
    arg0: XReg,
) -> XReg {
    let v1 = constructor_temp_writable_xreg(ctx);
    let v2 = RawInst::Xclz64 {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_xreg_to_xreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 1942.
    return v5;
}

// Generated as internal constructor for term pulley_xpopcnt32.
pub fn constructor_pulley_xpopcnt32<C: Context>(
    ctx: &mut C,
    arg0: XReg,
) -> XReg {
    let v1 = constructor_temp_writable_xreg(ctx);
    let v2 = RawInst::Xpopcnt32 {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_xreg_to_xreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 1949.
    return v5;
}

// Generated as internal constructor for term pulley_xpopcnt64.
pub fn constructor_pulley_xpopcnt64<C: Context>(
    ctx: &mut C,
    arg0: XReg,
) -> XReg {
    let v1 = constructor_temp_writable_xreg(ctx);
    let v2 = RawInst::Xpopcnt64 {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_xreg_to_xreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 1956.
    return v5;
}

// Generated as internal constructor for term pulley_xrotl32.
pub fn constructor_pulley_xrotl32<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: XReg,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::Xrotl32 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 1963.
    return v6;
}

// Generated as internal constructor for term pulley_xrotl64.
pub fn constructor_pulley_xrotl64<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: XReg,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::Xrotl64 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 1970.
    return v6;
}

// Generated as internal constructor for term pulley_xrotr32.
pub fn constructor_pulley_xrotr32<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: XReg,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::Xrotr32 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 1977.
    return v6;
}

// Generated as internal constructor for term pulley_xrotr64.
pub fn constructor_pulley_xrotr64<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: XReg,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::Xrotr64 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 1984.
    return v6;
}

// Generated as internal constructor for term pulley_xshl32.
pub fn constructor_pulley_xshl32<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: XReg,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::Xshl32 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 1991.
    return v6;
}

// Generated as internal constructor for term pulley_xshr32_s.
pub fn constructor_pulley_xshr32_s<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: XReg,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::Xshr32S {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 1998.
    return v6;
}

// Generated as internal constructor for term pulley_xshr32_u.
pub fn constructor_pulley_xshr32_u<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: XReg,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::Xshr32U {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2005.
    return v6;
}

// Generated as internal constructor for term pulley_xshl64.
pub fn constructor_pulley_xshl64<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: XReg,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::Xshl64 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2012.
    return v6;
}

// Generated as internal constructor for term pulley_xshr64_s.
pub fn constructor_pulley_xshr64_s<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: XReg,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::Xshr64S {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2019.
    return v6;
}

// Generated as internal constructor for term pulley_xshr64_u.
pub fn constructor_pulley_xshr64_u<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: XReg,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::Xshr64U {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2026.
    return v6;
}

// Generated as internal constructor for term pulley_xshl32_u6.
pub fn constructor_pulley_xshl32_u6<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: U6,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::Xshl32U6 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2033.
    return v6;
}

// Generated as internal constructor for term pulley_xshr32_s_u6.
pub fn constructor_pulley_xshr32_s_u6<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: U6,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::Xshr32SU6 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2040.
    return v6;
}

// Generated as internal constructor for term pulley_xshr32_u_u6.
pub fn constructor_pulley_xshr32_u_u6<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: U6,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::Xshr32UU6 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2047.
    return v6;
}

// Generated as internal constructor for term pulley_xshl64_u6.
pub fn constructor_pulley_xshl64_u6<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: U6,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::Xshl64U6 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2054.
    return v6;
}

// Generated as internal constructor for term pulley_xshr64_s_u6.
pub fn constructor_pulley_xshr64_s_u6<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: U6,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::Xshr64SU6 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2061.
    return v6;
}

// Generated as internal constructor for term pulley_xshr64_u_u6.
pub fn constructor_pulley_xshr64_u_u6<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: U6,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::Xshr64UU6 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2068.
    return v6;
}

// Generated as internal constructor for term pulley_xneg32.
pub fn constructor_pulley_xneg32<C: Context>(
    ctx: &mut C,
    arg0: XReg,
) -> XReg {
    let v1 = constructor_temp_writable_xreg(ctx);
    let v2 = RawInst::Xneg32 {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_xreg_to_xreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2075.
    return v5;
}

// Generated as internal constructor for term pulley_xneg64.
pub fn constructor_pulley_xneg64<C: Context>(
    ctx: &mut C,
    arg0: XReg,
) -> XReg {
    let v1 = constructor_temp_writable_xreg(ctx);
    let v2 = RawInst::Xneg64 {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_xreg_to_xreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2082.
    return v5;
}

// Generated as internal constructor for term pulley_xeq64.
pub fn constructor_pulley_xeq64<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: XReg,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::Xeq64 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2089.
    return v6;
}

// Generated as internal constructor for term pulley_xneq64.
pub fn constructor_pulley_xneq64<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: XReg,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::Xneq64 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2096.
    return v6;
}

// Generated as internal constructor for term pulley_xslt64.
pub fn constructor_pulley_xslt64<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: XReg,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::Xslt64 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2103.
    return v6;
}

// Generated as internal constructor for term pulley_xslteq64.
pub fn constructor_pulley_xslteq64<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: XReg,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::Xslteq64 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2110.
    return v6;
}

// Generated as internal constructor for term pulley_xult64.
pub fn constructor_pulley_xult64<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: XReg,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::Xult64 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2117.
    return v6;
}

// Generated as internal constructor for term pulley_xulteq64.
pub fn constructor_pulley_xulteq64<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: XReg,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::Xulteq64 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2124.
    return v6;
}

// Generated as internal constructor for term pulley_xeq32.
pub fn constructor_pulley_xeq32<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: XReg,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::Xeq32 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2131.
    return v6;
}

// Generated as internal constructor for term pulley_xneq32.
pub fn constructor_pulley_xneq32<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: XReg,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::Xneq32 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2138.
    return v6;
}

// Generated as internal constructor for term pulley_xslt32.
pub fn constructor_pulley_xslt32<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: XReg,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::Xslt32 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2145.
    return v6;
}

// Generated as internal constructor for term pulley_xslteq32.
pub fn constructor_pulley_xslteq32<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: XReg,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::Xslteq32 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2152.
    return v6;
}

// Generated as internal constructor for term pulley_xult32.
pub fn constructor_pulley_xult32<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: XReg,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::Xult32 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2159.
    return v6;
}

// Generated as internal constructor for term pulley_xulteq32.
pub fn constructor_pulley_xulteq32<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: XReg,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::Xulteq32 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2166.
    return v6;
}

// Generated as internal constructor for term pulley_xload8_u32_o32.
pub fn constructor_pulley_xload8_u32_o32<C: Context>(
    ctx: &mut C,
    arg0: &AddrO32,
) -> XReg {
    let v1 = constructor_temp_writable_xreg(ctx);
    let v2 = RawInst::XLoad8U32O32 {
        dst: v1,
        addr: arg0.clone(),
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_xreg_to_xreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2173.
    return v5;
}

// Generated as internal constructor for term pulley_xload8_s32_o32.
pub fn constructor_pulley_xload8_s32_o32<C: Context>(
    ctx: &mut C,
    arg0: &AddrO32,
) -> XReg {
    let v1 = constructor_temp_writable_xreg(ctx);
    let v2 = RawInst::XLoad8S32O32 {
        dst: v1,
        addr: arg0.clone(),
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_xreg_to_xreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2180.
    return v5;
}

// Generated as internal constructor for term pulley_xload16le_u32_o32.
pub fn constructor_pulley_xload16le_u32_o32<C: Context>(
    ctx: &mut C,
    arg0: &AddrO32,
) -> XReg {
    let v1 = constructor_temp_writable_xreg(ctx);
    let v2 = RawInst::XLoad16LeU32O32 {
        dst: v1,
        addr: arg0.clone(),
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_xreg_to_xreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2187.
    return v5;
}

// Generated as internal constructor for term pulley_xload16le_s32_o32.
pub fn constructor_pulley_xload16le_s32_o32<C: Context>(
    ctx: &mut C,
    arg0: &AddrO32,
) -> XReg {
    let v1 = constructor_temp_writable_xreg(ctx);
    let v2 = RawInst::XLoad16LeS32O32 {
        dst: v1,
        addr: arg0.clone(),
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_xreg_to_xreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2194.
    return v5;
}

// Generated as internal constructor for term pulley_xload32le_o32.
pub fn constructor_pulley_xload32le_o32<C: Context>(
    ctx: &mut C,
    arg0: &AddrO32,
) -> XReg {
    let v1 = constructor_temp_writable_xreg(ctx);
    let v2 = RawInst::XLoad32LeO32 {
        dst: v1,
        addr: arg0.clone(),
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_xreg_to_xreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2201.
    return v5;
}

// Generated as internal constructor for term pulley_xload64le_o32.
pub fn constructor_pulley_xload64le_o32<C: Context>(
    ctx: &mut C,
    arg0: &AddrO32,
) -> XReg {
    let v1 = constructor_temp_writable_xreg(ctx);
    let v2 = RawInst::XLoad64LeO32 {
        dst: v1,
        addr: arg0.clone(),
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_xreg_to_xreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2208.
    return v5;
}

// Generated as internal constructor for term pulley_xstore8_o32.
pub fn constructor_pulley_xstore8_o32<C: Context>(
    ctx: &mut C,
    arg0: &AddrO32,
    arg1: XReg,
) -> SideEffectNoResult {
    let v2 = RawInst::XStore8O32 {
        addr: arg0.clone(),
        src: arg1,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = SideEffectNoResult::Inst {
        inst: v3.clone(),
    };
    // Rule at <OUT_DIR>/pulley_gen.isle line 2215.
    return v4;
}

// Generated as internal constructor for term pulley_xstore16le_o32.
pub fn constructor_pulley_xstore16le_o32<C: Context>(
    ctx: &mut C,
    arg0: &AddrO32,
    arg1: XReg,
) -> SideEffectNoResult {
    let v2 = RawInst::XStore16LeO32 {
        addr: arg0.clone(),
        src: arg1,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = SideEffectNoResult::Inst {
        inst: v3.clone(),
    };
    // Rule at <OUT_DIR>/pulley_gen.isle line 2217.
    return v4;
}

// Generated as internal constructor for term pulley_xstore32le_o32.
pub fn constructor_pulley_xstore32le_o32<C: Context>(
    ctx: &mut C,
    arg0: &AddrO32,
    arg1: XReg,
) -> SideEffectNoResult {
    let v2 = RawInst::XStore32LeO32 {
        addr: arg0.clone(),
        src: arg1,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = SideEffectNoResult::Inst {
        inst: v3.clone(),
    };
    // Rule at <OUT_DIR>/pulley_gen.isle line 2219.
    return v4;
}

// Generated as internal constructor for term pulley_xstore64le_o32.
pub fn constructor_pulley_xstore64le_o32<C: Context>(
    ctx: &mut C,
    arg0: &AddrO32,
    arg1: XReg,
) -> SideEffectNoResult {
    let v2 = RawInst::XStore64LeO32 {
        addr: arg0.clone(),
        src: arg1,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = SideEffectNoResult::Inst {
        inst: v3.clone(),
    };
    // Rule at <OUT_DIR>/pulley_gen.isle line 2221.
    return v4;
}

// Generated as internal constructor for term pulley_xload8_u32_z.
pub fn constructor_pulley_xload8_u32_z<C: Context>(
    ctx: &mut C,
    arg0: &AddrZ,
    arg1: &TrapCode,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::XLoad8U32Z {
        dst: v2,
        addr: arg0.clone(),
        code: arg1.clone(),
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2223.
    return v6;
}

// Generated as internal constructor for term pulley_xload8_s32_z.
pub fn constructor_pulley_xload8_s32_z<C: Context>(
    ctx: &mut C,
    arg0: &AddrZ,
    arg1: &TrapCode,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::XLoad8S32Z {
        dst: v2,
        addr: arg0.clone(),
        code: arg1.clone(),
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2230.
    return v6;
}

// Generated as internal constructor for term pulley_xload16le_u32_z.
pub fn constructor_pulley_xload16le_u32_z<C: Context>(
    ctx: &mut C,
    arg0: &AddrZ,
    arg1: &TrapCode,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::XLoad16LeU32Z {
        dst: v2,
        addr: arg0.clone(),
        code: arg1.clone(),
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2237.
    return v6;
}

// Generated as internal constructor for term pulley_xload16le_s32_z.
pub fn constructor_pulley_xload16le_s32_z<C: Context>(
    ctx: &mut C,
    arg0: &AddrZ,
    arg1: &TrapCode,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::XLoad16LeS32Z {
        dst: v2,
        addr: arg0.clone(),
        code: arg1.clone(),
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2244.
    return v6;
}

// Generated as internal constructor for term pulley_xload32le_z.
pub fn constructor_pulley_xload32le_z<C: Context>(
    ctx: &mut C,
    arg0: &AddrZ,
    arg1: &TrapCode,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::XLoad32LeZ {
        dst: v2,
        addr: arg0.clone(),
        code: arg1.clone(),
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2251.
    return v6;
}

// Generated as internal constructor for term pulley_xload64le_z.
pub fn constructor_pulley_xload64le_z<C: Context>(
    ctx: &mut C,
    arg0: &AddrZ,
    arg1: &TrapCode,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::XLoad64LeZ {
        dst: v2,
        addr: arg0.clone(),
        code: arg1.clone(),
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2258.
    return v6;
}

// Generated as internal constructor for term pulley_xstore8_z.
pub fn constructor_pulley_xstore8_z<C: Context>(
    ctx: &mut C,
    arg0: &AddrZ,
    arg1: XReg,
    arg2: &TrapCode,
) -> SideEffectNoResult {
    let v3 = RawInst::XStore8Z {
        addr: arg0.clone(),
        src: arg1,
        code: arg2.clone(),
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = SideEffectNoResult::Inst {
        inst: v4.clone(),
    };
    // Rule at <OUT_DIR>/pulley_gen.isle line 2265.
    return v5;
}

// Generated as internal constructor for term pulley_xstore16le_z.
pub fn constructor_pulley_xstore16le_z<C: Context>(
    ctx: &mut C,
    arg0: &AddrZ,
    arg1: XReg,
    arg2: &TrapCode,
) -> SideEffectNoResult {
    let v3 = RawInst::XStore16LeZ {
        addr: arg0.clone(),
        src: arg1,
        code: arg2.clone(),
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = SideEffectNoResult::Inst {
        inst: v4.clone(),
    };
    // Rule at <OUT_DIR>/pulley_gen.isle line 2267.
    return v5;
}

// Generated as internal constructor for term pulley_xstore32le_z.
pub fn constructor_pulley_xstore32le_z<C: Context>(
    ctx: &mut C,
    arg0: &AddrZ,
    arg1: XReg,
    arg2: &TrapCode,
) -> SideEffectNoResult {
    let v3 = RawInst::XStore32LeZ {
        addr: arg0.clone(),
        src: arg1,
        code: arg2.clone(),
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = SideEffectNoResult::Inst {
        inst: v4.clone(),
    };
    // Rule at <OUT_DIR>/pulley_gen.isle line 2269.
    return v5;
}

// Generated as internal constructor for term pulley_xstore64le_z.
pub fn constructor_pulley_xstore64le_z<C: Context>(
    ctx: &mut C,
    arg0: &AddrZ,
    arg1: XReg,
    arg2: &TrapCode,
) -> SideEffectNoResult {
    let v3 = RawInst::XStore64LeZ {
        addr: arg0.clone(),
        src: arg1,
        code: arg2.clone(),
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = SideEffectNoResult::Inst {
        inst: v4.clone(),
    };
    // Rule at <OUT_DIR>/pulley_gen.isle line 2271.
    return v5;
}

// Generated as internal constructor for term pulley_xload8_u32_g32.
pub fn constructor_pulley_xload8_u32_g32<C: Context>(
    ctx: &mut C,
    arg0: &AddrG32,
) -> XReg {
    let v1 = constructor_temp_writable_xreg(ctx);
    let v2 = RawInst::XLoad8U32G32 {
        dst: v1,
        addr: arg0.clone(),
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_xreg_to_xreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2273.
    return v5;
}

// Generated as internal constructor for term pulley_xload8_s32_g32.
pub fn constructor_pulley_xload8_s32_g32<C: Context>(
    ctx: &mut C,
    arg0: &AddrG32,
) -> XReg {
    let v1 = constructor_temp_writable_xreg(ctx);
    let v2 = RawInst::XLoad8S32G32 {
        dst: v1,
        addr: arg0.clone(),
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_xreg_to_xreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2280.
    return v5;
}

// Generated as internal constructor for term pulley_xload16le_u32_g32.
pub fn constructor_pulley_xload16le_u32_g32<C: Context>(
    ctx: &mut C,
    arg0: &AddrG32,
) -> XReg {
    let v1 = constructor_temp_writable_xreg(ctx);
    let v2 = RawInst::XLoad16LeU32G32 {
        dst: v1,
        addr: arg0.clone(),
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_xreg_to_xreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2287.
    return v5;
}

// Generated as internal constructor for term pulley_xload16le_s32_g32.
pub fn constructor_pulley_xload16le_s32_g32<C: Context>(
    ctx: &mut C,
    arg0: &AddrG32,
) -> XReg {
    let v1 = constructor_temp_writable_xreg(ctx);
    let v2 = RawInst::XLoad16LeS32G32 {
        dst: v1,
        addr: arg0.clone(),
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_xreg_to_xreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2294.
    return v5;
}

// Generated as internal constructor for term pulley_xload32le_g32.
pub fn constructor_pulley_xload32le_g32<C: Context>(
    ctx: &mut C,
    arg0: &AddrG32,
) -> XReg {
    let v1 = constructor_temp_writable_xreg(ctx);
    let v2 = RawInst::XLoad32LeG32 {
        dst: v1,
        addr: arg0.clone(),
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_xreg_to_xreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2301.
    return v5;
}

// Generated as internal constructor for term pulley_xload64le_g32.
pub fn constructor_pulley_xload64le_g32<C: Context>(
    ctx: &mut C,
    arg0: &AddrG32,
) -> XReg {
    let v1 = constructor_temp_writable_xreg(ctx);
    let v2 = RawInst::XLoad64LeG32 {
        dst: v1,
        addr: arg0.clone(),
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_xreg_to_xreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2308.
    return v5;
}

// Generated as internal constructor for term pulley_xstore8_g32.
pub fn constructor_pulley_xstore8_g32<C: Context>(
    ctx: &mut C,
    arg0: &AddrG32,
    arg1: XReg,
) -> SideEffectNoResult {
    let v2 = RawInst::XStore8G32 {
        addr: arg0.clone(),
        src: arg1,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = SideEffectNoResult::Inst {
        inst: v3.clone(),
    };
    // Rule at <OUT_DIR>/pulley_gen.isle line 2315.
    return v4;
}

// Generated as internal constructor for term pulley_xstore16le_g32.
pub fn constructor_pulley_xstore16le_g32<C: Context>(
    ctx: &mut C,
    arg0: &AddrG32,
    arg1: XReg,
) -> SideEffectNoResult {
    let v2 = RawInst::XStore16LeG32 {
        addr: arg0.clone(),
        src: arg1,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = SideEffectNoResult::Inst {
        inst: v3.clone(),
    };
    // Rule at <OUT_DIR>/pulley_gen.isle line 2317.
    return v4;
}

// Generated as internal constructor for term pulley_xstore32le_g32.
pub fn constructor_pulley_xstore32le_g32<C: Context>(
    ctx: &mut C,
    arg0: &AddrG32,
    arg1: XReg,
) -> SideEffectNoResult {
    let v2 = RawInst::XStore32LeG32 {
        addr: arg0.clone(),
        src: arg1,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = SideEffectNoResult::Inst {
        inst: v3.clone(),
    };
    // Rule at <OUT_DIR>/pulley_gen.isle line 2319.
    return v4;
}

// Generated as internal constructor for term pulley_xstore64le_g32.
pub fn constructor_pulley_xstore64le_g32<C: Context>(
    ctx: &mut C,
    arg0: &AddrG32,
    arg1: XReg,
) -> SideEffectNoResult {
    let v2 = RawInst::XStore64LeG32 {
        addr: arg0.clone(),
        src: arg1,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = SideEffectNoResult::Inst {
        inst: v3.clone(),
    };
    // Rule at <OUT_DIR>/pulley_gen.isle line 2321.
    return v4;
}

// Generated as internal constructor for term pulley_xload8_u32_g32bne.
pub fn constructor_pulley_xload8_u32_g32bne<C: Context>(
    ctx: &mut C,
    arg0: &AddrG32Bne,
) -> XReg {
    let v1 = constructor_temp_writable_xreg(ctx);
    let v2 = RawInst::XLoad8U32G32Bne {
        dst: v1,
        addr: arg0.clone(),
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_xreg_to_xreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2323.
    return v5;
}

// Generated as internal constructor for term pulley_xload8_s32_g32bne.
pub fn constructor_pulley_xload8_s32_g32bne<C: Context>(
    ctx: &mut C,
    arg0: &AddrG32Bne,
) -> XReg {
    let v1 = constructor_temp_writable_xreg(ctx);
    let v2 = RawInst::XLoad8S32G32Bne {
        dst: v1,
        addr: arg0.clone(),
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_xreg_to_xreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2330.
    return v5;
}

// Generated as internal constructor for term pulley_xload16le_u32_g32bne.
pub fn constructor_pulley_xload16le_u32_g32bne<C: Context>(
    ctx: &mut C,
    arg0: &AddrG32Bne,
) -> XReg {
    let v1 = constructor_temp_writable_xreg(ctx);
    let v2 = RawInst::XLoad16LeU32G32Bne {
        dst: v1,
        addr: arg0.clone(),
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_xreg_to_xreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2337.
    return v5;
}

// Generated as internal constructor for term pulley_xload16le_s32_g32bne.
pub fn constructor_pulley_xload16le_s32_g32bne<C: Context>(
    ctx: &mut C,
    arg0: &AddrG32Bne,
) -> XReg {
    let v1 = constructor_temp_writable_xreg(ctx);
    let v2 = RawInst::XLoad16LeS32G32Bne {
        dst: v1,
        addr: arg0.clone(),
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_xreg_to_xreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2344.
    return v5;
}

// Generated as internal constructor for term pulley_xload32le_g32bne.
pub fn constructor_pulley_xload32le_g32bne<C: Context>(
    ctx: &mut C,
    arg0: &AddrG32Bne,
) -> XReg {
    let v1 = constructor_temp_writable_xreg(ctx);
    let v2 = RawInst::XLoad32LeG32Bne {
        dst: v1,
        addr: arg0.clone(),
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_xreg_to_xreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2351.
    return v5;
}

// Generated as internal constructor for term pulley_xload64le_g32bne.
pub fn constructor_pulley_xload64le_g32bne<C: Context>(
    ctx: &mut C,
    arg0: &AddrG32Bne,
) -> XReg {
    let v1 = constructor_temp_writable_xreg(ctx);
    let v2 = RawInst::XLoad64LeG32Bne {
        dst: v1,
        addr: arg0.clone(),
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_xreg_to_xreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2358.
    return v5;
}

// Generated as internal constructor for term pulley_xstore8_g32bne.
pub fn constructor_pulley_xstore8_g32bne<C: Context>(
    ctx: &mut C,
    arg0: &AddrG32Bne,
    arg1: XReg,
) -> SideEffectNoResult {
    let v2 = RawInst::XStore8G32Bne {
        addr: arg0.clone(),
        src: arg1,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = SideEffectNoResult::Inst {
        inst: v3.clone(),
    };
    // Rule at <OUT_DIR>/pulley_gen.isle line 2365.
    return v4;
}

// Generated as internal constructor for term pulley_xstore16le_g32bne.
pub fn constructor_pulley_xstore16le_g32bne<C: Context>(
    ctx: &mut C,
    arg0: &AddrG32Bne,
    arg1: XReg,
) -> SideEffectNoResult {
    let v2 = RawInst::XStore16LeG32Bne {
        addr: arg0.clone(),
        src: arg1,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = SideEffectNoResult::Inst {
        inst: v3.clone(),
    };
    // Rule at <OUT_DIR>/pulley_gen.isle line 2367.
    return v4;
}

// Generated as internal constructor for term pulley_xstore32le_g32bne.
pub fn constructor_pulley_xstore32le_g32bne<C: Context>(
    ctx: &mut C,
    arg0: &AddrG32Bne,
    arg1: XReg,
) -> SideEffectNoResult {
    let v2 = RawInst::XStore32LeG32Bne {
        addr: arg0.clone(),
        src: arg1,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = SideEffectNoResult::Inst {
        inst: v3.clone(),
    };
    // Rule at <OUT_DIR>/pulley_gen.isle line 2369.
    return v4;
}

// Generated as internal constructor for term pulley_xstore64le_g32bne.
pub fn constructor_pulley_xstore64le_g32bne<C: Context>(
    ctx: &mut C,
    arg0: &AddrG32Bne,
    arg1: XReg,
) -> SideEffectNoResult {
    let v2 = RawInst::XStore64LeG32Bne {
        addr: arg0.clone(),
        src: arg1,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = SideEffectNoResult::Inst {
        inst: v3.clone(),
    };
    // Rule at <OUT_DIR>/pulley_gen.isle line 2371.
    return v4;
}

// Generated as internal constructor for term pulley_push_frame.
pub fn constructor_pulley_push_frame<C: Context>(
    ctx: &mut C,
) -> SideEffectNoResult {
    let v1 = &constructor_raw_inst_to_inst(ctx, &RawInst::PushFrame);
    let v2 = SideEffectNoResult::Inst {
        inst: v1.clone(),
    };
    // Rule at <OUT_DIR>/pulley_gen.isle line 2373.
    return v2;
}

// Generated as internal constructor for term pulley_pop_frame.
pub fn constructor_pulley_pop_frame<C: Context>(
    ctx: &mut C,
) -> SideEffectNoResult {
    let v1 = &constructor_raw_inst_to_inst(ctx, &RawInst::PopFrame);
    let v2 = SideEffectNoResult::Inst {
        inst: v1.clone(),
    };
    // Rule at <OUT_DIR>/pulley_gen.isle line 2375.
    return v2;
}

// Generated as internal constructor for term pulley_push_frame_save.
pub fn constructor_pulley_push_frame_save<C: Context>(
    ctx: &mut C,
    arg0: u16,
    arg1: UpperXRegSet,
) -> SideEffectNoResult {
    let v2 = RawInst::PushFrameSave {
        amt: arg0,
        regs: arg1,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = SideEffectNoResult::Inst {
        inst: v3.clone(),
    };
    // Rule at <OUT_DIR>/pulley_gen.isle line 2377.
    return v4;
}

// Generated as internal constructor for term pulley_pop_frame_restore.
pub fn constructor_pulley_pop_frame_restore<C: Context>(
    ctx: &mut C,
    arg0: u16,
    arg1: UpperXRegSet,
) -> SideEffectNoResult {
    let v2 = RawInst::PopFrameRestore {
        amt: arg0,
        regs: arg1,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = SideEffectNoResult::Inst {
        inst: v3.clone(),
    };
    // Rule at <OUT_DIR>/pulley_gen.isle line 2379.
    return v4;
}

// Generated as internal constructor for term pulley_stack_alloc32.
pub fn constructor_pulley_stack_alloc32<C: Context>(
    ctx: &mut C,
    arg0: u32,
) -> SideEffectNoResult {
    let v1 = RawInst::StackAlloc32 {
        amt: arg0,
    };
    let v2 = &constructor_raw_inst_to_inst(ctx, &v1);
    let v3 = SideEffectNoResult::Inst {
        inst: v2.clone(),
    };
    // Rule at <OUT_DIR>/pulley_gen.isle line 2381.
    return v3;
}

// Generated as internal constructor for term pulley_stack_free32.
pub fn constructor_pulley_stack_free32<C: Context>(
    ctx: &mut C,
    arg0: u32,
) -> SideEffectNoResult {
    let v1 = RawInst::StackFree32 {
        amt: arg0,
    };
    let v2 = &constructor_raw_inst_to_inst(ctx, &v1);
    let v3 = SideEffectNoResult::Inst {
        inst: v2.clone(),
    };
    // Rule at <OUT_DIR>/pulley_gen.isle line 2383.
    return v3;
}

// Generated as internal constructor for term pulley_zext8.
pub fn constructor_pulley_zext8<C: Context>(
    ctx: &mut C,
    arg0: XReg,
) -> XReg {
    let v1 = constructor_temp_writable_xreg(ctx);
    let v2 = RawInst::Zext8 {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_xreg_to_xreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2385.
    return v5;
}

// Generated as internal constructor for term pulley_zext16.
pub fn constructor_pulley_zext16<C: Context>(
    ctx: &mut C,
    arg0: XReg,
) -> XReg {
    let v1 = constructor_temp_writable_xreg(ctx);
    let v2 = RawInst::Zext16 {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_xreg_to_xreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2392.
    return v5;
}

// Generated as internal constructor for term pulley_zext32.
pub fn constructor_pulley_zext32<C: Context>(
    ctx: &mut C,
    arg0: XReg,
) -> XReg {
    let v1 = constructor_temp_writable_xreg(ctx);
    let v2 = RawInst::Zext32 {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_xreg_to_xreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2399.
    return v5;
}

// Generated as internal constructor for term pulley_sext8.
pub fn constructor_pulley_sext8<C: Context>(
    ctx: &mut C,
    arg0: XReg,
) -> XReg {
    let v1 = constructor_temp_writable_xreg(ctx);
    let v2 = RawInst::Sext8 {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_xreg_to_xreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2406.
    return v5;
}

// Generated as internal constructor for term pulley_sext16.
pub fn constructor_pulley_sext16<C: Context>(
    ctx: &mut C,
    arg0: XReg,
) -> XReg {
    let v1 = constructor_temp_writable_xreg(ctx);
    let v2 = RawInst::Sext16 {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_xreg_to_xreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2413.
    return v5;
}

// Generated as internal constructor for term pulley_sext32.
pub fn constructor_pulley_sext32<C: Context>(
    ctx: &mut C,
    arg0: XReg,
) -> XReg {
    let v1 = constructor_temp_writable_xreg(ctx);
    let v2 = RawInst::Sext32 {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_xreg_to_xreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2420.
    return v5;
}

// Generated as internal constructor for term pulley_xabs32.
pub fn constructor_pulley_xabs32<C: Context>(
    ctx: &mut C,
    arg0: XReg,
) -> XReg {
    let v1 = constructor_temp_writable_xreg(ctx);
    let v2 = RawInst::XAbs32 {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_xreg_to_xreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2427.
    return v5;
}

// Generated as internal constructor for term pulley_xabs64.
pub fn constructor_pulley_xabs64<C: Context>(
    ctx: &mut C,
    arg0: XReg,
) -> XReg {
    let v1 = constructor_temp_writable_xreg(ctx);
    let v2 = RawInst::XAbs64 {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_xreg_to_xreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2434.
    return v5;
}

// Generated as internal constructor for term pulley_xdiv32_s.
pub fn constructor_pulley_xdiv32_s<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: XReg,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::XDiv32S {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2441.
    return v6;
}

// Generated as internal constructor for term pulley_xdiv64_s.
pub fn constructor_pulley_xdiv64_s<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: XReg,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::XDiv64S {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2448.
    return v6;
}

// Generated as internal constructor for term pulley_xdiv32_u.
pub fn constructor_pulley_xdiv32_u<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: XReg,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::XDiv32U {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2455.
    return v6;
}

// Generated as internal constructor for term pulley_xdiv64_u.
pub fn constructor_pulley_xdiv64_u<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: XReg,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::XDiv64U {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2462.
    return v6;
}

// Generated as internal constructor for term pulley_xrem32_s.
pub fn constructor_pulley_xrem32_s<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: XReg,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::XRem32S {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2469.
    return v6;
}

// Generated as internal constructor for term pulley_xrem64_s.
pub fn constructor_pulley_xrem64_s<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: XReg,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::XRem64S {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2476.
    return v6;
}

// Generated as internal constructor for term pulley_xrem32_u.
pub fn constructor_pulley_xrem32_u<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: XReg,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::XRem32U {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2483.
    return v6;
}

// Generated as internal constructor for term pulley_xrem64_u.
pub fn constructor_pulley_xrem64_u<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: XReg,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::XRem64U {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2490.
    return v6;
}

// Generated as internal constructor for term pulley_xband32.
pub fn constructor_pulley_xband32<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: XReg,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::XBand32 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2497.
    return v6;
}

// Generated as internal constructor for term pulley_xband32_s8.
pub fn constructor_pulley_xband32_s8<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: i8,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::Xband32S8 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2504.
    return v6;
}

// Generated as internal constructor for term pulley_xband32_s32.
pub fn constructor_pulley_xband32_s32<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: i32,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::Xband32S32 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2511.
    return v6;
}

// Generated as internal constructor for term pulley_xband64.
pub fn constructor_pulley_xband64<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: XReg,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::XBand64 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2518.
    return v6;
}

// Generated as internal constructor for term pulley_xband64_s8.
pub fn constructor_pulley_xband64_s8<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: i8,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::Xband64S8 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2525.
    return v6;
}

// Generated as internal constructor for term pulley_xband64_s32.
pub fn constructor_pulley_xband64_s32<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: i32,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::Xband64S32 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2532.
    return v6;
}

// Generated as internal constructor for term pulley_xbor32.
pub fn constructor_pulley_xbor32<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: XReg,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::XBor32 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2539.
    return v6;
}

// Generated as internal constructor for term pulley_xbor32_s8.
pub fn constructor_pulley_xbor32_s8<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: i8,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::Xbor32S8 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2546.
    return v6;
}

// Generated as internal constructor for term pulley_xbor32_s32.
pub fn constructor_pulley_xbor32_s32<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: i32,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::Xbor32S32 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2553.
    return v6;
}

// Generated as internal constructor for term pulley_xbor64.
pub fn constructor_pulley_xbor64<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: XReg,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::XBor64 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2560.
    return v6;
}

// Generated as internal constructor for term pulley_xbor64_s8.
pub fn constructor_pulley_xbor64_s8<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: i8,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::Xbor64S8 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2567.
    return v6;
}

// Generated as internal constructor for term pulley_xbor64_s32.
pub fn constructor_pulley_xbor64_s32<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: i32,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::Xbor64S32 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2574.
    return v6;
}

// Generated as internal constructor for term pulley_xbxor32.
pub fn constructor_pulley_xbxor32<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: XReg,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::XBxor32 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2581.
    return v6;
}

// Generated as internal constructor for term pulley_xbxor32_s8.
pub fn constructor_pulley_xbxor32_s8<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: i8,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::Xbxor32S8 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2588.
    return v6;
}

// Generated as internal constructor for term pulley_xbxor32_s32.
pub fn constructor_pulley_xbxor32_s32<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: i32,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::Xbxor32S32 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2595.
    return v6;
}

// Generated as internal constructor for term pulley_xbxor64.
pub fn constructor_pulley_xbxor64<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: XReg,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::XBxor64 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2602.
    return v6;
}

// Generated as internal constructor for term pulley_xbxor64_s8.
pub fn constructor_pulley_xbxor64_s8<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: i8,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::Xbxor64S8 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2609.
    return v6;
}

// Generated as internal constructor for term pulley_xbxor64_s32.
pub fn constructor_pulley_xbxor64_s32<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: i32,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::Xbxor64S32 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2616.
    return v6;
}

// Generated as internal constructor for term pulley_xbnot32.
pub fn constructor_pulley_xbnot32<C: Context>(
    ctx: &mut C,
    arg0: XReg,
) -> XReg {
    let v1 = constructor_temp_writable_xreg(ctx);
    let v2 = RawInst::XBnot32 {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_xreg_to_xreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2623.
    return v5;
}

// Generated as internal constructor for term pulley_xbnot64.
pub fn constructor_pulley_xbnot64<C: Context>(
    ctx: &mut C,
    arg0: XReg,
) -> XReg {
    let v1 = constructor_temp_writable_xreg(ctx);
    let v2 = RawInst::XBnot64 {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_xreg_to_xreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2630.
    return v5;
}

// Generated as internal constructor for term pulley_xmin32_u.
pub fn constructor_pulley_xmin32_u<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: XReg,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::Xmin32U {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2637.
    return v6;
}

// Generated as internal constructor for term pulley_xmin32_s.
pub fn constructor_pulley_xmin32_s<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: XReg,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::Xmin32S {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2644.
    return v6;
}

// Generated as internal constructor for term pulley_xmax32_u.
pub fn constructor_pulley_xmax32_u<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: XReg,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::Xmax32U {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2651.
    return v6;
}

// Generated as internal constructor for term pulley_xmax32_s.
pub fn constructor_pulley_xmax32_s<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: XReg,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::Xmax32S {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2658.
    return v6;
}

// Generated as internal constructor for term pulley_xmin64_u.
pub fn constructor_pulley_xmin64_u<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: XReg,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::Xmin64U {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2665.
    return v6;
}

// Generated as internal constructor for term pulley_xmin64_s.
pub fn constructor_pulley_xmin64_s<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: XReg,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::Xmin64S {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2672.
    return v6;
}

// Generated as internal constructor for term pulley_xmax64_u.
pub fn constructor_pulley_xmax64_u<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: XReg,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::Xmax64U {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2679.
    return v6;
}

// Generated as internal constructor for term pulley_xmax64_s.
pub fn constructor_pulley_xmax64_s<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: XReg,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::Xmax64S {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2686.
    return v6;
}

// Generated as internal constructor for term pulley_xselect32.
pub fn constructor_pulley_xselect32<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: XReg,
    arg2: XReg,
) -> XReg {
    let v3 = constructor_temp_writable_xreg(ctx);
    let v4 = RawInst::XSelect32 {
        dst: v3,
        cond: arg0,
        if_nonzero: arg1,
        if_zero: arg2,
    };
    let v5 = &constructor_raw_inst_to_inst(ctx, &v4);
    let v6 = C::emit(ctx, v5);
    let v7 = C::writable_xreg_to_xreg(ctx, v3);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2693.
    return v7;
}

// Generated as internal constructor for term pulley_xselect64.
pub fn constructor_pulley_xselect64<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: XReg,
    arg2: XReg,
) -> XReg {
    let v3 = constructor_temp_writable_xreg(ctx);
    let v4 = RawInst::XSelect64 {
        dst: v3,
        cond: arg0,
        if_nonzero: arg1,
        if_zero: arg2,
    };
    let v5 = &constructor_raw_inst_to_inst(ctx, &v4);
    let v6 = C::emit(ctx, v5);
    let v7 = C::writable_xreg_to_xreg(ctx, v3);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2700.
    return v7;
}

// Generated as internal constructor for term pulley_trap.
pub fn constructor_pulley_trap<C: Context>(
    ctx: &mut C,
    arg0: &TrapCode,
) -> SideEffectNoResult {
    let v1 = RawInst::Trap {
        code: arg0.clone(),
    };
    let v2 = &constructor_raw_inst_to_inst(ctx, &v1);
    let v3 = SideEffectNoResult::Inst {
        inst: v2.clone(),
    };
    // Rule at <OUT_DIR>/pulley_gen.isle line 2707.
    return v3;
}

// Generated as internal constructor for term pulley_xpcadd.
pub fn constructor_pulley_xpcadd<C: Context>(
    ctx: &mut C,
    arg0: PcRelOffset,
) -> XReg {
    let v1 = constructor_temp_writable_xreg(ctx);
    let v2 = RawInst::Xpcadd {
        dst: v1,
        offset: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_xreg_to_xreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2709.
    return v5;
}

// Generated as internal constructor for term pulley_xmov_fp.
pub fn constructor_pulley_xmov_fp<C: Context>(
    ctx: &mut C,
) -> XReg {
    let v0 = constructor_temp_writable_xreg(ctx);
    let v1 = RawInst::XmovFp {
        dst: v0,
    };
    let v2 = &constructor_raw_inst_to_inst(ctx, &v1);
    let v3 = C::emit(ctx, v2);
    let v4 = C::writable_xreg_to_xreg(ctx, v0);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2716.
    return v4;
}

// Generated as internal constructor for term pulley_xmov_lr.
pub fn constructor_pulley_xmov_lr<C: Context>(
    ctx: &mut C,
) -> XReg {
    let v0 = constructor_temp_writable_xreg(ctx);
    let v1 = RawInst::XmovLr {
        dst: v0,
    };
    let v2 = &constructor_raw_inst_to_inst(ctx, &v1);
    let v3 = C::emit(ctx, v2);
    let v4 = C::writable_xreg_to_xreg(ctx, v0);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2723.
    return v4;
}

// Generated as internal constructor for term pulley_bswap32.
pub fn constructor_pulley_bswap32<C: Context>(
    ctx: &mut C,
    arg0: XReg,
) -> XReg {
    let v1 = constructor_temp_writable_xreg(ctx);
    let v2 = RawInst::Bswap32 {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_xreg_to_xreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2730.
    return v5;
}

// Generated as internal constructor for term pulley_bswap64.
pub fn constructor_pulley_bswap64<C: Context>(
    ctx: &mut C,
    arg0: XReg,
) -> XReg {
    let v1 = constructor_temp_writable_xreg(ctx);
    let v2 = RawInst::Bswap64 {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_xreg_to_xreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2737.
    return v5;
}

// Generated as internal constructor for term pulley_xadd32_uoverflow_trap.
pub fn constructor_pulley_xadd32_uoverflow_trap<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: XReg,
    arg2: &TrapCode,
) -> XReg {
    let v3 = constructor_temp_writable_xreg(ctx);
    let v4 = RawInst::Xadd32UoverflowTrap {
        dst: v3,
        src1: arg0,
        src2: arg1,
        code: arg2.clone(),
    };
    let v5 = &constructor_raw_inst_to_inst(ctx, &v4);
    let v6 = C::emit(ctx, v5);
    let v7 = C::writable_xreg_to_xreg(ctx, v3);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2744.
    return v7;
}

// Generated as internal constructor for term pulley_xadd64_uoverflow_trap.
pub fn constructor_pulley_xadd64_uoverflow_trap<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: XReg,
    arg2: &TrapCode,
) -> XReg {
    let v3 = constructor_temp_writable_xreg(ctx);
    let v4 = RawInst::Xadd64UoverflowTrap {
        dst: v3,
        src1: arg0,
        src2: arg1,
        code: arg2.clone(),
    };
    let v5 = &constructor_raw_inst_to_inst(ctx, &v4);
    let v6 = C::emit(ctx, v5);
    let v7 = C::writable_xreg_to_xreg(ctx, v3);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2751.
    return v7;
}

// Generated as internal constructor for term pulley_xmulhi64_s.
pub fn constructor_pulley_xmulhi64_s<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: XReg,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::XMulHi64S {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2758.
    return v6;
}

// Generated as internal constructor for term pulley_xmulhi64_u.
pub fn constructor_pulley_xmulhi64_u<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: XReg,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::XMulHi64U {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2765.
    return v6;
}

// Generated as internal constructor for term pulley_xbmask32.
pub fn constructor_pulley_xbmask32<C: Context>(
    ctx: &mut C,
    arg0: XReg,
) -> XReg {
    let v1 = constructor_temp_writable_xreg(ctx);
    let v2 = RawInst::Xbmask32 {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_xreg_to_xreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2772.
    return v5;
}

// Generated as internal constructor for term pulley_xbmask64.
pub fn constructor_pulley_xbmask64<C: Context>(
    ctx: &mut C,
    arg0: XReg,
) -> XReg {
    let v1 = constructor_temp_writable_xreg(ctx);
    let v2 = RawInst::Xbmask64 {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_xreg_to_xreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2779.
    return v5;
}

// Generated as internal constructor for term pulley_xload16be_u32_o32.
pub fn constructor_pulley_xload16be_u32_o32<C: Context>(
    ctx: &mut C,
    arg0: &AddrO32,
) -> XReg {
    let v1 = constructor_temp_writable_xreg(ctx);
    let v2 = RawInst::XLoad16BeU32O32 {
        dst: v1,
        addr: arg0.clone(),
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_xreg_to_xreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2786.
    return v5;
}

// Generated as internal constructor for term pulley_xload16be_s32_o32.
pub fn constructor_pulley_xload16be_s32_o32<C: Context>(
    ctx: &mut C,
    arg0: &AddrO32,
) -> XReg {
    let v1 = constructor_temp_writable_xreg(ctx);
    let v2 = RawInst::XLoad16BeS32O32 {
        dst: v1,
        addr: arg0.clone(),
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_xreg_to_xreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2793.
    return v5;
}

// Generated as internal constructor for term pulley_xload32be_o32.
pub fn constructor_pulley_xload32be_o32<C: Context>(
    ctx: &mut C,
    arg0: &AddrO32,
) -> XReg {
    let v1 = constructor_temp_writable_xreg(ctx);
    let v2 = RawInst::XLoad32BeO32 {
        dst: v1,
        addr: arg0.clone(),
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_xreg_to_xreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2800.
    return v5;
}

// Generated as internal constructor for term pulley_xload64be_o32.
pub fn constructor_pulley_xload64be_o32<C: Context>(
    ctx: &mut C,
    arg0: &AddrO32,
) -> XReg {
    let v1 = constructor_temp_writable_xreg(ctx);
    let v2 = RawInst::XLoad64BeO32 {
        dst: v1,
        addr: arg0.clone(),
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_xreg_to_xreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2807.
    return v5;
}

// Generated as internal constructor for term pulley_xstore16be_o32.
pub fn constructor_pulley_xstore16be_o32<C: Context>(
    ctx: &mut C,
    arg0: &AddrO32,
    arg1: XReg,
) -> SideEffectNoResult {
    let v2 = RawInst::XStore16BeO32 {
        addr: arg0.clone(),
        src: arg1,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = SideEffectNoResult::Inst {
        inst: v3.clone(),
    };
    // Rule at <OUT_DIR>/pulley_gen.isle line 2814.
    return v4;
}

// Generated as internal constructor for term pulley_xstore32be_o32.
pub fn constructor_pulley_xstore32be_o32<C: Context>(
    ctx: &mut C,
    arg0: &AddrO32,
    arg1: XReg,
) -> SideEffectNoResult {
    let v2 = RawInst::XStore32BeO32 {
        addr: arg0.clone(),
        src: arg1,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = SideEffectNoResult::Inst {
        inst: v3.clone(),
    };
    // Rule at <OUT_DIR>/pulley_gen.isle line 2816.
    return v4;
}

// Generated as internal constructor for term pulley_xstore64be_o32.
pub fn constructor_pulley_xstore64be_o32<C: Context>(
    ctx: &mut C,
    arg0: &AddrO32,
    arg1: XReg,
) -> SideEffectNoResult {
    let v2 = RawInst::XStore64BeO32 {
        addr: arg0.clone(),
        src: arg1,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = SideEffectNoResult::Inst {
        inst: v3.clone(),
    };
    // Rule at <OUT_DIR>/pulley_gen.isle line 2818.
    return v4;
}

// Generated as internal constructor for term pulley_fload32be_o32.
pub fn constructor_pulley_fload32be_o32<C: Context>(
    ctx: &mut C,
    arg0: &AddrO32,
) -> FReg {
    let v1 = constructor_temp_writable_freg(ctx);
    let v2 = RawInst::Fload32BeO32 {
        dst: v1,
        addr: arg0.clone(),
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_freg_to_freg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2820.
    return v5;
}

// Generated as internal constructor for term pulley_fload64be_o32.
pub fn constructor_pulley_fload64be_o32<C: Context>(
    ctx: &mut C,
    arg0: &AddrO32,
) -> FReg {
    let v1 = constructor_temp_writable_freg(ctx);
    let v2 = RawInst::Fload64BeO32 {
        dst: v1,
        addr: arg0.clone(),
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_freg_to_freg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2827.
    return v5;
}

// Generated as internal constructor for term pulley_fstore32be_o32.
pub fn constructor_pulley_fstore32be_o32<C: Context>(
    ctx: &mut C,
    arg0: &AddrO32,
    arg1: FReg,
) -> SideEffectNoResult {
    let v2 = RawInst::Fstore32BeO32 {
        addr: arg0.clone(),
        src: arg1,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = SideEffectNoResult::Inst {
        inst: v3.clone(),
    };
    // Rule at <OUT_DIR>/pulley_gen.isle line 2834.
    return v4;
}

// Generated as internal constructor for term pulley_fstore64be_o32.
pub fn constructor_pulley_fstore64be_o32<C: Context>(
    ctx: &mut C,
    arg0: &AddrO32,
    arg1: FReg,
) -> SideEffectNoResult {
    let v2 = RawInst::Fstore64BeO32 {
        addr: arg0.clone(),
        src: arg1,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = SideEffectNoResult::Inst {
        inst: v3.clone(),
    };
    // Rule at <OUT_DIR>/pulley_gen.isle line 2836.
    return v4;
}

// Generated as internal constructor for term pulley_fload32le_o32.
pub fn constructor_pulley_fload32le_o32<C: Context>(
    ctx: &mut C,
    arg0: &AddrO32,
) -> FReg {
    let v1 = constructor_temp_writable_freg(ctx);
    let v2 = RawInst::Fload32LeO32 {
        dst: v1,
        addr: arg0.clone(),
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_freg_to_freg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2838.
    return v5;
}

// Generated as internal constructor for term pulley_fload64le_o32.
pub fn constructor_pulley_fload64le_o32<C: Context>(
    ctx: &mut C,
    arg0: &AddrO32,
) -> FReg {
    let v1 = constructor_temp_writable_freg(ctx);
    let v2 = RawInst::Fload64LeO32 {
        dst: v1,
        addr: arg0.clone(),
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_freg_to_freg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2845.
    return v5;
}

// Generated as internal constructor for term pulley_fstore32le_o32.
pub fn constructor_pulley_fstore32le_o32<C: Context>(
    ctx: &mut C,
    arg0: &AddrO32,
    arg1: FReg,
) -> SideEffectNoResult {
    let v2 = RawInst::Fstore32LeO32 {
        addr: arg0.clone(),
        src: arg1,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = SideEffectNoResult::Inst {
        inst: v3.clone(),
    };
    // Rule at <OUT_DIR>/pulley_gen.isle line 2852.
    return v4;
}

// Generated as internal constructor for term pulley_fstore64le_o32.
pub fn constructor_pulley_fstore64le_o32<C: Context>(
    ctx: &mut C,
    arg0: &AddrO32,
    arg1: FReg,
) -> SideEffectNoResult {
    let v2 = RawInst::Fstore64LeO32 {
        addr: arg0.clone(),
        src: arg1,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = SideEffectNoResult::Inst {
        inst: v3.clone(),
    };
    // Rule at <OUT_DIR>/pulley_gen.isle line 2854.
    return v4;
}

// Generated as internal constructor for term pulley_fload32le_z.
pub fn constructor_pulley_fload32le_z<C: Context>(
    ctx: &mut C,
    arg0: &AddrZ,
    arg1: &TrapCode,
) -> FReg {
    let v2 = constructor_temp_writable_freg(ctx);
    let v3 = RawInst::Fload32LeZ {
        dst: v2,
        addr: arg0.clone(),
        code: arg1.clone(),
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_freg_to_freg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2856.
    return v6;
}

// Generated as internal constructor for term pulley_fload64le_z.
pub fn constructor_pulley_fload64le_z<C: Context>(
    ctx: &mut C,
    arg0: &AddrZ,
    arg1: &TrapCode,
) -> FReg {
    let v2 = constructor_temp_writable_freg(ctx);
    let v3 = RawInst::Fload64LeZ {
        dst: v2,
        addr: arg0.clone(),
        code: arg1.clone(),
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_freg_to_freg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2863.
    return v6;
}

// Generated as internal constructor for term pulley_fstore32le_z.
pub fn constructor_pulley_fstore32le_z<C: Context>(
    ctx: &mut C,
    arg0: &AddrZ,
    arg1: FReg,
    arg2: &TrapCode,
) -> SideEffectNoResult {
    let v3 = RawInst::Fstore32LeZ {
        addr: arg0.clone(),
        src: arg1,
        code: arg2.clone(),
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = SideEffectNoResult::Inst {
        inst: v4.clone(),
    };
    // Rule at <OUT_DIR>/pulley_gen.isle line 2870.
    return v5;
}

// Generated as internal constructor for term pulley_fstore64le_z.
pub fn constructor_pulley_fstore64le_z<C: Context>(
    ctx: &mut C,
    arg0: &AddrZ,
    arg1: FReg,
    arg2: &TrapCode,
) -> SideEffectNoResult {
    let v3 = RawInst::Fstore64LeZ {
        addr: arg0.clone(),
        src: arg1,
        code: arg2.clone(),
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = SideEffectNoResult::Inst {
        inst: v4.clone(),
    };
    // Rule at <OUT_DIR>/pulley_gen.isle line 2872.
    return v5;
}

// Generated as internal constructor for term pulley_fload32le_g32.
pub fn constructor_pulley_fload32le_g32<C: Context>(
    ctx: &mut C,
    arg0: &AddrG32,
) -> FReg {
    let v1 = constructor_temp_writable_freg(ctx);
    let v2 = RawInst::Fload32LeG32 {
        dst: v1,
        addr: arg0.clone(),
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_freg_to_freg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2874.
    return v5;
}

// Generated as internal constructor for term pulley_fload64le_g32.
pub fn constructor_pulley_fload64le_g32<C: Context>(
    ctx: &mut C,
    arg0: &AddrG32,
) -> FReg {
    let v1 = constructor_temp_writable_freg(ctx);
    let v2 = RawInst::Fload64LeG32 {
        dst: v1,
        addr: arg0.clone(),
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_freg_to_freg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2881.
    return v5;
}

// Generated as internal constructor for term pulley_fstore32le_g32.
pub fn constructor_pulley_fstore32le_g32<C: Context>(
    ctx: &mut C,
    arg0: &AddrG32,
    arg1: FReg,
) -> SideEffectNoResult {
    let v2 = RawInst::Fstore32LeG32 {
        addr: arg0.clone(),
        src: arg1,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = SideEffectNoResult::Inst {
        inst: v3.clone(),
    };
    // Rule at <OUT_DIR>/pulley_gen.isle line 2888.
    return v4;
}

// Generated as internal constructor for term pulley_fstore64le_g32.
pub fn constructor_pulley_fstore64le_g32<C: Context>(
    ctx: &mut C,
    arg0: &AddrG32,
    arg1: FReg,
) -> SideEffectNoResult {
    let v2 = RawInst::Fstore64LeG32 {
        addr: arg0.clone(),
        src: arg1,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = SideEffectNoResult::Inst {
        inst: v3.clone(),
    };
    // Rule at <OUT_DIR>/pulley_gen.isle line 2890.
    return v4;
}

// Generated as internal constructor for term pulley_vload128le_o32.
pub fn constructor_pulley_vload128le_o32<C: Context>(
    ctx: &mut C,
    arg0: &AddrO32,
) -> VReg {
    let v1 = constructor_temp_writable_vreg(ctx);
    let v2 = RawInst::VLoad128O32 {
        dst: v1,
        addr: arg0.clone(),
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_vreg_to_vreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2892.
    return v5;
}

// Generated as internal constructor for term pulley_vstore128le_o32.
pub fn constructor_pulley_vstore128le_o32<C: Context>(
    ctx: &mut C,
    arg0: &AddrO32,
    arg1: VReg,
) -> SideEffectNoResult {
    let v2 = RawInst::Vstore128LeO32 {
        addr: arg0.clone(),
        src: arg1,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = SideEffectNoResult::Inst {
        inst: v3.clone(),
    };
    // Rule at <OUT_DIR>/pulley_gen.isle line 2899.
    return v4;
}

// Generated as internal constructor for term pulley_vload128le_z.
pub fn constructor_pulley_vload128le_z<C: Context>(
    ctx: &mut C,
    arg0: &AddrZ,
    arg1: &TrapCode,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::VLoad128LeZ {
        dst: v2,
        addr: arg0.clone(),
        code: arg1.clone(),
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2901.
    return v6;
}

// Generated as internal constructor for term pulley_vstore128le_z.
pub fn constructor_pulley_vstore128le_z<C: Context>(
    ctx: &mut C,
    arg0: &AddrZ,
    arg1: VReg,
    arg2: &TrapCode,
) -> SideEffectNoResult {
    let v3 = RawInst::Vstore128LeZ {
        addr: arg0.clone(),
        src: arg1,
        code: arg2.clone(),
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = SideEffectNoResult::Inst {
        inst: v4.clone(),
    };
    // Rule at <OUT_DIR>/pulley_gen.isle line 2908.
    return v5;
}

// Generated as internal constructor for term pulley_vload128le_g32.
pub fn constructor_pulley_vload128le_g32<C: Context>(
    ctx: &mut C,
    arg0: &AddrG32,
) -> VReg {
    let v1 = constructor_temp_writable_vreg(ctx);
    let v2 = RawInst::VLoad128G32 {
        dst: v1,
        addr: arg0.clone(),
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_vreg_to_vreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2910.
    return v5;
}

// Generated as internal constructor for term pulley_vstore128le_g32.
pub fn constructor_pulley_vstore128le_g32<C: Context>(
    ctx: &mut C,
    arg0: &AddrG32,
    arg1: VReg,
) -> SideEffectNoResult {
    let v2 = RawInst::Vstore128LeG32 {
        addr: arg0.clone(),
        src: arg1,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = SideEffectNoResult::Inst {
        inst: v3.clone(),
    };
    // Rule at <OUT_DIR>/pulley_gen.isle line 2917.
    return v4;
}

// Generated as internal constructor for term pulley_fmov.
pub fn constructor_pulley_fmov<C: Context>(
    ctx: &mut C,
    arg0: FReg,
) -> FReg {
    let v1 = constructor_temp_writable_freg(ctx);
    let v2 = RawInst::Fmov {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_freg_to_freg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2919.
    return v5;
}

// Generated as internal constructor for term pulley_vmov.
pub fn constructor_pulley_vmov<C: Context>(
    ctx: &mut C,
    arg0: VReg,
) -> VReg {
    let v1 = constructor_temp_writable_vreg(ctx);
    let v2 = RawInst::Vmov {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_vreg_to_vreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2926.
    return v5;
}

// Generated as internal constructor for term pulley_bitcast_int_from_float_32.
pub fn constructor_pulley_bitcast_int_from_float_32<C: Context>(
    ctx: &mut C,
    arg0: FReg,
) -> XReg {
    let v1 = constructor_temp_writable_xreg(ctx);
    let v2 = RawInst::BitcastIntFromFloat32 {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_xreg_to_xreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2933.
    return v5;
}

// Generated as internal constructor for term pulley_bitcast_int_from_float_64.
pub fn constructor_pulley_bitcast_int_from_float_64<C: Context>(
    ctx: &mut C,
    arg0: FReg,
) -> XReg {
    let v1 = constructor_temp_writable_xreg(ctx);
    let v2 = RawInst::BitcastIntFromFloat64 {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_xreg_to_xreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2940.
    return v5;
}

// Generated as internal constructor for term pulley_bitcast_float_from_int_32.
pub fn constructor_pulley_bitcast_float_from_int_32<C: Context>(
    ctx: &mut C,
    arg0: XReg,
) -> FReg {
    let v1 = constructor_temp_writable_freg(ctx);
    let v2 = RawInst::BitcastFloatFromInt32 {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_freg_to_freg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2947.
    return v5;
}

// Generated as internal constructor for term pulley_bitcast_float_from_int_64.
pub fn constructor_pulley_bitcast_float_from_int_64<C: Context>(
    ctx: &mut C,
    arg0: XReg,
) -> FReg {
    let v1 = constructor_temp_writable_freg(ctx);
    let v2 = RawInst::BitcastFloatFromInt64 {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_freg_to_freg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2954.
    return v5;
}

// Generated as internal constructor for term pulley_fconst32.
pub fn constructor_pulley_fconst32<C: Context>(
    ctx: &mut C,
    arg0: u32,
) -> FReg {
    let v1 = constructor_temp_writable_freg(ctx);
    let v2 = RawInst::FConst32 {
        dst: v1,
        bits: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_freg_to_freg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2961.
    return v5;
}

// Generated as internal constructor for term pulley_fconst64.
pub fn constructor_pulley_fconst64<C: Context>(
    ctx: &mut C,
    arg0: u64,
) -> FReg {
    let v1 = constructor_temp_writable_freg(ctx);
    let v2 = RawInst::FConst64 {
        dst: v1,
        bits: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_freg_to_freg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2968.
    return v5;
}

// Generated as internal constructor for term pulley_feq32.
pub fn constructor_pulley_feq32<C: Context>(
    ctx: &mut C,
    arg0: FReg,
    arg1: FReg,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::Feq32 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2975.
    return v6;
}

// Generated as internal constructor for term pulley_fneq32.
pub fn constructor_pulley_fneq32<C: Context>(
    ctx: &mut C,
    arg0: FReg,
    arg1: FReg,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::Fneq32 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2982.
    return v6;
}

// Generated as internal constructor for term pulley_flt32.
pub fn constructor_pulley_flt32<C: Context>(
    ctx: &mut C,
    arg0: FReg,
    arg1: FReg,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::Flt32 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2989.
    return v6;
}

// Generated as internal constructor for term pulley_flteq32.
pub fn constructor_pulley_flteq32<C: Context>(
    ctx: &mut C,
    arg0: FReg,
    arg1: FReg,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::Flteq32 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 2996.
    return v6;
}

// Generated as internal constructor for term pulley_feq64.
pub fn constructor_pulley_feq64<C: Context>(
    ctx: &mut C,
    arg0: FReg,
    arg1: FReg,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::Feq64 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3003.
    return v6;
}

// Generated as internal constructor for term pulley_fneq64.
pub fn constructor_pulley_fneq64<C: Context>(
    ctx: &mut C,
    arg0: FReg,
    arg1: FReg,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::Fneq64 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3010.
    return v6;
}

// Generated as internal constructor for term pulley_flt64.
pub fn constructor_pulley_flt64<C: Context>(
    ctx: &mut C,
    arg0: FReg,
    arg1: FReg,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::Flt64 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3017.
    return v6;
}

// Generated as internal constructor for term pulley_flteq64.
pub fn constructor_pulley_flteq64<C: Context>(
    ctx: &mut C,
    arg0: FReg,
    arg1: FReg,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::Flteq64 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3024.
    return v6;
}

// Generated as internal constructor for term pulley_fselect32.
pub fn constructor_pulley_fselect32<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: FReg,
    arg2: FReg,
) -> FReg {
    let v3 = constructor_temp_writable_freg(ctx);
    let v4 = RawInst::FSelect32 {
        dst: v3,
        cond: arg0,
        if_nonzero: arg1,
        if_zero: arg2,
    };
    let v5 = &constructor_raw_inst_to_inst(ctx, &v4);
    let v6 = C::emit(ctx, v5);
    let v7 = C::writable_freg_to_freg(ctx, v3);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3031.
    return v7;
}

// Generated as internal constructor for term pulley_fselect64.
pub fn constructor_pulley_fselect64<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: FReg,
    arg2: FReg,
) -> FReg {
    let v3 = constructor_temp_writable_freg(ctx);
    let v4 = RawInst::FSelect64 {
        dst: v3,
        cond: arg0,
        if_nonzero: arg1,
        if_zero: arg2,
    };
    let v5 = &constructor_raw_inst_to_inst(ctx, &v4);
    let v6 = C::emit(ctx, v5);
    let v7 = C::writable_freg_to_freg(ctx, v3);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3038.
    return v7;
}

// Generated as internal constructor for term pulley_f32_from_f64.
pub fn constructor_pulley_f32_from_f64<C: Context>(
    ctx: &mut C,
    arg0: FReg,
) -> FReg {
    let v1 = constructor_temp_writable_freg(ctx);
    let v2 = RawInst::F32FromF64 {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_freg_to_freg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3045.
    return v5;
}

// Generated as internal constructor for term pulley_f64_from_f32.
pub fn constructor_pulley_f64_from_f32<C: Context>(
    ctx: &mut C,
    arg0: FReg,
) -> FReg {
    let v1 = constructor_temp_writable_freg(ctx);
    let v2 = RawInst::F64FromF32 {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_freg_to_freg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3052.
    return v5;
}

// Generated as internal constructor for term pulley_f32_from_x32_s.
pub fn constructor_pulley_f32_from_x32_s<C: Context>(
    ctx: &mut C,
    arg0: XReg,
) -> FReg {
    let v1 = constructor_temp_writable_freg(ctx);
    let v2 = RawInst::F32FromX32S {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_freg_to_freg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3059.
    return v5;
}

// Generated as internal constructor for term pulley_f32_from_x32_u.
pub fn constructor_pulley_f32_from_x32_u<C: Context>(
    ctx: &mut C,
    arg0: XReg,
) -> FReg {
    let v1 = constructor_temp_writable_freg(ctx);
    let v2 = RawInst::F32FromX32U {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_freg_to_freg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3066.
    return v5;
}

// Generated as internal constructor for term pulley_f32_from_x64_s.
pub fn constructor_pulley_f32_from_x64_s<C: Context>(
    ctx: &mut C,
    arg0: XReg,
) -> FReg {
    let v1 = constructor_temp_writable_freg(ctx);
    let v2 = RawInst::F32FromX64S {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_freg_to_freg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3073.
    return v5;
}

// Generated as internal constructor for term pulley_f32_from_x64_u.
pub fn constructor_pulley_f32_from_x64_u<C: Context>(
    ctx: &mut C,
    arg0: XReg,
) -> FReg {
    let v1 = constructor_temp_writable_freg(ctx);
    let v2 = RawInst::F32FromX64U {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_freg_to_freg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3080.
    return v5;
}

// Generated as internal constructor for term pulley_f64_from_x32_s.
pub fn constructor_pulley_f64_from_x32_s<C: Context>(
    ctx: &mut C,
    arg0: XReg,
) -> FReg {
    let v1 = constructor_temp_writable_freg(ctx);
    let v2 = RawInst::F64FromX32S {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_freg_to_freg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3087.
    return v5;
}

// Generated as internal constructor for term pulley_f64_from_x32_u.
pub fn constructor_pulley_f64_from_x32_u<C: Context>(
    ctx: &mut C,
    arg0: XReg,
) -> FReg {
    let v1 = constructor_temp_writable_freg(ctx);
    let v2 = RawInst::F64FromX32U {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_freg_to_freg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3094.
    return v5;
}

// Generated as internal constructor for term pulley_f64_from_x64_s.
pub fn constructor_pulley_f64_from_x64_s<C: Context>(
    ctx: &mut C,
    arg0: XReg,
) -> FReg {
    let v1 = constructor_temp_writable_freg(ctx);
    let v2 = RawInst::F64FromX64S {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_freg_to_freg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3101.
    return v5;
}

// Generated as internal constructor for term pulley_f64_from_x64_u.
pub fn constructor_pulley_f64_from_x64_u<C: Context>(
    ctx: &mut C,
    arg0: XReg,
) -> FReg {
    let v1 = constructor_temp_writable_freg(ctx);
    let v2 = RawInst::F64FromX64U {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_freg_to_freg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3108.
    return v5;
}

// Generated as internal constructor for term pulley_x32_from_f32_s.
pub fn constructor_pulley_x32_from_f32_s<C: Context>(
    ctx: &mut C,
    arg0: FReg,
) -> XReg {
    let v1 = constructor_temp_writable_xreg(ctx);
    let v2 = RawInst::X32FromF32S {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_xreg_to_xreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3115.
    return v5;
}

// Generated as internal constructor for term pulley_x32_from_f32_u.
pub fn constructor_pulley_x32_from_f32_u<C: Context>(
    ctx: &mut C,
    arg0: FReg,
) -> XReg {
    let v1 = constructor_temp_writable_xreg(ctx);
    let v2 = RawInst::X32FromF32U {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_xreg_to_xreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3122.
    return v5;
}

// Generated as internal constructor for term pulley_x32_from_f64_s.
pub fn constructor_pulley_x32_from_f64_s<C: Context>(
    ctx: &mut C,
    arg0: FReg,
) -> XReg {
    let v1 = constructor_temp_writable_xreg(ctx);
    let v2 = RawInst::X32FromF64S {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_xreg_to_xreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3129.
    return v5;
}

// Generated as internal constructor for term pulley_x32_from_f64_u.
pub fn constructor_pulley_x32_from_f64_u<C: Context>(
    ctx: &mut C,
    arg0: FReg,
) -> XReg {
    let v1 = constructor_temp_writable_xreg(ctx);
    let v2 = RawInst::X32FromF64U {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_xreg_to_xreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3136.
    return v5;
}

// Generated as internal constructor for term pulley_x64_from_f32_s.
pub fn constructor_pulley_x64_from_f32_s<C: Context>(
    ctx: &mut C,
    arg0: FReg,
) -> XReg {
    let v1 = constructor_temp_writable_xreg(ctx);
    let v2 = RawInst::X64FromF32S {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_xreg_to_xreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3143.
    return v5;
}

// Generated as internal constructor for term pulley_x64_from_f32_u.
pub fn constructor_pulley_x64_from_f32_u<C: Context>(
    ctx: &mut C,
    arg0: FReg,
) -> XReg {
    let v1 = constructor_temp_writable_xreg(ctx);
    let v2 = RawInst::X64FromF32U {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_xreg_to_xreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3150.
    return v5;
}

// Generated as internal constructor for term pulley_x64_from_f64_s.
pub fn constructor_pulley_x64_from_f64_s<C: Context>(
    ctx: &mut C,
    arg0: FReg,
) -> XReg {
    let v1 = constructor_temp_writable_xreg(ctx);
    let v2 = RawInst::X64FromF64S {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_xreg_to_xreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3157.
    return v5;
}

// Generated as internal constructor for term pulley_x64_from_f64_u.
pub fn constructor_pulley_x64_from_f64_u<C: Context>(
    ctx: &mut C,
    arg0: FReg,
) -> XReg {
    let v1 = constructor_temp_writable_xreg(ctx);
    let v2 = RawInst::X64FromF64U {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_xreg_to_xreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3164.
    return v5;
}

// Generated as internal constructor for term pulley_x32_from_f32_s_sat.
pub fn constructor_pulley_x32_from_f32_s_sat<C: Context>(
    ctx: &mut C,
    arg0: FReg,
) -> XReg {
    let v1 = constructor_temp_writable_xreg(ctx);
    let v2 = RawInst::X32FromF32SSat {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_xreg_to_xreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3171.
    return v5;
}

// Generated as internal constructor for term pulley_x32_from_f32_u_sat.
pub fn constructor_pulley_x32_from_f32_u_sat<C: Context>(
    ctx: &mut C,
    arg0: FReg,
) -> XReg {
    let v1 = constructor_temp_writable_xreg(ctx);
    let v2 = RawInst::X32FromF32USat {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_xreg_to_xreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3178.
    return v5;
}

// Generated as internal constructor for term pulley_x32_from_f64_s_sat.
pub fn constructor_pulley_x32_from_f64_s_sat<C: Context>(
    ctx: &mut C,
    arg0: FReg,
) -> XReg {
    let v1 = constructor_temp_writable_xreg(ctx);
    let v2 = RawInst::X32FromF64SSat {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_xreg_to_xreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3185.
    return v5;
}

// Generated as internal constructor for term pulley_x32_from_f64_u_sat.
pub fn constructor_pulley_x32_from_f64_u_sat<C: Context>(
    ctx: &mut C,
    arg0: FReg,
) -> XReg {
    let v1 = constructor_temp_writable_xreg(ctx);
    let v2 = RawInst::X32FromF64USat {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_xreg_to_xreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3192.
    return v5;
}

// Generated as internal constructor for term pulley_x64_from_f32_s_sat.
pub fn constructor_pulley_x64_from_f32_s_sat<C: Context>(
    ctx: &mut C,
    arg0: FReg,
) -> XReg {
    let v1 = constructor_temp_writable_xreg(ctx);
    let v2 = RawInst::X64FromF32SSat {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_xreg_to_xreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3199.
    return v5;
}

// Generated as internal constructor for term pulley_x64_from_f32_u_sat.
pub fn constructor_pulley_x64_from_f32_u_sat<C: Context>(
    ctx: &mut C,
    arg0: FReg,
) -> XReg {
    let v1 = constructor_temp_writable_xreg(ctx);
    let v2 = RawInst::X64FromF32USat {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_xreg_to_xreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3206.
    return v5;
}

// Generated as internal constructor for term pulley_x64_from_f64_s_sat.
pub fn constructor_pulley_x64_from_f64_s_sat<C: Context>(
    ctx: &mut C,
    arg0: FReg,
) -> XReg {
    let v1 = constructor_temp_writable_xreg(ctx);
    let v2 = RawInst::X64FromF64SSat {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_xreg_to_xreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3213.
    return v5;
}

// Generated as internal constructor for term pulley_x64_from_f64_u_sat.
pub fn constructor_pulley_x64_from_f64_u_sat<C: Context>(
    ctx: &mut C,
    arg0: FReg,
) -> XReg {
    let v1 = constructor_temp_writable_xreg(ctx);
    let v2 = RawInst::X64FromF64USat {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_xreg_to_xreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3220.
    return v5;
}

// Generated as internal constructor for term pulley_fcopysign32.
pub fn constructor_pulley_fcopysign32<C: Context>(
    ctx: &mut C,
    arg0: FReg,
    arg1: FReg,
) -> FReg {
    let v2 = constructor_temp_writable_freg(ctx);
    let v3 = RawInst::FCopySign32 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_freg_to_freg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3227.
    return v6;
}

// Generated as internal constructor for term pulley_fcopysign64.
pub fn constructor_pulley_fcopysign64<C: Context>(
    ctx: &mut C,
    arg0: FReg,
    arg1: FReg,
) -> FReg {
    let v2 = constructor_temp_writable_freg(ctx);
    let v3 = RawInst::FCopySign64 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_freg_to_freg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3234.
    return v6;
}

// Generated as internal constructor for term pulley_fadd32.
pub fn constructor_pulley_fadd32<C: Context>(
    ctx: &mut C,
    arg0: FReg,
    arg1: FReg,
) -> FReg {
    let v2 = constructor_temp_writable_freg(ctx);
    let v3 = RawInst::Fadd32 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_freg_to_freg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3241.
    return v6;
}

// Generated as internal constructor for term pulley_fsub32.
pub fn constructor_pulley_fsub32<C: Context>(
    ctx: &mut C,
    arg0: FReg,
    arg1: FReg,
) -> FReg {
    let v2 = constructor_temp_writable_freg(ctx);
    let v3 = RawInst::Fsub32 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_freg_to_freg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3248.
    return v6;
}

// Generated as internal constructor for term pulley_vsubf32x4.
pub fn constructor_pulley_vsubf32x4<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::Vsubf32x4 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3255.
    return v6;
}

// Generated as internal constructor for term pulley_fmul32.
pub fn constructor_pulley_fmul32<C: Context>(
    ctx: &mut C,
    arg0: FReg,
    arg1: FReg,
) -> FReg {
    let v2 = constructor_temp_writable_freg(ctx);
    let v3 = RawInst::Fmul32 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_freg_to_freg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3262.
    return v6;
}

// Generated as internal constructor for term pulley_vmulf32x4.
pub fn constructor_pulley_vmulf32x4<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::Vmulf32x4 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3269.
    return v6;
}

// Generated as internal constructor for term pulley_fdiv32.
pub fn constructor_pulley_fdiv32<C: Context>(
    ctx: &mut C,
    arg0: FReg,
    arg1: FReg,
) -> FReg {
    let v2 = constructor_temp_writable_freg(ctx);
    let v3 = RawInst::Fdiv32 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_freg_to_freg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3276.
    return v6;
}

// Generated as internal constructor for term pulley_vdivf32x4.
pub fn constructor_pulley_vdivf32x4<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::Vdivf32x4 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3283.
    return v6;
}

// Generated as internal constructor for term pulley_fmaximum32.
pub fn constructor_pulley_fmaximum32<C: Context>(
    ctx: &mut C,
    arg0: FReg,
    arg1: FReg,
) -> FReg {
    let v2 = constructor_temp_writable_freg(ctx);
    let v3 = RawInst::Fmaximum32 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_freg_to_freg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3290.
    return v6;
}

// Generated as internal constructor for term pulley_fminimum32.
pub fn constructor_pulley_fminimum32<C: Context>(
    ctx: &mut C,
    arg0: FReg,
    arg1: FReg,
) -> FReg {
    let v2 = constructor_temp_writable_freg(ctx);
    let v3 = RawInst::Fminimum32 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_freg_to_freg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3297.
    return v6;
}

// Generated as internal constructor for term pulley_ftrunc32.
pub fn constructor_pulley_ftrunc32<C: Context>(
    ctx: &mut C,
    arg0: FReg,
) -> FReg {
    let v1 = constructor_temp_writable_freg(ctx);
    let v2 = RawInst::Ftrunc32 {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_freg_to_freg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3304.
    return v5;
}

// Generated as internal constructor for term pulley_vtrunc32x4.
pub fn constructor_pulley_vtrunc32x4<C: Context>(
    ctx: &mut C,
    arg0: VReg,
) -> VReg {
    let v1 = constructor_temp_writable_vreg(ctx);
    let v2 = RawInst::Vtrunc32x4 {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_vreg_to_vreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3311.
    return v5;
}

// Generated as internal constructor for term pulley_vtrunc64x2.
pub fn constructor_pulley_vtrunc64x2<C: Context>(
    ctx: &mut C,
    arg0: VReg,
) -> VReg {
    let v1 = constructor_temp_writable_vreg(ctx);
    let v2 = RawInst::Vtrunc64x2 {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_vreg_to_vreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3318.
    return v5;
}

// Generated as internal constructor for term pulley_ffloor32.
pub fn constructor_pulley_ffloor32<C: Context>(
    ctx: &mut C,
    arg0: FReg,
) -> FReg {
    let v1 = constructor_temp_writable_freg(ctx);
    let v2 = RawInst::Ffloor32 {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_freg_to_freg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3325.
    return v5;
}

// Generated as internal constructor for term pulley_vfloor32x4.
pub fn constructor_pulley_vfloor32x4<C: Context>(
    ctx: &mut C,
    arg0: VReg,
) -> VReg {
    let v1 = constructor_temp_writable_vreg(ctx);
    let v2 = RawInst::Vfloor32x4 {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_vreg_to_vreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3332.
    return v5;
}

// Generated as internal constructor for term pulley_vfloor64x2.
pub fn constructor_pulley_vfloor64x2<C: Context>(
    ctx: &mut C,
    arg0: VReg,
) -> VReg {
    let v1 = constructor_temp_writable_vreg(ctx);
    let v2 = RawInst::Vfloor64x2 {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_vreg_to_vreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3339.
    return v5;
}

// Generated as internal constructor for term pulley_fceil32.
pub fn constructor_pulley_fceil32<C: Context>(
    ctx: &mut C,
    arg0: FReg,
) -> FReg {
    let v1 = constructor_temp_writable_freg(ctx);
    let v2 = RawInst::Fceil32 {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_freg_to_freg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3346.
    return v5;
}

// Generated as internal constructor for term pulley_vceil32x4.
pub fn constructor_pulley_vceil32x4<C: Context>(
    ctx: &mut C,
    arg0: VReg,
) -> VReg {
    let v1 = constructor_temp_writable_vreg(ctx);
    let v2 = RawInst::Vceil32x4 {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_vreg_to_vreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3353.
    return v5;
}

// Generated as internal constructor for term pulley_vceil64x2.
pub fn constructor_pulley_vceil64x2<C: Context>(
    ctx: &mut C,
    arg0: VReg,
) -> VReg {
    let v1 = constructor_temp_writable_vreg(ctx);
    let v2 = RawInst::Vceil64x2 {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_vreg_to_vreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3360.
    return v5;
}

// Generated as internal constructor for term pulley_fnearest32.
pub fn constructor_pulley_fnearest32<C: Context>(
    ctx: &mut C,
    arg0: FReg,
) -> FReg {
    let v1 = constructor_temp_writable_freg(ctx);
    let v2 = RawInst::Fnearest32 {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_freg_to_freg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3367.
    return v5;
}

// Generated as internal constructor for term pulley_fsqrt32.
pub fn constructor_pulley_fsqrt32<C: Context>(
    ctx: &mut C,
    arg0: FReg,
) -> FReg {
    let v1 = constructor_temp_writable_freg(ctx);
    let v2 = RawInst::Fsqrt32 {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_freg_to_freg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3374.
    return v5;
}

// Generated as internal constructor for term pulley_vsqrt32x4.
pub fn constructor_pulley_vsqrt32x4<C: Context>(
    ctx: &mut C,
    arg0: VReg,
) -> VReg {
    let v1 = constructor_temp_writable_vreg(ctx);
    let v2 = RawInst::Vsqrt32x4 {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_vreg_to_vreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3381.
    return v5;
}

// Generated as internal constructor for term pulley_vsqrt64x2.
pub fn constructor_pulley_vsqrt64x2<C: Context>(
    ctx: &mut C,
    arg0: VReg,
) -> VReg {
    let v1 = constructor_temp_writable_vreg(ctx);
    let v2 = RawInst::Vsqrt64x2 {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_vreg_to_vreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3388.
    return v5;
}

// Generated as internal constructor for term pulley_fneg32.
pub fn constructor_pulley_fneg32<C: Context>(
    ctx: &mut C,
    arg0: FReg,
) -> FReg {
    let v1 = constructor_temp_writable_freg(ctx);
    let v2 = RawInst::Fneg32 {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_freg_to_freg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3395.
    return v5;
}

// Generated as internal constructor for term pulley_vnegf32x4.
pub fn constructor_pulley_vnegf32x4<C: Context>(
    ctx: &mut C,
    arg0: VReg,
) -> VReg {
    let v1 = constructor_temp_writable_vreg(ctx);
    let v2 = RawInst::Vnegf32x4 {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_vreg_to_vreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3402.
    return v5;
}

// Generated as internal constructor for term pulley_fabs32.
pub fn constructor_pulley_fabs32<C: Context>(
    ctx: &mut C,
    arg0: FReg,
) -> FReg {
    let v1 = constructor_temp_writable_freg(ctx);
    let v2 = RawInst::Fabs32 {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_freg_to_freg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3409.
    return v5;
}

// Generated as internal constructor for term pulley_fadd64.
pub fn constructor_pulley_fadd64<C: Context>(
    ctx: &mut C,
    arg0: FReg,
    arg1: FReg,
) -> FReg {
    let v2 = constructor_temp_writable_freg(ctx);
    let v3 = RawInst::Fadd64 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_freg_to_freg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3416.
    return v6;
}

// Generated as internal constructor for term pulley_fsub64.
pub fn constructor_pulley_fsub64<C: Context>(
    ctx: &mut C,
    arg0: FReg,
    arg1: FReg,
) -> FReg {
    let v2 = constructor_temp_writable_freg(ctx);
    let v3 = RawInst::Fsub64 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_freg_to_freg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3423.
    return v6;
}

// Generated as internal constructor for term pulley_fmul64.
pub fn constructor_pulley_fmul64<C: Context>(
    ctx: &mut C,
    arg0: FReg,
    arg1: FReg,
) -> FReg {
    let v2 = constructor_temp_writable_freg(ctx);
    let v3 = RawInst::Fmul64 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_freg_to_freg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3430.
    return v6;
}

// Generated as internal constructor for term pulley_fdiv64.
pub fn constructor_pulley_fdiv64<C: Context>(
    ctx: &mut C,
    arg0: FReg,
    arg1: FReg,
) -> FReg {
    let v2 = constructor_temp_writable_freg(ctx);
    let v3 = RawInst::Fdiv64 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_freg_to_freg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3437.
    return v6;
}

// Generated as internal constructor for term pulley_vdivf64x2.
pub fn constructor_pulley_vdivf64x2<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::VDivF64x2 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3444.
    return v6;
}

// Generated as internal constructor for term pulley_fmaximum64.
pub fn constructor_pulley_fmaximum64<C: Context>(
    ctx: &mut C,
    arg0: FReg,
    arg1: FReg,
) -> FReg {
    let v2 = constructor_temp_writable_freg(ctx);
    let v3 = RawInst::Fmaximum64 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_freg_to_freg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3451.
    return v6;
}

// Generated as internal constructor for term pulley_fminimum64.
pub fn constructor_pulley_fminimum64<C: Context>(
    ctx: &mut C,
    arg0: FReg,
    arg1: FReg,
) -> FReg {
    let v2 = constructor_temp_writable_freg(ctx);
    let v3 = RawInst::Fminimum64 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_freg_to_freg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3458.
    return v6;
}

// Generated as internal constructor for term pulley_ftrunc64.
pub fn constructor_pulley_ftrunc64<C: Context>(
    ctx: &mut C,
    arg0: FReg,
) -> FReg {
    let v1 = constructor_temp_writable_freg(ctx);
    let v2 = RawInst::Ftrunc64 {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_freg_to_freg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3465.
    return v5;
}

// Generated as internal constructor for term pulley_ffloor64.
pub fn constructor_pulley_ffloor64<C: Context>(
    ctx: &mut C,
    arg0: FReg,
) -> FReg {
    let v1 = constructor_temp_writable_freg(ctx);
    let v2 = RawInst::Ffloor64 {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_freg_to_freg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3472.
    return v5;
}

// Generated as internal constructor for term pulley_fceil64.
pub fn constructor_pulley_fceil64<C: Context>(
    ctx: &mut C,
    arg0: FReg,
) -> FReg {
    let v1 = constructor_temp_writable_freg(ctx);
    let v2 = RawInst::Fceil64 {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_freg_to_freg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3479.
    return v5;
}

// Generated as internal constructor for term pulley_fnearest64.
pub fn constructor_pulley_fnearest64<C: Context>(
    ctx: &mut C,
    arg0: FReg,
) -> FReg {
    let v1 = constructor_temp_writable_freg(ctx);
    let v2 = RawInst::Fnearest64 {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_freg_to_freg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3486.
    return v5;
}

// Generated as internal constructor for term pulley_vnearest32x4.
pub fn constructor_pulley_vnearest32x4<C: Context>(
    ctx: &mut C,
    arg0: VReg,
) -> VReg {
    let v1 = constructor_temp_writable_vreg(ctx);
    let v2 = RawInst::Vnearest32x4 {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_vreg_to_vreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3493.
    return v5;
}

// Generated as internal constructor for term pulley_vnearest64x2.
pub fn constructor_pulley_vnearest64x2<C: Context>(
    ctx: &mut C,
    arg0: VReg,
) -> VReg {
    let v1 = constructor_temp_writable_vreg(ctx);
    let v2 = RawInst::Vnearest64x2 {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_vreg_to_vreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3500.
    return v5;
}

// Generated as internal constructor for term pulley_fsqrt64.
pub fn constructor_pulley_fsqrt64<C: Context>(
    ctx: &mut C,
    arg0: FReg,
) -> FReg {
    let v1 = constructor_temp_writable_freg(ctx);
    let v2 = RawInst::Fsqrt64 {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_freg_to_freg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3507.
    return v5;
}

// Generated as internal constructor for term pulley_fneg64.
pub fn constructor_pulley_fneg64<C: Context>(
    ctx: &mut C,
    arg0: FReg,
) -> FReg {
    let v1 = constructor_temp_writable_freg(ctx);
    let v2 = RawInst::Fneg64 {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_freg_to_freg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3514.
    return v5;
}

// Generated as internal constructor for term pulley_fabs64.
pub fn constructor_pulley_fabs64<C: Context>(
    ctx: &mut C,
    arg0: FReg,
) -> FReg {
    let v1 = constructor_temp_writable_freg(ctx);
    let v2 = RawInst::Fabs64 {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_freg_to_freg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3521.
    return v5;
}

// Generated as internal constructor for term pulley_vconst128.
pub fn constructor_pulley_vconst128<C: Context>(
    ctx: &mut C,
    arg0: u128,
) -> VReg {
    let v1 = constructor_temp_writable_vreg(ctx);
    let v2 = RawInst::Vconst128 {
        dst: v1,
        imm: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_vreg_to_vreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3528.
    return v5;
}

// Generated as internal constructor for term pulley_vaddi8x16.
pub fn constructor_pulley_vaddi8x16<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::VAddI8x16 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3535.
    return v6;
}

// Generated as internal constructor for term pulley_vaddi16x8.
pub fn constructor_pulley_vaddi16x8<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::VAddI16x8 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3542.
    return v6;
}

// Generated as internal constructor for term pulley_vaddi32x4.
pub fn constructor_pulley_vaddi32x4<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::VAddI32x4 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3549.
    return v6;
}

// Generated as internal constructor for term pulley_vaddi64x2.
pub fn constructor_pulley_vaddi64x2<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::VAddI64x2 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3556.
    return v6;
}

// Generated as internal constructor for term pulley_vaddf32x4.
pub fn constructor_pulley_vaddf32x4<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::VAddF32x4 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3563.
    return v6;
}

// Generated as internal constructor for term pulley_vaddf64x2.
pub fn constructor_pulley_vaddf64x2<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::VAddF64x2 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3570.
    return v6;
}

// Generated as internal constructor for term pulley_vaddi8x16_sat.
pub fn constructor_pulley_vaddi8x16_sat<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::VAddI8x16Sat {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3577.
    return v6;
}

// Generated as internal constructor for term pulley_vaddu8x16_sat.
pub fn constructor_pulley_vaddu8x16_sat<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::VAddU8x16Sat {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3584.
    return v6;
}

// Generated as internal constructor for term pulley_vaddi16x8_sat.
pub fn constructor_pulley_vaddi16x8_sat<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::VAddI16x8Sat {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3591.
    return v6;
}

// Generated as internal constructor for term pulley_vaddu16x8_sat.
pub fn constructor_pulley_vaddu16x8_sat<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::VAddU16x8Sat {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3598.
    return v6;
}

// Generated as internal constructor for term pulley_vaddpairwisei16x8_s.
pub fn constructor_pulley_vaddpairwisei16x8_s<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::VAddpairwiseI16x8S {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3605.
    return v6;
}

// Generated as internal constructor for term pulley_vaddpairwisei32x4_s.
pub fn constructor_pulley_vaddpairwisei32x4_s<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::VAddpairwiseI32x4S {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3612.
    return v6;
}

// Generated as internal constructor for term pulley_vshli8x16.
pub fn constructor_pulley_vshli8x16<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: XReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::VShlI8x16 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3619.
    return v6;
}

// Generated as internal constructor for term pulley_vshli16x8.
pub fn constructor_pulley_vshli16x8<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: XReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::VShlI16x8 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3626.
    return v6;
}

// Generated as internal constructor for term pulley_vshli32x4.
pub fn constructor_pulley_vshli32x4<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: XReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::VShlI32x4 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3633.
    return v6;
}

// Generated as internal constructor for term pulley_vshli64x2.
pub fn constructor_pulley_vshli64x2<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: XReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::VShlI64x2 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3640.
    return v6;
}

// Generated as internal constructor for term pulley_vshri8x16_s.
pub fn constructor_pulley_vshri8x16_s<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: XReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::VShrI8x16S {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3647.
    return v6;
}

// Generated as internal constructor for term pulley_vshri16x8_s.
pub fn constructor_pulley_vshri16x8_s<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: XReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::VShrI16x8S {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3654.
    return v6;
}

// Generated as internal constructor for term pulley_vshri32x4_s.
pub fn constructor_pulley_vshri32x4_s<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: XReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::VShrI32x4S {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3661.
    return v6;
}

// Generated as internal constructor for term pulley_vshri64x2_s.
pub fn constructor_pulley_vshri64x2_s<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: XReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::VShrI64x2S {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3668.
    return v6;
}

// Generated as internal constructor for term pulley_vshri8x16_u.
pub fn constructor_pulley_vshri8x16_u<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: XReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::VShrI8x16U {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3675.
    return v6;
}

// Generated as internal constructor for term pulley_vshri16x8_u.
pub fn constructor_pulley_vshri16x8_u<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: XReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::VShrI16x8U {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3682.
    return v6;
}

// Generated as internal constructor for term pulley_vshri32x4_u.
pub fn constructor_pulley_vshri32x4_u<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: XReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::VShrI32x4U {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3689.
    return v6;
}

// Generated as internal constructor for term pulley_vshri64x2_u.
pub fn constructor_pulley_vshri64x2_u<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: XReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::VShrI64x2U {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3696.
    return v6;
}

// Generated as internal constructor for term pulley_vsplatx8.
pub fn constructor_pulley_vsplatx8<C: Context>(
    ctx: &mut C,
    arg0: XReg,
) -> VReg {
    let v1 = constructor_temp_writable_vreg(ctx);
    let v2 = RawInst::VSplatX8 {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_vreg_to_vreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3703.
    return v5;
}

// Generated as internal constructor for term pulley_vsplatx16.
pub fn constructor_pulley_vsplatx16<C: Context>(
    ctx: &mut C,
    arg0: XReg,
) -> VReg {
    let v1 = constructor_temp_writable_vreg(ctx);
    let v2 = RawInst::VSplatX16 {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_vreg_to_vreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3710.
    return v5;
}

// Generated as internal constructor for term pulley_vsplatx32.
pub fn constructor_pulley_vsplatx32<C: Context>(
    ctx: &mut C,
    arg0: XReg,
) -> VReg {
    let v1 = constructor_temp_writable_vreg(ctx);
    let v2 = RawInst::VSplatX32 {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_vreg_to_vreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3717.
    return v5;
}

// Generated as internal constructor for term pulley_vsplatx64.
pub fn constructor_pulley_vsplatx64<C: Context>(
    ctx: &mut C,
    arg0: XReg,
) -> VReg {
    let v1 = constructor_temp_writable_vreg(ctx);
    let v2 = RawInst::VSplatX64 {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_vreg_to_vreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3724.
    return v5;
}

// Generated as internal constructor for term pulley_vsplatf32.
pub fn constructor_pulley_vsplatf32<C: Context>(
    ctx: &mut C,
    arg0: FReg,
) -> VReg {
    let v1 = constructor_temp_writable_vreg(ctx);
    let v2 = RawInst::VSplatF32 {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_vreg_to_vreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3731.
    return v5;
}

// Generated as internal constructor for term pulley_vsplatf64.
pub fn constructor_pulley_vsplatf64<C: Context>(
    ctx: &mut C,
    arg0: FReg,
) -> VReg {
    let v1 = constructor_temp_writable_vreg(ctx);
    let v2 = RawInst::VSplatF64 {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_vreg_to_vreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3738.
    return v5;
}

// Generated as internal constructor for term pulley_vload8x8_s_z.
pub fn constructor_pulley_vload8x8_s_z<C: Context>(
    ctx: &mut C,
    arg0: &AddrZ,
    arg1: &TrapCode,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::VLoad8x8SZ {
        dst: v2,
        addr: arg0.clone(),
        code: arg1.clone(),
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3745.
    return v6;
}

// Generated as internal constructor for term pulley_vload8x8_u_z.
pub fn constructor_pulley_vload8x8_u_z<C: Context>(
    ctx: &mut C,
    arg0: &AddrZ,
    arg1: &TrapCode,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::VLoad8x8UZ {
        dst: v2,
        addr: arg0.clone(),
        code: arg1.clone(),
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3752.
    return v6;
}

// Generated as internal constructor for term pulley_vload16x4le_s_z.
pub fn constructor_pulley_vload16x4le_s_z<C: Context>(
    ctx: &mut C,
    arg0: &AddrZ,
    arg1: &TrapCode,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::VLoad16x4LeSZ {
        dst: v2,
        addr: arg0.clone(),
        code: arg1.clone(),
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3759.
    return v6;
}

// Generated as internal constructor for term pulley_vload16x4le_u_z.
pub fn constructor_pulley_vload16x4le_u_z<C: Context>(
    ctx: &mut C,
    arg0: &AddrZ,
    arg1: &TrapCode,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::VLoad16x4LeUZ {
        dst: v2,
        addr: arg0.clone(),
        code: arg1.clone(),
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3766.
    return v6;
}

// Generated as internal constructor for term pulley_vload32x2le_s_z.
pub fn constructor_pulley_vload32x2le_s_z<C: Context>(
    ctx: &mut C,
    arg0: &AddrZ,
    arg1: &TrapCode,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::VLoad32x2LeSZ {
        dst: v2,
        addr: arg0.clone(),
        code: arg1.clone(),
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3773.
    return v6;
}

// Generated as internal constructor for term pulley_vload32x2le_u_z.
pub fn constructor_pulley_vload32x2le_u_z<C: Context>(
    ctx: &mut C,
    arg0: &AddrZ,
    arg1: &TrapCode,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::VLoad32x2LeUZ {
        dst: v2,
        addr: arg0.clone(),
        code: arg1.clone(),
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3780.
    return v6;
}

// Generated as internal constructor for term pulley_vband128.
pub fn constructor_pulley_vband128<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::VBand128 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3787.
    return v6;
}

// Generated as internal constructor for term pulley_vbor128.
pub fn constructor_pulley_vbor128<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::VBor128 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3794.
    return v6;
}

// Generated as internal constructor for term pulley_vbxor128.
pub fn constructor_pulley_vbxor128<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::VBxor128 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3801.
    return v6;
}

// Generated as internal constructor for term pulley_vbnot128.
pub fn constructor_pulley_vbnot128<C: Context>(
    ctx: &mut C,
    arg0: VReg,
) -> VReg {
    let v1 = constructor_temp_writable_vreg(ctx);
    let v2 = RawInst::VBnot128 {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_vreg_to_vreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3808.
    return v5;
}

// Generated as internal constructor for term pulley_vbitselect128.
pub fn constructor_pulley_vbitselect128<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
    arg2: VReg,
) -> VReg {
    let v3 = constructor_temp_writable_vreg(ctx);
    let v4 = RawInst::VBitselect128 {
        dst: v3,
        c: arg0,
        x: arg1,
        y: arg2,
    };
    let v5 = &constructor_raw_inst_to_inst(ctx, &v4);
    let v6 = C::emit(ctx, v5);
    let v7 = C::writable_vreg_to_vreg(ctx, v3);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3815.
    return v7;
}

// Generated as internal constructor for term pulley_vbitmask8x16.
pub fn constructor_pulley_vbitmask8x16<C: Context>(
    ctx: &mut C,
    arg0: VReg,
) -> XReg {
    let v1 = constructor_temp_writable_xreg(ctx);
    let v2 = RawInst::Vbitmask8x16 {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_xreg_to_xreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3822.
    return v5;
}

// Generated as internal constructor for term pulley_vbitmask16x8.
pub fn constructor_pulley_vbitmask16x8<C: Context>(
    ctx: &mut C,
    arg0: VReg,
) -> XReg {
    let v1 = constructor_temp_writable_xreg(ctx);
    let v2 = RawInst::Vbitmask16x8 {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_xreg_to_xreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3829.
    return v5;
}

// Generated as internal constructor for term pulley_vbitmask32x4.
pub fn constructor_pulley_vbitmask32x4<C: Context>(
    ctx: &mut C,
    arg0: VReg,
) -> XReg {
    let v1 = constructor_temp_writable_xreg(ctx);
    let v2 = RawInst::Vbitmask32x4 {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_xreg_to_xreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3836.
    return v5;
}

// Generated as internal constructor for term pulley_vbitmask64x2.
pub fn constructor_pulley_vbitmask64x2<C: Context>(
    ctx: &mut C,
    arg0: VReg,
) -> XReg {
    let v1 = constructor_temp_writable_xreg(ctx);
    let v2 = RawInst::Vbitmask64x2 {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_xreg_to_xreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3843.
    return v5;
}

// Generated as internal constructor for term pulley_valltrue8x16.
pub fn constructor_pulley_valltrue8x16<C: Context>(
    ctx: &mut C,
    arg0: VReg,
) -> XReg {
    let v1 = constructor_temp_writable_xreg(ctx);
    let v2 = RawInst::Valltrue8x16 {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_xreg_to_xreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3850.
    return v5;
}

// Generated as internal constructor for term pulley_valltrue16x8.
pub fn constructor_pulley_valltrue16x8<C: Context>(
    ctx: &mut C,
    arg0: VReg,
) -> XReg {
    let v1 = constructor_temp_writable_xreg(ctx);
    let v2 = RawInst::Valltrue16x8 {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_xreg_to_xreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3857.
    return v5;
}

// Generated as internal constructor for term pulley_valltrue32x4.
pub fn constructor_pulley_valltrue32x4<C: Context>(
    ctx: &mut C,
    arg0: VReg,
) -> XReg {
    let v1 = constructor_temp_writable_xreg(ctx);
    let v2 = RawInst::Valltrue32x4 {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_xreg_to_xreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3864.
    return v5;
}

// Generated as internal constructor for term pulley_valltrue64x2.
pub fn constructor_pulley_valltrue64x2<C: Context>(
    ctx: &mut C,
    arg0: VReg,
) -> XReg {
    let v1 = constructor_temp_writable_xreg(ctx);
    let v2 = RawInst::Valltrue64x2 {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_xreg_to_xreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3871.
    return v5;
}

// Generated as internal constructor for term pulley_vanytrue8x16.
pub fn constructor_pulley_vanytrue8x16<C: Context>(
    ctx: &mut C,
    arg0: VReg,
) -> XReg {
    let v1 = constructor_temp_writable_xreg(ctx);
    let v2 = RawInst::Vanytrue8x16 {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_xreg_to_xreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3878.
    return v5;
}

// Generated as internal constructor for term pulley_vanytrue16x8.
pub fn constructor_pulley_vanytrue16x8<C: Context>(
    ctx: &mut C,
    arg0: VReg,
) -> XReg {
    let v1 = constructor_temp_writable_xreg(ctx);
    let v2 = RawInst::Vanytrue16x8 {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_xreg_to_xreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3885.
    return v5;
}

// Generated as internal constructor for term pulley_vanytrue32x4.
pub fn constructor_pulley_vanytrue32x4<C: Context>(
    ctx: &mut C,
    arg0: VReg,
) -> XReg {
    let v1 = constructor_temp_writable_xreg(ctx);
    let v2 = RawInst::Vanytrue32x4 {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_xreg_to_xreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3892.
    return v5;
}

// Generated as internal constructor for term pulley_vanytrue64x2.
pub fn constructor_pulley_vanytrue64x2<C: Context>(
    ctx: &mut C,
    arg0: VReg,
) -> XReg {
    let v1 = constructor_temp_writable_xreg(ctx);
    let v2 = RawInst::Vanytrue64x2 {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_xreg_to_xreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3899.
    return v5;
}

// Generated as internal constructor for term pulley_vf32x4_from_i32x4_s.
pub fn constructor_pulley_vf32x4_from_i32x4_s<C: Context>(
    ctx: &mut C,
    arg0: VReg,
) -> VReg {
    let v1 = constructor_temp_writable_vreg(ctx);
    let v2 = RawInst::VF32x4FromI32x4S {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_vreg_to_vreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3906.
    return v5;
}

// Generated as internal constructor for term pulley_vf32x4_from_i32x4_u.
pub fn constructor_pulley_vf32x4_from_i32x4_u<C: Context>(
    ctx: &mut C,
    arg0: VReg,
) -> VReg {
    let v1 = constructor_temp_writable_vreg(ctx);
    let v2 = RawInst::VF32x4FromI32x4U {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_vreg_to_vreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3913.
    return v5;
}

// Generated as internal constructor for term pulley_vf64x2_from_i64x2_s.
pub fn constructor_pulley_vf64x2_from_i64x2_s<C: Context>(
    ctx: &mut C,
    arg0: VReg,
) -> VReg {
    let v1 = constructor_temp_writable_vreg(ctx);
    let v2 = RawInst::VF64x2FromI64x2S {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_vreg_to_vreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3920.
    return v5;
}

// Generated as internal constructor for term pulley_vf64x2_from_i64x2_u.
pub fn constructor_pulley_vf64x2_from_i64x2_u<C: Context>(
    ctx: &mut C,
    arg0: VReg,
) -> VReg {
    let v1 = constructor_temp_writable_vreg(ctx);
    let v2 = RawInst::VF64x2FromI64x2U {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_vreg_to_vreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3927.
    return v5;
}

// Generated as internal constructor for term pulley_vi32x4_from_f32x4_s.
pub fn constructor_pulley_vi32x4_from_f32x4_s<C: Context>(
    ctx: &mut C,
    arg0: VReg,
) -> VReg {
    let v1 = constructor_temp_writable_vreg(ctx);
    let v2 = RawInst::VI32x4FromF32x4S {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_vreg_to_vreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3934.
    return v5;
}

// Generated as internal constructor for term pulley_vi32x4_from_f32x4_u.
pub fn constructor_pulley_vi32x4_from_f32x4_u<C: Context>(
    ctx: &mut C,
    arg0: VReg,
) -> VReg {
    let v1 = constructor_temp_writable_vreg(ctx);
    let v2 = RawInst::VI32x4FromF32x4U {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_vreg_to_vreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3941.
    return v5;
}

// Generated as internal constructor for term pulley_vi64x2_from_f64x2_s.
pub fn constructor_pulley_vi64x2_from_f64x2_s<C: Context>(
    ctx: &mut C,
    arg0: VReg,
) -> VReg {
    let v1 = constructor_temp_writable_vreg(ctx);
    let v2 = RawInst::VI64x2FromF64x2S {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_vreg_to_vreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3948.
    return v5;
}

// Generated as internal constructor for term pulley_vi64x2_from_f64x2_u.
pub fn constructor_pulley_vi64x2_from_f64x2_u<C: Context>(
    ctx: &mut C,
    arg0: VReg,
) -> VReg {
    let v1 = constructor_temp_writable_vreg(ctx);
    let v2 = RawInst::VI64x2FromF64x2U {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_vreg_to_vreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3955.
    return v5;
}

// Generated as internal constructor for term pulley_vwidenlow8x16_s.
pub fn constructor_pulley_vwidenlow8x16_s<C: Context>(
    ctx: &mut C,
    arg0: VReg,
) -> VReg {
    let v1 = constructor_temp_writable_vreg(ctx);
    let v2 = RawInst::VWidenLow8x16S {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_vreg_to_vreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3962.
    return v5;
}

// Generated as internal constructor for term pulley_vwidenlow8x16_u.
pub fn constructor_pulley_vwidenlow8x16_u<C: Context>(
    ctx: &mut C,
    arg0: VReg,
) -> VReg {
    let v1 = constructor_temp_writable_vreg(ctx);
    let v2 = RawInst::VWidenLow8x16U {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_vreg_to_vreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3969.
    return v5;
}

// Generated as internal constructor for term pulley_vwidenlow16x8_s.
pub fn constructor_pulley_vwidenlow16x8_s<C: Context>(
    ctx: &mut C,
    arg0: VReg,
) -> VReg {
    let v1 = constructor_temp_writable_vreg(ctx);
    let v2 = RawInst::VWidenLow16x8S {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_vreg_to_vreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3976.
    return v5;
}

// Generated as internal constructor for term pulley_vwidenlow16x8_u.
pub fn constructor_pulley_vwidenlow16x8_u<C: Context>(
    ctx: &mut C,
    arg0: VReg,
) -> VReg {
    let v1 = constructor_temp_writable_vreg(ctx);
    let v2 = RawInst::VWidenLow16x8U {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_vreg_to_vreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3983.
    return v5;
}

// Generated as internal constructor for term pulley_vwidenlow32x4_s.
pub fn constructor_pulley_vwidenlow32x4_s<C: Context>(
    ctx: &mut C,
    arg0: VReg,
) -> VReg {
    let v1 = constructor_temp_writable_vreg(ctx);
    let v2 = RawInst::VWidenLow32x4S {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_vreg_to_vreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3990.
    return v5;
}

// Generated as internal constructor for term pulley_vwidenlow32x4_u.
pub fn constructor_pulley_vwidenlow32x4_u<C: Context>(
    ctx: &mut C,
    arg0: VReg,
) -> VReg {
    let v1 = constructor_temp_writable_vreg(ctx);
    let v2 = RawInst::VWidenLow32x4U {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_vreg_to_vreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 3997.
    return v5;
}

// Generated as internal constructor for term pulley_vwidenhigh8x16_s.
pub fn constructor_pulley_vwidenhigh8x16_s<C: Context>(
    ctx: &mut C,
    arg0: VReg,
) -> VReg {
    let v1 = constructor_temp_writable_vreg(ctx);
    let v2 = RawInst::VWidenHigh8x16S {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_vreg_to_vreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4004.
    return v5;
}

// Generated as internal constructor for term pulley_vwidenhigh8x16_u.
pub fn constructor_pulley_vwidenhigh8x16_u<C: Context>(
    ctx: &mut C,
    arg0: VReg,
) -> VReg {
    let v1 = constructor_temp_writable_vreg(ctx);
    let v2 = RawInst::VWidenHigh8x16U {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_vreg_to_vreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4011.
    return v5;
}

// Generated as internal constructor for term pulley_vwidenhigh16x8_s.
pub fn constructor_pulley_vwidenhigh16x8_s<C: Context>(
    ctx: &mut C,
    arg0: VReg,
) -> VReg {
    let v1 = constructor_temp_writable_vreg(ctx);
    let v2 = RawInst::VWidenHigh16x8S {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_vreg_to_vreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4018.
    return v5;
}

// Generated as internal constructor for term pulley_vwidenhigh16x8_u.
pub fn constructor_pulley_vwidenhigh16x8_u<C: Context>(
    ctx: &mut C,
    arg0: VReg,
) -> VReg {
    let v1 = constructor_temp_writable_vreg(ctx);
    let v2 = RawInst::VWidenHigh16x8U {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_vreg_to_vreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4025.
    return v5;
}

// Generated as internal constructor for term pulley_vwidenhigh32x4_s.
pub fn constructor_pulley_vwidenhigh32x4_s<C: Context>(
    ctx: &mut C,
    arg0: VReg,
) -> VReg {
    let v1 = constructor_temp_writable_vreg(ctx);
    let v2 = RawInst::VWidenHigh32x4S {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_vreg_to_vreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4032.
    return v5;
}

// Generated as internal constructor for term pulley_vwidenhigh32x4_u.
pub fn constructor_pulley_vwidenhigh32x4_u<C: Context>(
    ctx: &mut C,
    arg0: VReg,
) -> VReg {
    let v1 = constructor_temp_writable_vreg(ctx);
    let v2 = RawInst::VWidenHigh32x4U {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_vreg_to_vreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4039.
    return v5;
}

// Generated as internal constructor for term pulley_vnarrow16x8_s.
pub fn constructor_pulley_vnarrow16x8_s<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::Vnarrow16x8S {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4046.
    return v6;
}

// Generated as internal constructor for term pulley_vnarrow16x8_u.
pub fn constructor_pulley_vnarrow16x8_u<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::Vnarrow16x8U {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4053.
    return v6;
}

// Generated as internal constructor for term pulley_vnarrow32x4_s.
pub fn constructor_pulley_vnarrow32x4_s<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::Vnarrow32x4S {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4060.
    return v6;
}

// Generated as internal constructor for term pulley_vnarrow32x4_u.
pub fn constructor_pulley_vnarrow32x4_u<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::Vnarrow32x4U {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4067.
    return v6;
}

// Generated as internal constructor for term pulley_vnarrow64x2_s.
pub fn constructor_pulley_vnarrow64x2_s<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::Vnarrow64x2S {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4074.
    return v6;
}

// Generated as internal constructor for term pulley_vnarrow64x2_u.
pub fn constructor_pulley_vnarrow64x2_u<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::Vnarrow64x2U {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4081.
    return v6;
}

// Generated as internal constructor for term pulley_vunarrow64x2_u.
pub fn constructor_pulley_vunarrow64x2_u<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::Vunarrow64x2U {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4088.
    return v6;
}

// Generated as internal constructor for term pulley_vfpromotelow.
pub fn constructor_pulley_vfpromotelow<C: Context>(
    ctx: &mut C,
    arg0: VReg,
) -> VReg {
    let v1 = constructor_temp_writable_vreg(ctx);
    let v2 = RawInst::VFpromoteLow {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_vreg_to_vreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4095.
    return v5;
}

// Generated as internal constructor for term pulley_vfdemote.
pub fn constructor_pulley_vfdemote<C: Context>(
    ctx: &mut C,
    arg0: VReg,
) -> VReg {
    let v1 = constructor_temp_writable_vreg(ctx);
    let v2 = RawInst::VFdemote {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_vreg_to_vreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4102.
    return v5;
}

// Generated as internal constructor for term pulley_vsubi8x16.
pub fn constructor_pulley_vsubi8x16<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::VSubI8x16 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4109.
    return v6;
}

// Generated as internal constructor for term pulley_vsubi16x8.
pub fn constructor_pulley_vsubi16x8<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::VSubI16x8 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4116.
    return v6;
}

// Generated as internal constructor for term pulley_vsubi32x4.
pub fn constructor_pulley_vsubi32x4<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::VSubI32x4 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4123.
    return v6;
}

// Generated as internal constructor for term pulley_vsubi64x2.
pub fn constructor_pulley_vsubi64x2<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::VSubI64x2 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4130.
    return v6;
}

// Generated as internal constructor for term pulley_vsubf64x2.
pub fn constructor_pulley_vsubf64x2<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::VSubF64x2 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4137.
    return v6;
}

// Generated as internal constructor for term pulley_vsubi8x16_sat.
pub fn constructor_pulley_vsubi8x16_sat<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::VSubI8x16Sat {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4144.
    return v6;
}

// Generated as internal constructor for term pulley_vsubu8x16_sat.
pub fn constructor_pulley_vsubu8x16_sat<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::VSubU8x16Sat {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4151.
    return v6;
}

// Generated as internal constructor for term pulley_vsubi16x8_sat.
pub fn constructor_pulley_vsubi16x8_sat<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::VSubI16x8Sat {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4158.
    return v6;
}

// Generated as internal constructor for term pulley_vsubu16x8_sat.
pub fn constructor_pulley_vsubu16x8_sat<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::VSubU16x8Sat {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4165.
    return v6;
}

// Generated as internal constructor for term pulley_vmuli8x16.
pub fn constructor_pulley_vmuli8x16<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::VMulI8x16 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4172.
    return v6;
}

// Generated as internal constructor for term pulley_vmuli16x8.
pub fn constructor_pulley_vmuli16x8<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::VMulI16x8 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4179.
    return v6;
}

// Generated as internal constructor for term pulley_vmuli32x4.
pub fn constructor_pulley_vmuli32x4<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::VMulI32x4 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4186.
    return v6;
}

// Generated as internal constructor for term pulley_vmuli64x2.
pub fn constructor_pulley_vmuli64x2<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::VMulI64x2 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4193.
    return v6;
}

// Generated as internal constructor for term pulley_vmulf64x2.
pub fn constructor_pulley_vmulf64x2<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::VMulF64x2 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4200.
    return v6;
}

// Generated as internal constructor for term pulley_vqmulrsi16x8.
pub fn constructor_pulley_vqmulrsi16x8<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::VQmulrsI16x8 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4207.
    return v6;
}

// Generated as internal constructor for term pulley_vpopcnt8x16.
pub fn constructor_pulley_vpopcnt8x16<C: Context>(
    ctx: &mut C,
    arg0: VReg,
) -> VReg {
    let v1 = constructor_temp_writable_vreg(ctx);
    let v2 = RawInst::VPopcnt8x16 {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_vreg_to_vreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4214.
    return v5;
}

// Generated as internal constructor for term pulley_xextractv8x16.
pub fn constructor_pulley_xextractv8x16<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: u8,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::XExtractV8x16 {
        dst: v2,
        src: arg0,
        lane: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4221.
    return v6;
}

// Generated as internal constructor for term pulley_xextractv16x8.
pub fn constructor_pulley_xextractv16x8<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: u8,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::XExtractV16x8 {
        dst: v2,
        src: arg0,
        lane: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4228.
    return v6;
}

// Generated as internal constructor for term pulley_xextractv32x4.
pub fn constructor_pulley_xextractv32x4<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: u8,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::XExtractV32x4 {
        dst: v2,
        src: arg0,
        lane: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4235.
    return v6;
}

// Generated as internal constructor for term pulley_xextractv64x2.
pub fn constructor_pulley_xextractv64x2<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: u8,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::XExtractV64x2 {
        dst: v2,
        src: arg0,
        lane: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4242.
    return v6;
}

// Generated as internal constructor for term pulley_fextractv32x4.
pub fn constructor_pulley_fextractv32x4<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: u8,
) -> FReg {
    let v2 = constructor_temp_writable_freg(ctx);
    let v3 = RawInst::FExtractV32x4 {
        dst: v2,
        src: arg0,
        lane: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_freg_to_freg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4249.
    return v6;
}

// Generated as internal constructor for term pulley_fextractv64x2.
pub fn constructor_pulley_fextractv64x2<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: u8,
) -> FReg {
    let v2 = constructor_temp_writable_freg(ctx);
    let v3 = RawInst::FExtractV64x2 {
        dst: v2,
        src: arg0,
        lane: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_freg_to_freg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4256.
    return v6;
}

// Generated as internal constructor for term pulley_vinsertx8.
pub fn constructor_pulley_vinsertx8<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: XReg,
    arg2: u8,
) -> VReg {
    let v3 = constructor_temp_writable_vreg(ctx);
    let v4 = RawInst::VInsertX8 {
        dst: v3,
        src1: arg0,
        src2: arg1,
        lane: arg2,
    };
    let v5 = &constructor_raw_inst_to_inst(ctx, &v4);
    let v6 = C::emit(ctx, v5);
    let v7 = C::writable_vreg_to_vreg(ctx, v3);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4263.
    return v7;
}

// Generated as internal constructor for term pulley_vinsertx16.
pub fn constructor_pulley_vinsertx16<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: XReg,
    arg2: u8,
) -> VReg {
    let v3 = constructor_temp_writable_vreg(ctx);
    let v4 = RawInst::VInsertX16 {
        dst: v3,
        src1: arg0,
        src2: arg1,
        lane: arg2,
    };
    let v5 = &constructor_raw_inst_to_inst(ctx, &v4);
    let v6 = C::emit(ctx, v5);
    let v7 = C::writable_vreg_to_vreg(ctx, v3);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4270.
    return v7;
}

// Generated as internal constructor for term pulley_vinsertx32.
pub fn constructor_pulley_vinsertx32<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: XReg,
    arg2: u8,
) -> VReg {
    let v3 = constructor_temp_writable_vreg(ctx);
    let v4 = RawInst::VInsertX32 {
        dst: v3,
        src1: arg0,
        src2: arg1,
        lane: arg2,
    };
    let v5 = &constructor_raw_inst_to_inst(ctx, &v4);
    let v6 = C::emit(ctx, v5);
    let v7 = C::writable_vreg_to_vreg(ctx, v3);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4277.
    return v7;
}

// Generated as internal constructor for term pulley_vinsertx64.
pub fn constructor_pulley_vinsertx64<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: XReg,
    arg2: u8,
) -> VReg {
    let v3 = constructor_temp_writable_vreg(ctx);
    let v4 = RawInst::VInsertX64 {
        dst: v3,
        src1: arg0,
        src2: arg1,
        lane: arg2,
    };
    let v5 = &constructor_raw_inst_to_inst(ctx, &v4);
    let v6 = C::emit(ctx, v5);
    let v7 = C::writable_vreg_to_vreg(ctx, v3);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4284.
    return v7;
}

// Generated as internal constructor for term pulley_vinsertf32.
pub fn constructor_pulley_vinsertf32<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: FReg,
    arg2: u8,
) -> VReg {
    let v3 = constructor_temp_writable_vreg(ctx);
    let v4 = RawInst::VInsertF32 {
        dst: v3,
        src1: arg0,
        src2: arg1,
        lane: arg2,
    };
    let v5 = &constructor_raw_inst_to_inst(ctx, &v4);
    let v6 = C::emit(ctx, v5);
    let v7 = C::writable_vreg_to_vreg(ctx, v3);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4291.
    return v7;
}

// Generated as internal constructor for term pulley_vinsertf64.
pub fn constructor_pulley_vinsertf64<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: FReg,
    arg2: u8,
) -> VReg {
    let v3 = constructor_temp_writable_vreg(ctx);
    let v4 = RawInst::VInsertF64 {
        dst: v3,
        src1: arg0,
        src2: arg1,
        lane: arg2,
    };
    let v5 = &constructor_raw_inst_to_inst(ctx, &v4);
    let v6 = C::emit(ctx, v5);
    let v7 = C::writable_vreg_to_vreg(ctx, v3);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4298.
    return v7;
}

// Generated as internal constructor for term pulley_veq8x16.
pub fn constructor_pulley_veq8x16<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::Veq8x16 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4305.
    return v6;
}

// Generated as internal constructor for term pulley_vneq8x16.
pub fn constructor_pulley_vneq8x16<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::Vneq8x16 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4312.
    return v6;
}

// Generated as internal constructor for term pulley_vslt8x16.
pub fn constructor_pulley_vslt8x16<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::Vslt8x16 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4319.
    return v6;
}

// Generated as internal constructor for term pulley_vslteq8x16.
pub fn constructor_pulley_vslteq8x16<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::Vslteq8x16 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4326.
    return v6;
}

// Generated as internal constructor for term pulley_vult8x16.
pub fn constructor_pulley_vult8x16<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::Vult8x16 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4333.
    return v6;
}

// Generated as internal constructor for term pulley_vulteq8x16.
pub fn constructor_pulley_vulteq8x16<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::Vulteq8x16 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4340.
    return v6;
}

// Generated as internal constructor for term pulley_veq16x8.
pub fn constructor_pulley_veq16x8<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::Veq16x8 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4347.
    return v6;
}

// Generated as internal constructor for term pulley_vneq16x8.
pub fn constructor_pulley_vneq16x8<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::Vneq16x8 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4354.
    return v6;
}

// Generated as internal constructor for term pulley_vslt16x8.
pub fn constructor_pulley_vslt16x8<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::Vslt16x8 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4361.
    return v6;
}

// Generated as internal constructor for term pulley_vslteq16x8.
pub fn constructor_pulley_vslteq16x8<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::Vslteq16x8 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4368.
    return v6;
}

// Generated as internal constructor for term pulley_vult16x8.
pub fn constructor_pulley_vult16x8<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::Vult16x8 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4375.
    return v6;
}

// Generated as internal constructor for term pulley_vulteq16x8.
pub fn constructor_pulley_vulteq16x8<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::Vulteq16x8 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4382.
    return v6;
}

// Generated as internal constructor for term pulley_veq32x4.
pub fn constructor_pulley_veq32x4<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::Veq32x4 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4389.
    return v6;
}

// Generated as internal constructor for term pulley_vneq32x4.
pub fn constructor_pulley_vneq32x4<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::Vneq32x4 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4396.
    return v6;
}

// Generated as internal constructor for term pulley_vslt32x4.
pub fn constructor_pulley_vslt32x4<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::Vslt32x4 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4403.
    return v6;
}

// Generated as internal constructor for term pulley_vslteq32x4.
pub fn constructor_pulley_vslteq32x4<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::Vslteq32x4 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4410.
    return v6;
}

// Generated as internal constructor for term pulley_vult32x4.
pub fn constructor_pulley_vult32x4<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::Vult32x4 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4417.
    return v6;
}

// Generated as internal constructor for term pulley_vulteq32x4.
pub fn constructor_pulley_vulteq32x4<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::Vulteq32x4 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4424.
    return v6;
}

// Generated as internal constructor for term pulley_veq64x2.
pub fn constructor_pulley_veq64x2<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::Veq64x2 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4431.
    return v6;
}

// Generated as internal constructor for term pulley_vneq64x2.
pub fn constructor_pulley_vneq64x2<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::Vneq64x2 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4438.
    return v6;
}

// Generated as internal constructor for term pulley_vslt64x2.
pub fn constructor_pulley_vslt64x2<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::Vslt64x2 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4445.
    return v6;
}

// Generated as internal constructor for term pulley_vslteq64x2.
pub fn constructor_pulley_vslteq64x2<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::Vslteq64x2 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4452.
    return v6;
}

// Generated as internal constructor for term pulley_vult64x2.
pub fn constructor_pulley_vult64x2<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::Vult64x2 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4459.
    return v6;
}

// Generated as internal constructor for term pulley_vulteq64x2.
pub fn constructor_pulley_vulteq64x2<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::Vulteq64x2 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4466.
    return v6;
}

// Generated as internal constructor for term pulley_vneg8x16.
pub fn constructor_pulley_vneg8x16<C: Context>(
    ctx: &mut C,
    arg0: VReg,
) -> VReg {
    let v1 = constructor_temp_writable_vreg(ctx);
    let v2 = RawInst::Vneg8x16 {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_vreg_to_vreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4473.
    return v5;
}

// Generated as internal constructor for term pulley_vneg16x8.
pub fn constructor_pulley_vneg16x8<C: Context>(
    ctx: &mut C,
    arg0: VReg,
) -> VReg {
    let v1 = constructor_temp_writable_vreg(ctx);
    let v2 = RawInst::Vneg16x8 {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_vreg_to_vreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4480.
    return v5;
}

// Generated as internal constructor for term pulley_vneg32x4.
pub fn constructor_pulley_vneg32x4<C: Context>(
    ctx: &mut C,
    arg0: VReg,
) -> VReg {
    let v1 = constructor_temp_writable_vreg(ctx);
    let v2 = RawInst::Vneg32x4 {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_vreg_to_vreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4487.
    return v5;
}

// Generated as internal constructor for term pulley_vneg64x2.
pub fn constructor_pulley_vneg64x2<C: Context>(
    ctx: &mut C,
    arg0: VReg,
) -> VReg {
    let v1 = constructor_temp_writable_vreg(ctx);
    let v2 = RawInst::Vneg64x2 {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_vreg_to_vreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4494.
    return v5;
}

// Generated as internal constructor for term pulley_vnegf64x2.
pub fn constructor_pulley_vnegf64x2<C: Context>(
    ctx: &mut C,
    arg0: VReg,
) -> VReg {
    let v1 = constructor_temp_writable_vreg(ctx);
    let v2 = RawInst::VnegF64x2 {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_vreg_to_vreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4501.
    return v5;
}

// Generated as internal constructor for term pulley_vmin8x16_s.
pub fn constructor_pulley_vmin8x16_s<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::Vmin8x16S {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4508.
    return v6;
}

// Generated as internal constructor for term pulley_vmin8x16_u.
pub fn constructor_pulley_vmin8x16_u<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::Vmin8x16U {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4515.
    return v6;
}

// Generated as internal constructor for term pulley_vmin16x8_s.
pub fn constructor_pulley_vmin16x8_s<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::Vmin16x8S {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4522.
    return v6;
}

// Generated as internal constructor for term pulley_vmin16x8_u.
pub fn constructor_pulley_vmin16x8_u<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::Vmin16x8U {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4529.
    return v6;
}

// Generated as internal constructor for term pulley_vmax8x16_s.
pub fn constructor_pulley_vmax8x16_s<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::Vmax8x16S {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4536.
    return v6;
}

// Generated as internal constructor for term pulley_vmax8x16_u.
pub fn constructor_pulley_vmax8x16_u<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::Vmax8x16U {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4543.
    return v6;
}

// Generated as internal constructor for term pulley_vmax16x8_s.
pub fn constructor_pulley_vmax16x8_s<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::Vmax16x8S {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4550.
    return v6;
}

// Generated as internal constructor for term pulley_vmax16x8_u.
pub fn constructor_pulley_vmax16x8_u<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::Vmax16x8U {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4557.
    return v6;
}

// Generated as internal constructor for term pulley_vmin32x4_s.
pub fn constructor_pulley_vmin32x4_s<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::Vmin32x4S {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4564.
    return v6;
}

// Generated as internal constructor for term pulley_vmin32x4_u.
pub fn constructor_pulley_vmin32x4_u<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::Vmin32x4U {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4571.
    return v6;
}

// Generated as internal constructor for term pulley_vmax32x4_s.
pub fn constructor_pulley_vmax32x4_s<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::Vmax32x4S {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4578.
    return v6;
}

// Generated as internal constructor for term pulley_vmax32x4_u.
pub fn constructor_pulley_vmax32x4_u<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::Vmax32x4U {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4585.
    return v6;
}

// Generated as internal constructor for term pulley_vabs8x16.
pub fn constructor_pulley_vabs8x16<C: Context>(
    ctx: &mut C,
    arg0: VReg,
) -> VReg {
    let v1 = constructor_temp_writable_vreg(ctx);
    let v2 = RawInst::Vabs8x16 {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_vreg_to_vreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4592.
    return v5;
}

// Generated as internal constructor for term pulley_vabs16x8.
pub fn constructor_pulley_vabs16x8<C: Context>(
    ctx: &mut C,
    arg0: VReg,
) -> VReg {
    let v1 = constructor_temp_writable_vreg(ctx);
    let v2 = RawInst::Vabs16x8 {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_vreg_to_vreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4599.
    return v5;
}

// Generated as internal constructor for term pulley_vabs32x4.
pub fn constructor_pulley_vabs32x4<C: Context>(
    ctx: &mut C,
    arg0: VReg,
) -> VReg {
    let v1 = constructor_temp_writable_vreg(ctx);
    let v2 = RawInst::Vabs32x4 {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_vreg_to_vreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4606.
    return v5;
}

// Generated as internal constructor for term pulley_vabs64x2.
pub fn constructor_pulley_vabs64x2<C: Context>(
    ctx: &mut C,
    arg0: VReg,
) -> VReg {
    let v1 = constructor_temp_writable_vreg(ctx);
    let v2 = RawInst::Vabs64x2 {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_vreg_to_vreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4613.
    return v5;
}

// Generated as internal constructor for term pulley_vabsf32x4.
pub fn constructor_pulley_vabsf32x4<C: Context>(
    ctx: &mut C,
    arg0: VReg,
) -> VReg {
    let v1 = constructor_temp_writable_vreg(ctx);
    let v2 = RawInst::Vabsf32x4 {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_vreg_to_vreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4620.
    return v5;
}

// Generated as internal constructor for term pulley_vabsf64x2.
pub fn constructor_pulley_vabsf64x2<C: Context>(
    ctx: &mut C,
    arg0: VReg,
) -> VReg {
    let v1 = constructor_temp_writable_vreg(ctx);
    let v2 = RawInst::Vabsf64x2 {
        dst: v1,
        src: arg0,
    };
    let v3 = &constructor_raw_inst_to_inst(ctx, &v2);
    let v4 = C::emit(ctx, v3);
    let v5 = C::writable_vreg_to_vreg(ctx, v1);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4627.
    return v5;
}

// Generated as internal constructor for term pulley_vmaximumf32x4.
pub fn constructor_pulley_vmaximumf32x4<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::Vmaximumf32x4 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4634.
    return v6;
}

// Generated as internal constructor for term pulley_vmaximumf64x2.
pub fn constructor_pulley_vmaximumf64x2<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::Vmaximumf64x2 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4641.
    return v6;
}

// Generated as internal constructor for term pulley_vminimumf32x4.
pub fn constructor_pulley_vminimumf32x4<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::Vminimumf32x4 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4648.
    return v6;
}

// Generated as internal constructor for term pulley_vminimumf64x2.
pub fn constructor_pulley_vminimumf64x2<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::Vminimumf64x2 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4655.
    return v6;
}

// Generated as internal constructor for term pulley_vshuffle.
pub fn constructor_pulley_vshuffle<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
    arg2: u128,
) -> VReg {
    let v3 = constructor_temp_writable_vreg(ctx);
    let v4 = RawInst::VShuffle {
        dst: v3,
        src1: arg0,
        src2: arg1,
        mask: arg2,
    };
    let v5 = &constructor_raw_inst_to_inst(ctx, &v4);
    let v6 = C::emit(ctx, v5);
    let v7 = C::writable_vreg_to_vreg(ctx, v3);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4662.
    return v7;
}

// Generated as internal constructor for term pulley_vswizzlei8x16.
pub fn constructor_pulley_vswizzlei8x16<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::Vswizzlei8x16 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4669.
    return v6;
}

// Generated as internal constructor for term pulley_vavground8x16.
pub fn constructor_pulley_vavground8x16<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::Vavground8x16 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4676.
    return v6;
}

// Generated as internal constructor for term pulley_vavground16x8.
pub fn constructor_pulley_vavground16x8<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::Vavground16x8 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4683.
    return v6;
}

// Generated as internal constructor for term pulley_veqf32x4.
pub fn constructor_pulley_veqf32x4<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::VeqF32x4 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4690.
    return v6;
}

// Generated as internal constructor for term pulley_vneqf32x4.
pub fn constructor_pulley_vneqf32x4<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::VneqF32x4 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4697.
    return v6;
}

// Generated as internal constructor for term pulley_vltf32x4.
pub fn constructor_pulley_vltf32x4<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::VltF32x4 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4704.
    return v6;
}

// Generated as internal constructor for term pulley_vlteqf32x4.
pub fn constructor_pulley_vlteqf32x4<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::VlteqF32x4 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4711.
    return v6;
}

// Generated as internal constructor for term pulley_veqf64x2.
pub fn constructor_pulley_veqf64x2<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::VeqF64x2 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4718.
    return v6;
}

// Generated as internal constructor for term pulley_vneqf64x2.
pub fn constructor_pulley_vneqf64x2<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::VneqF64x2 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4725.
    return v6;
}

// Generated as internal constructor for term pulley_vltf64x2.
pub fn constructor_pulley_vltf64x2<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::VltF64x2 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4732.
    return v6;
}

// Generated as internal constructor for term pulley_vlteqf64x2.
pub fn constructor_pulley_vlteqf64x2<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::VlteqF64x2 {
        dst: v2,
        src1: arg0,
        src2: arg1,
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4739.
    return v6;
}

// Generated as internal constructor for term pulley_vfma32x4.
pub fn constructor_pulley_vfma32x4<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
    arg2: VReg,
) -> VReg {
    let v3 = constructor_temp_writable_vreg(ctx);
    let v4 = RawInst::Vfma32x4 {
        dst: v3,
        a: arg0,
        b: arg1,
        c: arg2,
    };
    let v5 = &constructor_raw_inst_to_inst(ctx, &v4);
    let v6 = C::emit(ctx, v5);
    let v7 = C::writable_vreg_to_vreg(ctx, v3);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4746.
    return v7;
}

// Generated as internal constructor for term pulley_vfma64x2.
pub fn constructor_pulley_vfma64x2<C: Context>(
    ctx: &mut C,
    arg0: VReg,
    arg1: VReg,
    arg2: VReg,
) -> VReg {
    let v3 = constructor_temp_writable_vreg(ctx);
    let v4 = RawInst::Vfma64x2 {
        dst: v3,
        a: arg0,
        b: arg1,
        c: arg2,
    };
    let v5 = &constructor_raw_inst_to_inst(ctx, &v4);
    let v6 = C::emit(ctx, v5);
    let v7 = C::writable_vreg_to_vreg(ctx, v3);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4753.
    return v7;
}

// Generated as internal constructor for term pulley_vselect.
pub fn constructor_pulley_vselect<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: VReg,
    arg2: VReg,
) -> VReg {
    let v3 = constructor_temp_writable_vreg(ctx);
    let v4 = RawInst::Vselect {
        dst: v3,
        cond: arg0,
        if_nonzero: arg1,
        if_zero: arg2,
    };
    let v5 = &constructor_raw_inst_to_inst(ctx, &v4);
    let v6 = C::emit(ctx, v5);
    let v7 = C::writable_vreg_to_vreg(ctx, v3);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4760.
    return v7;
}

// Generated as internal constructor for term pulley_xadd128.
pub fn constructor_pulley_xadd128<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: XReg,
    arg2: XReg,
    arg3: XReg,
) -> ValueRegs {
    let v4 = constructor_temp_writable_xreg(ctx);
    let v5 = constructor_temp_writable_xreg(ctx);
    let v6 = RawInst::Xadd128 {
        dst_lo: v4,
        dst_hi: v5,
        lhs_lo: arg0,
        lhs_hi: arg1,
        rhs_lo: arg2,
        rhs_hi: arg3,
    };
    let v7 = &constructor_raw_inst_to_inst(ctx, &v6);
    let v8 = C::emit(ctx, v7);
    let v9 = constructor_writable_xreg_to_reg(ctx, v4);
    let v10 = constructor_writable_xreg_to_reg(ctx, v5);
    let v11 = C::value_regs(ctx, v9, v10);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4767.
    return v11;
}

// Generated as internal constructor for term pulley_xsub128.
pub fn constructor_pulley_xsub128<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: XReg,
    arg2: XReg,
    arg3: XReg,
) -> ValueRegs {
    let v4 = constructor_temp_writable_xreg(ctx);
    let v5 = constructor_temp_writable_xreg(ctx);
    let v6 = RawInst::Xsub128 {
        dst_lo: v4,
        dst_hi: v5,
        lhs_lo: arg0,
        lhs_hi: arg1,
        rhs_lo: arg2,
        rhs_hi: arg3,
    };
    let v7 = &constructor_raw_inst_to_inst(ctx, &v6);
    let v8 = C::emit(ctx, v7);
    let v9 = constructor_writable_xreg_to_reg(ctx, v4);
    let v10 = constructor_writable_xreg_to_reg(ctx, v5);
    let v11 = C::value_regs(ctx, v9, v10);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4775.
    return v11;
}

// Generated as internal constructor for term pulley_xwidemul64_s.
pub fn constructor_pulley_xwidemul64_s<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: XReg,
) -> ValueRegs {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = constructor_temp_writable_xreg(ctx);
    let v4 = RawInst::Xwidemul64S {
        dst_lo: v2,
        dst_hi: v3,
        lhs: arg0,
        rhs: arg1,
    };
    let v5 = &constructor_raw_inst_to_inst(ctx, &v4);
    let v6 = C::emit(ctx, v5);
    let v7 = constructor_writable_xreg_to_reg(ctx, v2);
    let v8 = constructor_writable_xreg_to_reg(ctx, v3);
    let v9 = C::value_regs(ctx, v7, v8);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4783.
    return v9;
}

// Generated as internal constructor for term pulley_xwidemul64_u.
pub fn constructor_pulley_xwidemul64_u<C: Context>(
    ctx: &mut C,
    arg0: XReg,
    arg1: XReg,
) -> ValueRegs {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = constructor_temp_writable_xreg(ctx);
    let v4 = RawInst::Xwidemul64U {
        dst_lo: v2,
        dst_hi: v3,
        lhs: arg0,
        rhs: arg1,
    };
    let v5 = &constructor_raw_inst_to_inst(ctx, &v4);
    let v6 = C::emit(ctx, v5);
    let v7 = constructor_writable_xreg_to_reg(ctx, v2);
    let v8 = constructor_writable_xreg_to_reg(ctx, v3);
    let v9 = C::value_regs(ctx, v7, v8);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4791.
    return v9;
}

// Generated as internal constructor for term pulley_xload16be_u32_z.
pub fn constructor_pulley_xload16be_u32_z<C: Context>(
    ctx: &mut C,
    arg0: &AddrZ,
    arg1: &TrapCode,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::XLoad16BeU32Z {
        dst: v2,
        addr: arg0.clone(),
        code: arg1.clone(),
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4799.
    return v6;
}

// Generated as internal constructor for term pulley_xload16be_s32_z.
pub fn constructor_pulley_xload16be_s32_z<C: Context>(
    ctx: &mut C,
    arg0: &AddrZ,
    arg1: &TrapCode,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::XLoad16BeS32Z {
        dst: v2,
        addr: arg0.clone(),
        code: arg1.clone(),
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4806.
    return v6;
}

// Generated as internal constructor for term pulley_xload32be_z.
pub fn constructor_pulley_xload32be_z<C: Context>(
    ctx: &mut C,
    arg0: &AddrZ,
    arg1: &TrapCode,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::XLoad32BeZ {
        dst: v2,
        addr: arg0.clone(),
        code: arg1.clone(),
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4813.
    return v6;
}

// Generated as internal constructor for term pulley_xload64be_z.
pub fn constructor_pulley_xload64be_z<C: Context>(
    ctx: &mut C,
    arg0: &AddrZ,
    arg1: &TrapCode,
) -> XReg {
    let v2 = constructor_temp_writable_xreg(ctx);
    let v3 = RawInst::XLoad64BeZ {
        dst: v2,
        addr: arg0.clone(),
        code: arg1.clone(),
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_xreg_to_xreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4820.
    return v6;
}

// Generated as internal constructor for term pulley_xstore16be_z.
pub fn constructor_pulley_xstore16be_z<C: Context>(
    ctx: &mut C,
    arg0: &AddrZ,
    arg1: XReg,
    arg2: &TrapCode,
) -> SideEffectNoResult {
    let v3 = RawInst::XStore16BeZ {
        addr: arg0.clone(),
        src: arg1,
        code: arg2.clone(),
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = SideEffectNoResult::Inst {
        inst: v4.clone(),
    };
    // Rule at <OUT_DIR>/pulley_gen.isle line 4827.
    return v5;
}

// Generated as internal constructor for term pulley_xstore32be_z.
pub fn constructor_pulley_xstore32be_z<C: Context>(
    ctx: &mut C,
    arg0: &AddrZ,
    arg1: XReg,
    arg2: &TrapCode,
) -> SideEffectNoResult {
    let v3 = RawInst::XStore32BeZ {
        addr: arg0.clone(),
        src: arg1,
        code: arg2.clone(),
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = SideEffectNoResult::Inst {
        inst: v4.clone(),
    };
    // Rule at <OUT_DIR>/pulley_gen.isle line 4829.
    return v5;
}

// Generated as internal constructor for term pulley_xstore64be_z.
pub fn constructor_pulley_xstore64be_z<C: Context>(
    ctx: &mut C,
    arg0: &AddrZ,
    arg1: XReg,
    arg2: &TrapCode,
) -> SideEffectNoResult {
    let v3 = RawInst::XStore64BeZ {
        addr: arg0.clone(),
        src: arg1,
        code: arg2.clone(),
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = SideEffectNoResult::Inst {
        inst: v4.clone(),
    };
    // Rule at <OUT_DIR>/pulley_gen.isle line 4831.
    return v5;
}

// Generated as internal constructor for term pulley_fload32be_z.
pub fn constructor_pulley_fload32be_z<C: Context>(
    ctx: &mut C,
    arg0: &AddrZ,
    arg1: &TrapCode,
) -> FReg {
    let v2 = constructor_temp_writable_freg(ctx);
    let v3 = RawInst::Fload32BeZ {
        dst: v2,
        addr: arg0.clone(),
        code: arg1.clone(),
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_freg_to_freg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4833.
    return v6;
}

// Generated as internal constructor for term pulley_fload64be_z.
pub fn constructor_pulley_fload64be_z<C: Context>(
    ctx: &mut C,
    arg0: &AddrZ,
    arg1: &TrapCode,
) -> FReg {
    let v2 = constructor_temp_writable_freg(ctx);
    let v3 = RawInst::Fload64BeZ {
        dst: v2,
        addr: arg0.clone(),
        code: arg1.clone(),
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_freg_to_freg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4840.
    return v6;
}

// Generated as internal constructor for term pulley_fstore32be_z.
pub fn constructor_pulley_fstore32be_z<C: Context>(
    ctx: &mut C,
    arg0: &AddrZ,
    arg1: FReg,
    arg2: &TrapCode,
) -> SideEffectNoResult {
    let v3 = RawInst::Fstore32BeZ {
        addr: arg0.clone(),
        src: arg1,
        code: arg2.clone(),
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = SideEffectNoResult::Inst {
        inst: v4.clone(),
    };
    // Rule at <OUT_DIR>/pulley_gen.isle line 4847.
    return v5;
}

// Generated as internal constructor for term pulley_fstore64be_z.
pub fn constructor_pulley_fstore64be_z<C: Context>(
    ctx: &mut C,
    arg0: &AddrZ,
    arg1: FReg,
    arg2: &TrapCode,
) -> SideEffectNoResult {
    let v3 = RawInst::Fstore64BeZ {
        addr: arg0.clone(),
        src: arg1,
        code: arg2.clone(),
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = SideEffectNoResult::Inst {
        inst: v4.clone(),
    };
    // Rule at <OUT_DIR>/pulley_gen.isle line 4849.
    return v5;
}

// Generated as internal constructor for term pulley_vload128be_z.
pub fn constructor_pulley_vload128be_z<C: Context>(
    ctx: &mut C,
    arg0: &AddrZ,
    arg1: &TrapCode,
) -> VReg {
    let v2 = constructor_temp_writable_vreg(ctx);
    let v3 = RawInst::VLoad128BeZ {
        dst: v2,
        addr: arg0.clone(),
        code: arg1.clone(),
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_vreg_to_vreg(ctx, v2);
    // Rule at <OUT_DIR>/pulley_gen.isle line 4851.
    return v6;
}

// Generated as internal constructor for term pulley_vstore128be_z.
pub fn constructor_pulley_vstore128be_z<C: Context>(
    ctx: &mut C,
    arg0: &AddrZ,
    arg1: VReg,
    arg2: &TrapCode,
) -> SideEffectNoResult {
    let v3 = RawInst::Vstore128BeZ {
        addr: arg0.clone(),
        src: arg1,
        code: arg2.clone(),
    };
    let v4 = &constructor_raw_inst_to_inst(ctx, &v3);
    let v5 = SideEffectNoResult::Inst {
        inst: v4.clone(),
    };
    // Rule at <OUT_DIR>/pulley_gen.isle line 4858.
    return v5;
}
