// GENERATED BY ISLE. DO NOT EDIT!
//
// Generated automatically from the instruction-selection DSL code in:
// - src/prelude.isle
// - src/prelude_lower.isle
// - src/isa/x64/inst.isle
// - src/isa/x64/lower.isle
// - <OUT_DIR>/numerics.isle
// - <OUT_DIR>/clif_lower.isle
// - <OUT_DIR>/assembler.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_srem(&mut self, arg0: Type, arg1: Imm64, arg2: Imm64) -> Option<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 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<u64>;
    fn u32_replicated_u16(&mut self, arg0: u64) -> Option<u64>;
    fn u16_replicated_u8(&mut self, arg0: u64) -> 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 little_or_native_endian(&mut self, arg0: MemFlags) -> Option<MemFlags>;
    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_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 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 ensure_in_vreg(&mut self, arg0: Reg, arg1: Type) -> Reg;
    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 add_range_fact(&mut self, arg0: Reg, arg1: u16, arg2: u64, arg3: u64) -> 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) -> 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 box_synthetic_amode(&mut self, arg0: &SyntheticAmode) -> BoxSyntheticAmode;
    fn operand_size_of_type_32_64(&mut self, arg0: Type) -> OperandSize;
    fn raw_operand_size_of_type(&mut self, arg0: Type) -> OperandSize;
    fn put_in_reg_mem_imm(&mut self, arg0: Value) -> RegMemImm;
    fn put_in_reg_mem(&mut self, arg0: Value) -> RegMem;
    fn synthetic_amode_to_reg_mem(&mut self, arg0: &SyntheticAmode) -> RegMem;
    fn amode_to_synthetic_amode(&mut self, arg0: &Amode) -> SyntheticAmode;
    fn synthetic_amode_slot(&mut self, arg0: i32) -> SyntheticAmode;
    fn sum_extend_fits_in_32_bits(&mut self, arg0: Type, arg1: Imm64, arg2: Offset32) -> Option<u32>;
    fn amode_offset(&mut self, arg0: &SyntheticAmode, arg1: i32) -> SyntheticAmode;
    fn zero_offset(&mut self, ) -> Offset32;
    fn intcc_to_cc(&mut self, arg0: &IntCC) -> CC;
    fn cc_invert(&mut self, arg0: &CC) -> CC;
    fn cc_nz_or_z(&mut self, arg0: &CC) -> Option<CC>;
    fn encode_fcmp_imm(&mut self, arg0: &FcmpImm) -> u8;
    fn encode_round_imm(&mut self, arg0: &RoundImm) -> u8;
    fn writable_gpr_to_reg(&mut self, arg0: WritableGpr) -> WritableReg;
    fn writable_xmm_to_reg(&mut self, arg0: WritableXmm) -> WritableReg;
    fn writable_reg_to_xmm(&mut self, arg0: WritableReg) -> WritableXmm;
    fn writable_xmm_to_xmm(&mut self, arg0: WritableXmm) -> Xmm;
    fn writable_gpr_to_gpr(&mut self, arg0: WritableGpr) -> Gpr;
    fn gpr_to_reg(&mut self, arg0: Gpr) -> Reg;
    fn gpr_to_gpr_mem(&mut self, arg0: Gpr) -> GprMem;
    fn gpr_to_gpr_mem_imm(&mut self, arg0: Gpr) -> GprMemImm;
    fn xmm_to_reg(&mut self, arg0: Xmm) -> Reg;
    fn xmm_to_xmm_mem_imm(&mut self, arg0: Xmm) -> XmmMemImm;
    fn xmm_mem_to_xmm_mem_imm(&mut self, arg0: &XmmMem) -> XmmMemImm;
    fn xmm_mem_to_xmm_mem_aligned(&mut self, arg0: &XmmMem) -> XmmMemAligned;
    fn xmm_mem_imm_to_xmm_mem_aligned_imm(&mut self, arg0: &XmmMemImm) -> XmmMemAlignedImm;
    fn temp_writable_gpr(&mut self, ) -> WritableGpr;
    fn temp_writable_xmm(&mut self, ) -> WritableXmm;
    fn reg_mem_to_xmm_mem(&mut self, arg0: &RegMem) -> XmmMem;
    fn reg_to_reg_mem_imm(&mut self, arg0: Reg) -> RegMemImm;
    fn gpr_mem_imm_new(&mut self, arg0: &RegMemImm) -> GprMemImm;
    fn xmm_mem_imm_new(&mut self, arg0: &RegMemImm) -> XmmMemImm;
    fn xmm_to_xmm_mem(&mut self, arg0: Xmm) -> XmmMem;
    fn xmm_mem_to_reg_mem(&mut self, arg0: &XmmMem) -> RegMem;
    fn gpr_mem_to_reg_mem(&mut self, arg0: &GprMem) -> RegMem;
    fn xmm_new(&mut self, arg0: Reg) -> Xmm;
    fn gpr_new(&mut self, arg0: Reg) -> Gpr;
    fn reg_mem_to_gpr_mem(&mut self, arg0: &RegMem) -> GprMem;
    fn reg_to_gpr_mem(&mut self, arg0: Reg) -> GprMem;
    fn put_in_xmm_mem(&mut self, arg0: Value) -> XmmMem;
    fn put_in_xmm_mem_imm(&mut self, arg0: Value) -> XmmMemImm;
    fn xmi_imm(&mut self, arg0: u32) -> XmmMemImm;
    fn type_register_class(&mut self, arg0: Type) -> Option<RegisterClass>;
    fn is_imm8(&mut self, arg0: &GprMemImm) -> Option<u8>;
    fn is_imm8_xmm(&mut self, arg0: &XmmMemImm) -> Option<u8>;
    fn is_simm8(&mut self, arg0: &GprMemImm) -> Option<i8>;
    fn is_imm16(&mut self, arg0: &GprMemImm) -> Option<u16>;
    fn is_simm16(&mut self, arg0: &GprMemImm) -> Option<i16>;
    fn is_imm32(&mut self, arg0: &GprMemImm) -> Option<u32>;
    fn is_simm32(&mut self, arg0: &GprMemImm) -> Option<i32>;
    fn is_gpr(&mut self, arg0: &GprMemImm) -> Option<Gpr>;
    fn is_gpr_mem(&mut self, arg0: &GprMemImm) -> Option<GprMem>;
    fn is_xmm_mem(&mut self, arg0: &XmmMemImm) -> Option<XmmMem>;
    fn is_xmm(&mut self, arg0: &XmmMem) -> Option<Xmm>;
    fn is_mem(&mut self, arg0: &XmmMem) -> Option<SyntheticAmode>;
    fn has_avx512vl(&mut self, ) -> bool;
    fn has_avx512dq(&mut self, ) -> bool;
    fn has_avx512f(&mut self, ) -> bool;
    fn has_avx512bitalg(&mut self, ) -> bool;
    fn has_avx512vbmi(&mut self, ) -> bool;
    fn has_lzcnt(&mut self, ) -> bool;
    fn has_bmi1(&mut self, ) -> bool;
    fn has_bmi2(&mut self, ) -> bool;
    fn use_popcnt(&mut self, ) -> bool;
    fn use_fma(&mut self, ) -> bool;
    fn has_sse3(&mut self, ) -> bool;
    fn has_ssse3(&mut self, ) -> bool;
    fn has_sse41(&mut self, ) -> bool;
    fn use_sse42(&mut self, ) -> bool;
    fn has_avx(&mut self, ) -> bool;
    fn use_avx2(&mut self, ) -> bool;
    fn has_cmpxchg16b(&mut self, ) -> bool;
    fn shift_mask(&mut self, arg0: Type) -> u8;
    fn shift_amount_masked(&mut self, arg0: Type, arg1: Imm64) -> u8;
    fn simm32_from_value(&mut self, arg0: Value) -> Option<GprMemImm>;
    fn sinkable_load(&mut self, arg0: Value) -> Option<SinkableLoad>;
    fn sinkable_load_exact(&mut self, arg0: Value) -> Option<SinkableLoad>;
    fn sink_load(&mut self, arg0: &SinkableLoad) -> SyntheticAmode;
    fn ext_mode(&mut self, arg0: u16, arg1: u16) -> ExtMode;
    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: &RegMem, arg2: CallArgList, arg3: CallRetList, arg4: OptionTryCallInfo) -> BoxCallIndInfo;
    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 x64_mulxl_rvm_hi(&mut self, arg0: &GprMem, arg1: Gpr) -> Gpr;
    fn x64_mulxq_rvm_hi(&mut self, arg0: &GprMem, arg1: Gpr) -> Gpr;
    fn writable_invalid_gpr(&mut self, ) -> WritableGpr;
    fn bt_imm(&mut self, arg0: u64) -> Option<u8>;
    fn ty_int_bool_or_ref(&mut self, arg0: Type) -> Option<()>;
    fn shuffle_0_31_mask(&mut self, arg0: &VecMask) -> VCodeConstant;
    fn shuffle_0_15_mask(&mut self, arg0: &VecMask) -> VCodeConstant;
    fn shuffle_16_31_mask(&mut self, arg0: &VecMask) -> VCodeConstant;
    fn perm_from_mask(&mut self, arg0: &VecMask) -> VCodeConstant;
    fn perm_from_mask_with_zeros(&mut self, arg0: &VecMask) -> Option<(VCodeConstant, VCodeConstant)>;
    fn const_to_synthetic_amode(&mut self, arg0: VCodeConstant) -> SyntheticAmode;
    fn preg_rbp(&mut self, ) -> PReg;
    fn preg_rsp(&mut self, ) -> PReg;
    fn preg_pinned(&mut self, ) -> PReg;
    fn libcall_1(&mut self, arg0: &LibCall, arg1: Reg) -> Reg;
    fn libcall_2(&mut self, arg0: &LibCall, arg1: Reg, arg2: Reg) -> Reg;
    fn libcall_3(&mut self, arg0: &LibCall, arg1: Reg, arg2: Reg, arg3: Reg) -> Reg;
    fn ishl_i8x16_mask_for_const(&mut self, arg0: u32) -> SyntheticAmode;
    fn ishl_i8x16_mask_table(&mut self, ) -> SyntheticAmode;
    fn ushr_i8x16_mask_for_const(&mut self, arg0: u32) -> SyntheticAmode;
    fn ushr_i8x16_mask_table(&mut self, ) -> SyntheticAmode;
    fn vconst_all_ones_or_all_zeros(&mut self, arg0: Constant) -> Option<()>;
    fn insert_i8x16_lane_hole(&mut self, arg0: u8) -> VCodeConstant;
    fn sse_insertps_lane_imm(&mut self, arg0: u8) -> u8;
    fn pblendw_imm(&mut self, arg0: Immediate) -> Option<u8>;
    fn palignr_imm_from_immediate(&mut self, arg0: Immediate) -> Option<u8>;
    fn pshuflw_lhs_imm(&mut self, arg0: Immediate) -> Option<u8>;
    fn pshuflw_rhs_imm(&mut self, arg0: Immediate) -> Option<u8>;
    fn pshufhw_lhs_imm(&mut self, arg0: Immediate) -> Option<u8>;
    fn pshufhw_rhs_imm(&mut self, arg0: Immediate) -> Option<u8>;
    fn pshufd_lhs_imm(&mut self, arg0: Immediate) -> Option<u8>;
    fn pshufd_rhs_imm(&mut self, arg0: Immediate) -> Option<u8>;
    fn shufps_imm(&mut self, arg0: Immediate) -> Option<u8>;
    fn shufps_rev_imm(&mut self, arg0: Immediate) -> Option<u8>;
    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_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_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_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_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_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_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_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_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_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_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;
    fn x64_pabsb_a_raw(&mut self, arg0: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_vpabsb_a_raw(&mut self, arg0: &XmmMem) -> AssemblerOutputs;
    fn x64_pabsw_a_raw(&mut self, arg0: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_vpabsw_a_raw(&mut self, arg0: &XmmMem) -> AssemblerOutputs;
    fn x64_pabsd_a_raw(&mut self, arg0: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_vpabsd_a_raw(&mut self, arg0: &XmmMem) -> AssemblerOutputs;
    fn x64_vpabsd_c_raw(&mut self, arg0: &XmmMem) -> AssemblerOutputs;
    fn x64_vpabsq_c_raw(&mut self, arg0: &XmmMem) -> AssemblerOutputs;
    fn x64_addb_i_raw(&mut self, arg0: Gpr, arg1: u8) -> AssemblerOutputs;
    fn x64_addw_i_raw(&mut self, arg0: Gpr, arg1: u16) -> AssemblerOutputs;
    fn x64_addl_i_raw(&mut self, arg0: Gpr, arg1: u32) -> AssemblerOutputs;
    fn x64_addq_i_sxl_raw(&mut self, arg0: Gpr, arg1: i32) -> AssemblerOutputs;
    fn x64_addb_mi_raw(&mut self, arg0: &GprMem, arg1: u8) -> AssemblerOutputs;
    fn x64_addw_mi_raw(&mut self, arg0: &GprMem, arg1: u16) -> AssemblerOutputs;
    fn x64_addl_mi_raw(&mut self, arg0: &GprMem, arg1: u32) -> AssemblerOutputs;
    fn x64_addq_mi_sxl_raw(&mut self, arg0: &GprMem, arg1: i32) -> AssemblerOutputs;
    fn x64_addl_mi_sxb_raw(&mut self, arg0: &GprMem, arg1: i8) -> AssemblerOutputs;
    fn x64_addq_mi_sxb_raw(&mut self, arg0: &GprMem, arg1: i8) -> AssemblerOutputs;
    fn x64_addb_mr_raw(&mut self, arg0: &GprMem, arg1: Gpr) -> AssemblerOutputs;
    fn x64_addw_mr_raw(&mut self, arg0: &GprMem, arg1: Gpr) -> AssemblerOutputs;
    fn x64_addl_mr_raw(&mut self, arg0: &GprMem, arg1: Gpr) -> AssemblerOutputs;
    fn x64_addq_mr_raw(&mut self, arg0: &GprMem, arg1: Gpr) -> AssemblerOutputs;
    fn x64_addb_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_addw_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_addl_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_addq_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_adcb_i_raw(&mut self, arg0: Gpr, arg1: u8) -> AssemblerOutputs;
    fn x64_adcw_i_raw(&mut self, arg0: Gpr, arg1: u16) -> AssemblerOutputs;
    fn x64_adcl_i_raw(&mut self, arg0: Gpr, arg1: u32) -> AssemblerOutputs;
    fn x64_adcq_i_sxl_raw(&mut self, arg0: Gpr, arg1: i32) -> AssemblerOutputs;
    fn x64_adcb_mi_raw(&mut self, arg0: &GprMem, arg1: u8) -> AssemblerOutputs;
    fn x64_adcw_mi_raw(&mut self, arg0: &GprMem, arg1: u16) -> AssemblerOutputs;
    fn x64_adcl_mi_raw(&mut self, arg0: &GprMem, arg1: u32) -> AssemblerOutputs;
    fn x64_adcq_mi_sxl_raw(&mut self, arg0: &GprMem, arg1: i32) -> AssemblerOutputs;
    fn x64_adcl_mi_sxb_raw(&mut self, arg0: &GprMem, arg1: i8) -> AssemblerOutputs;
    fn x64_adcq_mi_sxb_raw(&mut self, arg0: &GprMem, arg1: i8) -> AssemblerOutputs;
    fn x64_adcb_mr_raw(&mut self, arg0: &GprMem, arg1: Gpr) -> AssemblerOutputs;
    fn x64_adcw_mr_raw(&mut self, arg0: &GprMem, arg1: Gpr) -> AssemblerOutputs;
    fn x64_adcl_mr_raw(&mut self, arg0: &GprMem, arg1: Gpr) -> AssemblerOutputs;
    fn x64_adcq_mr_raw(&mut self, arg0: &GprMem, arg1: Gpr) -> AssemblerOutputs;
    fn x64_adcb_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_adcw_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_adcl_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_adcq_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_lock_addb_mi_raw(&mut self, arg0: &SyntheticAmode, arg1: u8) -> AssemblerOutputs;
    fn x64_lock_addw_mi_raw(&mut self, arg0: &SyntheticAmode, arg1: u16) -> AssemblerOutputs;
    fn x64_lock_addl_mi_raw(&mut self, arg0: &SyntheticAmode, arg1: u32) -> AssemblerOutputs;
    fn x64_lock_addq_mi_sxl_raw(&mut self, arg0: &SyntheticAmode, arg1: i32) -> AssemblerOutputs;
    fn x64_lock_addl_mi_sxb_raw(&mut self, arg0: &SyntheticAmode, arg1: i8) -> AssemblerOutputs;
    fn x64_lock_addq_mi_sxb_raw(&mut self, arg0: &SyntheticAmode, arg1: i8) -> AssemblerOutputs;
    fn x64_lock_addb_mr_raw(&mut self, arg0: &SyntheticAmode, arg1: Gpr) -> AssemblerOutputs;
    fn x64_lock_addw_mr_raw(&mut self, arg0: &SyntheticAmode, arg1: Gpr) -> AssemblerOutputs;
    fn x64_lock_addl_mr_raw(&mut self, arg0: &SyntheticAmode, arg1: Gpr) -> AssemblerOutputs;
    fn x64_lock_addq_mr_raw(&mut self, arg0: &SyntheticAmode, arg1: Gpr) -> AssemblerOutputs;
    fn x64_lock_adcb_mi_raw(&mut self, arg0: &SyntheticAmode, arg1: u8) -> AssemblerOutputs;
    fn x64_lock_adcw_mi_raw(&mut self, arg0: &SyntheticAmode, arg1: u16) -> AssemblerOutputs;
    fn x64_lock_adcl_mi_raw(&mut self, arg0: &SyntheticAmode, arg1: u32) -> AssemblerOutputs;
    fn x64_lock_adcq_mi_sxl_raw(&mut self, arg0: &SyntheticAmode, arg1: i32) -> AssemblerOutputs;
    fn x64_lock_adcl_mi_sxb_raw(&mut self, arg0: &SyntheticAmode, arg1: i8) -> AssemblerOutputs;
    fn x64_lock_adcq_mi_sxb_raw(&mut self, arg0: &SyntheticAmode, arg1: i8) -> AssemblerOutputs;
    fn x64_lock_adcb_mr_raw(&mut self, arg0: &SyntheticAmode, arg1: Gpr) -> AssemblerOutputs;
    fn x64_lock_adcw_mr_raw(&mut self, arg0: &SyntheticAmode, arg1: Gpr) -> AssemblerOutputs;
    fn x64_lock_adcl_mr_raw(&mut self, arg0: &SyntheticAmode, arg1: Gpr) -> AssemblerOutputs;
    fn x64_lock_adcq_mr_raw(&mut self, arg0: &SyntheticAmode, arg1: Gpr) -> AssemblerOutputs;
    fn x64_lock_xaddb_mr_raw(&mut self, arg0: &SyntheticAmode, arg1: Gpr) -> AssemblerOutputs;
    fn x64_lock_xaddw_mr_raw(&mut self, arg0: &SyntheticAmode, arg1: Gpr) -> AssemblerOutputs;
    fn x64_lock_xaddl_mr_raw(&mut self, arg0: &SyntheticAmode, arg1: Gpr) -> AssemblerOutputs;
    fn x64_lock_xaddq_mr_raw(&mut self, arg0: &SyntheticAmode, arg1: Gpr) -> AssemblerOutputs;
    fn x64_addss_a_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_addsd_a_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_addps_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_addpd_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_paddb_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_paddw_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_paddd_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_paddq_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_paddsb_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_paddsw_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_paddusb_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_paddusw_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_phaddw_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_phaddd_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_vaddss_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vaddsd_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vaddps_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vaddpd_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vpaddb_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vpaddw_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vpaddd_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vpaddq_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vpaddsb_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vpaddsw_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vpaddusb_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vpaddusw_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vphaddw_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vphaddd_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vaddpd_c_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_palignr_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned, arg2: u8) -> AssemblerOutputs;
    fn x64_vpalignr_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem, arg2: u8) -> AssemblerOutputs;
    fn x64_andb_i_raw(&mut self, arg0: Gpr, arg1: u8) -> AssemblerOutputs;
    fn x64_andw_i_raw(&mut self, arg0: Gpr, arg1: u16) -> AssemblerOutputs;
    fn x64_andl_i_raw(&mut self, arg0: Gpr, arg1: u32) -> AssemblerOutputs;
    fn x64_andq_i_sxl_raw(&mut self, arg0: Gpr, arg1: i32) -> AssemblerOutputs;
    fn x64_andb_mi_raw(&mut self, arg0: &GprMem, arg1: u8) -> AssemblerOutputs;
    fn x64_andw_mi_raw(&mut self, arg0: &GprMem, arg1: u16) -> AssemblerOutputs;
    fn x64_andl_mi_raw(&mut self, arg0: &GprMem, arg1: u32) -> AssemblerOutputs;
    fn x64_andq_mi_sxl_raw(&mut self, arg0: &GprMem, arg1: i32) -> AssemblerOutputs;
    fn x64_andl_mi_sxb_raw(&mut self, arg0: &GprMem, arg1: i8) -> AssemblerOutputs;
    fn x64_andq_mi_sxb_raw(&mut self, arg0: &GprMem, arg1: i8) -> AssemblerOutputs;
    fn x64_andb_mr_raw(&mut self, arg0: &GprMem, arg1: Gpr) -> AssemblerOutputs;
    fn x64_andw_mr_raw(&mut self, arg0: &GprMem, arg1: Gpr) -> AssemblerOutputs;
    fn x64_andl_mr_raw(&mut self, arg0: &GprMem, arg1: Gpr) -> AssemblerOutputs;
    fn x64_andq_mr_raw(&mut self, arg0: &GprMem, arg1: Gpr) -> AssemblerOutputs;
    fn x64_andb_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_andw_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_andl_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_andq_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_andnl_rvm_raw(&mut self, arg0: Gpr, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_andnq_rvm_raw(&mut self, arg0: Gpr, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_lock_andb_mi_raw(&mut self, arg0: &SyntheticAmode, arg1: u8) -> AssemblerOutputs;
    fn x64_lock_andw_mi_raw(&mut self, arg0: &SyntheticAmode, arg1: u16) -> AssemblerOutputs;
    fn x64_lock_andl_mi_raw(&mut self, arg0: &SyntheticAmode, arg1: u32) -> AssemblerOutputs;
    fn x64_lock_andq_mi_sxl_raw(&mut self, arg0: &SyntheticAmode, arg1: i32) -> AssemblerOutputs;
    fn x64_lock_andl_mi_sxb_raw(&mut self, arg0: &SyntheticAmode, arg1: i8) -> AssemblerOutputs;
    fn x64_lock_andq_mi_sxb_raw(&mut self, arg0: &SyntheticAmode, arg1: i8) -> AssemblerOutputs;
    fn x64_lock_andb_mr_raw(&mut self, arg0: &SyntheticAmode, arg1: Gpr) -> AssemblerOutputs;
    fn x64_lock_andw_mr_raw(&mut self, arg0: &SyntheticAmode, arg1: Gpr) -> AssemblerOutputs;
    fn x64_lock_andl_mr_raw(&mut self, arg0: &SyntheticAmode, arg1: Gpr) -> AssemblerOutputs;
    fn x64_lock_andq_mr_raw(&mut self, arg0: &SyntheticAmode, arg1: Gpr) -> AssemblerOutputs;
    fn x64_andps_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_andpd_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_andnps_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_andnpd_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_pand_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_pandn_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_vandps_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vandpd_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vandnps_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vandnpd_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vpand_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vpandn_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_xchgb_rm_raw(&mut self, arg0: Gpr, arg1: &SyntheticAmode) -> AssemblerOutputs;
    fn x64_xchgw_rm_raw(&mut self, arg0: Gpr, arg1: &SyntheticAmode) -> AssemblerOutputs;
    fn x64_xchgl_rm_raw(&mut self, arg0: Gpr, arg1: &SyntheticAmode) -> AssemblerOutputs;
    fn x64_xchgq_rm_raw(&mut self, arg0: Gpr, arg1: &SyntheticAmode) -> AssemblerOutputs;
    fn x64_cmpxchg16b_m_raw(&mut self, arg0: Gpr, arg1: Gpr, arg2: Gpr, arg3: Gpr, arg4: &SyntheticAmode) -> AssemblerOutputs;
    fn x64_lock_cmpxchg16b_m_raw(&mut self, arg0: Gpr, arg1: Gpr, arg2: Gpr, arg3: Gpr, arg4: &SyntheticAmode) -> AssemblerOutputs;
    fn x64_cmpxchgb_mr_raw(&mut self, arg0: &GprMem, arg1: Gpr, arg2: Gpr) -> AssemblerOutputs;
    fn x64_cmpxchgw_mr_raw(&mut self, arg0: &GprMem, arg1: Gpr, arg2: Gpr) -> AssemblerOutputs;
    fn x64_cmpxchgl_mr_raw(&mut self, arg0: &GprMem, arg1: Gpr, arg2: Gpr) -> AssemblerOutputs;
    fn x64_cmpxchgq_mr_raw(&mut self, arg0: &GprMem, arg1: Gpr, arg2: Gpr) -> AssemblerOutputs;
    fn x64_lock_cmpxchgb_mr_raw(&mut self, arg0: &SyntheticAmode, arg1: Gpr, arg2: Gpr) -> AssemblerOutputs;
    fn x64_lock_cmpxchgw_mr_raw(&mut self, arg0: &SyntheticAmode, arg1: Gpr, arg2: Gpr) -> AssemblerOutputs;
    fn x64_lock_cmpxchgl_mr_raw(&mut self, arg0: &SyntheticAmode, arg1: Gpr, arg2: Gpr) -> AssemblerOutputs;
    fn x64_lock_cmpxchgq_mr_raw(&mut self, arg0: &SyntheticAmode, arg1: Gpr, arg2: Gpr) -> AssemblerOutputs;
    fn x64_pavgb_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_pavgw_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_vpavgb_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vpavgw_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_bsfw_rm_raw(&mut self, arg0: &GprMem) -> AssemblerOutputs;
    fn x64_bsfl_rm_raw(&mut self, arg0: &GprMem) -> AssemblerOutputs;
    fn x64_bsfq_rm_raw(&mut self, arg0: &GprMem) -> AssemblerOutputs;
    fn x64_bsrw_rm_raw(&mut self, arg0: &GprMem) -> AssemblerOutputs;
    fn x64_bsrl_rm_raw(&mut self, arg0: &GprMem) -> AssemblerOutputs;
    fn x64_bsrq_rm_raw(&mut self, arg0: &GprMem) -> AssemblerOutputs;
    fn x64_tzcntw_a_raw(&mut self, arg0: &GprMem) -> AssemblerOutputs;
    fn x64_tzcntl_a_raw(&mut self, arg0: &GprMem) -> AssemblerOutputs;
    fn x64_tzcntq_a_raw(&mut self, arg0: &GprMem) -> AssemblerOutputs;
    fn x64_lzcntw_rm_raw(&mut self, arg0: &GprMem) -> AssemblerOutputs;
    fn x64_lzcntl_rm_raw(&mut self, arg0: &GprMem) -> AssemblerOutputs;
    fn x64_lzcntq_rm_raw(&mut self, arg0: &GprMem) -> AssemblerOutputs;
    fn x64_popcntw_rm_raw(&mut self, arg0: &GprMem) -> AssemblerOutputs;
    fn x64_popcntl_rm_raw(&mut self, arg0: &GprMem) -> AssemblerOutputs;
    fn x64_popcntq_rm_raw(&mut self, arg0: &GprMem) -> AssemblerOutputs;
    fn x64_btw_mr_raw(&mut self, arg0: &GprMem, arg1: Gpr) -> AssemblerOutputs;
    fn x64_btl_mr_raw(&mut self, arg0: &GprMem, arg1: Gpr) -> AssemblerOutputs;
    fn x64_btq_mr_raw(&mut self, arg0: &GprMem, arg1: Gpr) -> AssemblerOutputs;
    fn x64_btw_mi_raw(&mut self, arg0: &GprMem, arg1: u8) -> AssemblerOutputs;
    fn x64_btl_mi_raw(&mut self, arg0: &GprMem, arg1: u8) -> AssemblerOutputs;
    fn x64_btq_mi_raw(&mut self, arg0: &GprMem, arg1: u8) -> AssemblerOutputs;
    fn x64_cbtw_zo_raw(&mut self, arg0: Gpr) -> AssemblerOutputs;
    fn x64_cwtl_zo_raw(&mut self, arg0: Gpr) -> AssemblerOutputs;
    fn x64_cltq_zo_raw(&mut self, arg0: Gpr) -> AssemblerOutputs;
    fn x64_cwtd_zo_raw(&mut self, arg0: Gpr) -> AssemblerOutputs;
    fn x64_cltd_zo_raw(&mut self, arg0: Gpr) -> AssemblerOutputs;
    fn x64_cqto_zo_raw(&mut self, arg0: Gpr) -> AssemblerOutputs;
    fn x64_bswapl_o_raw(&mut self, arg0: Gpr) -> AssemblerOutputs;
    fn x64_bswapq_o_raw(&mut self, arg0: Gpr) -> AssemblerOutputs;
    fn x64_blsrl_vm_raw(&mut self, arg0: &GprMem) -> AssemblerOutputs;
    fn x64_blsrq_vm_raw(&mut self, arg0: &GprMem) -> AssemblerOutputs;
    fn x64_blsmskl_vm_raw(&mut self, arg0: &GprMem) -> AssemblerOutputs;
    fn x64_blsmskq_vm_raw(&mut self, arg0: &GprMem) -> AssemblerOutputs;
    fn x64_blsil_vm_raw(&mut self, arg0: &GprMem) -> AssemblerOutputs;
    fn x64_blsiq_vm_raw(&mut self, arg0: &GprMem) -> AssemblerOutputs;
    fn x64_bzhil_rmv_raw(&mut self, arg0: &GprMem, arg1: Gpr) -> AssemblerOutputs;
    fn x64_bzhiq_rmv_raw(&mut self, arg0: &GprMem, arg1: Gpr) -> AssemblerOutputs;
    fn x64_vpopcntb_a_raw(&mut self, arg0: &XmmMem) -> AssemblerOutputs;
    fn x64_vpopcntw_a_raw(&mut self, arg0: &XmmMem) -> AssemblerOutputs;
    fn x64_cmovaw_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_cmoval_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_cmovaq_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_cmovaew_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_cmovael_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_cmovaeq_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_cmovbw_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_cmovbl_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_cmovbq_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_cmovbew_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_cmovbel_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_cmovbeq_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_cmovew_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_cmovel_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_cmoveq_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_cmovgw_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_cmovgl_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_cmovgq_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_cmovgew_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_cmovgel_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_cmovgeq_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_cmovlw_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_cmovll_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_cmovlq_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_cmovlew_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_cmovlel_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_cmovleq_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_cmovnew_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_cmovnel_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_cmovneq_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_cmovnow_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_cmovnol_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_cmovnoq_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_cmovnpw_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_cmovnpl_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_cmovnpq_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_cmovnsw_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_cmovnsl_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_cmovnsq_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_cmovow_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_cmovol_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_cmovoq_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_cmovpw_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_cmovpl_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_cmovpq_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_cmovsw_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_cmovsl_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_cmovsq_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_cmpb_i_raw(&mut self, arg0: Gpr, arg1: u8) -> AssemblerOutputs;
    fn x64_cmpw_i_raw(&mut self, arg0: Gpr, arg1: u16) -> AssemblerOutputs;
    fn x64_cmpl_i_raw(&mut self, arg0: Gpr, arg1: u32) -> AssemblerOutputs;
    fn x64_cmpq_i_raw(&mut self, arg0: Gpr, arg1: i32) -> AssemblerOutputs;
    fn x64_cmpb_mi_raw(&mut self, arg0: &GprMem, arg1: u8) -> AssemblerOutputs;
    fn x64_cmpw_mi_raw(&mut self, arg0: &GprMem, arg1: u16) -> AssemblerOutputs;
    fn x64_cmpl_mi_raw(&mut self, arg0: &GprMem, arg1: u32) -> AssemblerOutputs;
    fn x64_cmpq_mi_raw(&mut self, arg0: &GprMem, arg1: i32) -> AssemblerOutputs;
    fn x64_cmpw_mi_sxb_raw(&mut self, arg0: &GprMem, arg1: i8) -> AssemblerOutputs;
    fn x64_cmpl_mi_sxb_raw(&mut self, arg0: &GprMem, arg1: i8) -> AssemblerOutputs;
    fn x64_cmpq_mi_sxb_raw(&mut self, arg0: &GprMem, arg1: i8) -> AssemblerOutputs;
    fn x64_cmpb_mr_raw(&mut self, arg0: &GprMem, arg1: Gpr) -> AssemblerOutputs;
    fn x64_cmpw_mr_raw(&mut self, arg0: &GprMem, arg1: Gpr) -> AssemblerOutputs;
    fn x64_cmpl_mr_raw(&mut self, arg0: &GprMem, arg1: Gpr) -> AssemblerOutputs;
    fn x64_cmpq_mr_raw(&mut self, arg0: &GprMem, arg1: Gpr) -> AssemblerOutputs;
    fn x64_cmpb_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_cmpw_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_cmpl_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_cmpq_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_testb_i_raw(&mut self, arg0: Gpr, arg1: u8) -> AssemblerOutputs;
    fn x64_testw_i_raw(&mut self, arg0: Gpr, arg1: u16) -> AssemblerOutputs;
    fn x64_testl_i_raw(&mut self, arg0: Gpr, arg1: u32) -> AssemblerOutputs;
    fn x64_testq_i_raw(&mut self, arg0: Gpr, arg1: i32) -> AssemblerOutputs;
    fn x64_testb_mi_raw(&mut self, arg0: &GprMem, arg1: u8) -> AssemblerOutputs;
    fn x64_testw_mi_raw(&mut self, arg0: &GprMem, arg1: u16) -> AssemblerOutputs;
    fn x64_testl_mi_raw(&mut self, arg0: &GprMem, arg1: u32) -> AssemblerOutputs;
    fn x64_testq_mi_raw(&mut self, arg0: &GprMem, arg1: i32) -> AssemblerOutputs;
    fn x64_testb_mr_raw(&mut self, arg0: &GprMem, arg1: Gpr) -> AssemblerOutputs;
    fn x64_testw_mr_raw(&mut self, arg0: &GprMem, arg1: Gpr) -> AssemblerOutputs;
    fn x64_testl_mr_raw(&mut self, arg0: &GprMem, arg1: Gpr) -> AssemblerOutputs;
    fn x64_testq_mr_raw(&mut self, arg0: &GprMem, arg1: Gpr) -> AssemblerOutputs;
    fn x64_ptest_rm_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_vptest_rm_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_ucomiss_a_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_ucomisd_a_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vucomiss_a_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vucomisd_a_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_cmpss_a_raw(&mut self, arg0: Xmm, arg1: &XmmMem, arg2: u8) -> AssemblerOutputs;
    fn x64_cmpsd_a_raw(&mut self, arg0: Xmm, arg1: &XmmMem, arg2: u8) -> AssemblerOutputs;
    fn x64_cmpps_a_raw(&mut self, arg0: Xmm, arg1: &XmmMem, arg2: u8) -> AssemblerOutputs;
    fn x64_cmppd_a_raw(&mut self, arg0: Xmm, arg1: &XmmMem, arg2: u8) -> AssemblerOutputs;
    fn x64_vcmpss_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem, arg2: u8) -> AssemblerOutputs;
    fn x64_vcmpsd_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem, arg2: u8) -> AssemblerOutputs;
    fn x64_vcmpps_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem, arg2: u8) -> AssemblerOutputs;
    fn x64_vcmppd_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem, arg2: u8) -> AssemblerOutputs;
    fn x64_pcmpeqb_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_pcmpeqw_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_pcmpeqd_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_pcmpeqq_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_pcmpgtb_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_pcmpgtw_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_pcmpgtd_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_pcmpgtq_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_vpcmpeqb_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vpcmpeqw_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vpcmpeqd_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vpcmpeqq_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vpcmpgtb_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vpcmpgtw_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vpcmpgtd_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vpcmpgtq_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_cvtps2pd_a_raw(&mut self, arg0: &XmmMem) -> AssemblerOutputs;
    fn x64_cvttps2dq_a_raw(&mut self, arg0: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_cvtss2sd_a_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_cvtss2si_a_raw(&mut self, arg0: &XmmMem) -> AssemblerOutputs;
    fn x64_cvtss2si_aq_raw(&mut self, arg0: &XmmMem) -> AssemblerOutputs;
    fn x64_cvttss2si_a_raw(&mut self, arg0: &XmmMem) -> AssemblerOutputs;
    fn x64_cvttss2si_aq_raw(&mut self, arg0: &XmmMem) -> AssemblerOutputs;
    fn x64_vcvtps2pd_a_raw(&mut self, arg0: &XmmMem) -> AssemblerOutputs;
    fn x64_vcvttps2dq_a_raw(&mut self, arg0: &XmmMem) -> AssemblerOutputs;
    fn x64_vcvtss2sd_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vcvtss2si_a_raw(&mut self, arg0: &XmmMem) -> AssemblerOutputs;
    fn x64_vcvtss2si_aq_raw(&mut self, arg0: &XmmMem) -> AssemblerOutputs;
    fn x64_vcvttss2si_a_raw(&mut self, arg0: &XmmMem) -> AssemblerOutputs;
    fn x64_vcvttss2si_aq_raw(&mut self, arg0: &XmmMem) -> AssemblerOutputs;
    fn x64_cvtpd2ps_a_raw(&mut self, arg0: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_cvttpd2dq_a_raw(&mut self, arg0: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_cvtsd2ss_a_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_cvtsd2si_a_raw(&mut self, arg0: &XmmMem) -> AssemblerOutputs;
    fn x64_cvtsd2si_aq_raw(&mut self, arg0: &XmmMem) -> AssemblerOutputs;
    fn x64_cvttsd2si_a_raw(&mut self, arg0: &XmmMem) -> AssemblerOutputs;
    fn x64_cvttsd2si_aq_raw(&mut self, arg0: &XmmMem) -> AssemblerOutputs;
    fn x64_vcvtpd2ps_a_raw(&mut self, arg0: &XmmMem) -> AssemblerOutputs;
    fn x64_vcvttpd2dq_a_raw(&mut self, arg0: &XmmMem) -> AssemblerOutputs;
    fn x64_vcvtsd2ss_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vcvtsd2si_a_raw(&mut self, arg0: &XmmMem) -> AssemblerOutputs;
    fn x64_vcvtsd2si_aq_raw(&mut self, arg0: &XmmMem) -> AssemblerOutputs;
    fn x64_vcvttsd2si_a_raw(&mut self, arg0: &XmmMem) -> AssemblerOutputs;
    fn x64_vcvttsd2si_aq_raw(&mut self, arg0: &XmmMem) -> AssemblerOutputs;
    fn x64_cvtdq2ps_a_raw(&mut self, arg0: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_cvtdq2pd_a_raw(&mut self, arg0: &XmmMem) -> AssemblerOutputs;
    fn x64_cvtsi2ssl_a_raw(&mut self, arg0: Xmm, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_cvtsi2ssq_a_raw(&mut self, arg0: Xmm, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_cvtsi2sdl_a_raw(&mut self, arg0: Xmm, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_cvtsi2sdq_a_raw(&mut self, arg0: Xmm, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_vcvtdq2pd_a_raw(&mut self, arg0: &XmmMem) -> AssemblerOutputs;
    fn x64_vcvtdq2ps_a_raw(&mut self, arg0: &XmmMem) -> AssemblerOutputs;
    fn x64_vcvtsi2sdl_b_raw(&mut self, arg0: Xmm, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_vcvtsi2sdq_b_raw(&mut self, arg0: Xmm, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_vcvtsi2ssl_b_raw(&mut self, arg0: Xmm, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_vcvtsi2ssq_b_raw(&mut self, arg0: Xmm, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_vcvtudq2ps_a_raw(&mut self, arg0: &XmmMem) -> AssemblerOutputs;
    fn x64_divb_m_raw(&mut self, arg0: Gpr, arg1: &GprMem, arg2: &TrapCode) -> AssemblerOutputs;
    fn x64_divw_m_raw(&mut self, arg0: Gpr, arg1: Gpr, arg2: &GprMem, arg3: &TrapCode) -> AssemblerOutputs;
    fn x64_divl_m_raw(&mut self, arg0: Gpr, arg1: Gpr, arg2: &GprMem, arg3: &TrapCode) -> AssemblerOutputs;
    fn x64_divq_m_raw(&mut self, arg0: Gpr, arg1: Gpr, arg2: &GprMem, arg3: &TrapCode) -> AssemblerOutputs;
    fn x64_idivb_m_raw(&mut self, arg0: Gpr, arg1: &GprMem, arg2: &TrapCode) -> AssemblerOutputs;
    fn x64_idivw_m_raw(&mut self, arg0: Gpr, arg1: Gpr, arg2: &GprMem, arg3: &TrapCode) -> AssemblerOutputs;
    fn x64_idivl_m_raw(&mut self, arg0: Gpr, arg1: Gpr, arg2: &GprMem, arg3: &TrapCode) -> AssemblerOutputs;
    fn x64_idivq_m_raw(&mut self, arg0: Gpr, arg1: Gpr, arg2: &GprMem, arg3: &TrapCode) -> AssemblerOutputs;
    fn x64_divss_a_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_divsd_a_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_divps_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_divpd_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_vdivss_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vdivsd_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vdivps_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vdivpd_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vfmadd132ss_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem) -> AssemblerOutputs;
    fn x64_vfmadd213ss_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem) -> AssemblerOutputs;
    fn x64_vfmadd231ss_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem) -> AssemblerOutputs;
    fn x64_vfmadd132sd_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem) -> AssemblerOutputs;
    fn x64_vfmadd213sd_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem) -> AssemblerOutputs;
    fn x64_vfmadd231sd_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem) -> AssemblerOutputs;
    fn x64_vfmadd132ps_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem) -> AssemblerOutputs;
    fn x64_vfmadd213ps_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem) -> AssemblerOutputs;
    fn x64_vfmadd231ps_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem) -> AssemblerOutputs;
    fn x64_vfmadd132pd_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem) -> AssemblerOutputs;
    fn x64_vfmadd213pd_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem) -> AssemblerOutputs;
    fn x64_vfmadd231pd_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem) -> AssemblerOutputs;
    fn x64_vfnmadd132ss_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem) -> AssemblerOutputs;
    fn x64_vfnmadd213ss_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem) -> AssemblerOutputs;
    fn x64_vfnmadd231ss_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem) -> AssemblerOutputs;
    fn x64_vfnmadd132sd_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem) -> AssemblerOutputs;
    fn x64_vfnmadd213sd_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem) -> AssemblerOutputs;
    fn x64_vfnmadd231sd_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem) -> AssemblerOutputs;
    fn x64_vfnmadd132ps_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem) -> AssemblerOutputs;
    fn x64_vfnmadd213ps_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem) -> AssemblerOutputs;
    fn x64_vfnmadd231ps_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem) -> AssemblerOutputs;
    fn x64_vfnmadd132pd_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem) -> AssemblerOutputs;
    fn x64_vfnmadd213pd_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem) -> AssemblerOutputs;
    fn x64_vfnmadd231pd_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem) -> AssemblerOutputs;
    fn x64_vfmsub132ss_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem) -> AssemblerOutputs;
    fn x64_vfmsub213ss_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem) -> AssemblerOutputs;
    fn x64_vfmsub231ss_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem) -> AssemblerOutputs;
    fn x64_vfmsub132sd_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem) -> AssemblerOutputs;
    fn x64_vfmsub213sd_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem) -> AssemblerOutputs;
    fn x64_vfmsub231sd_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem) -> AssemblerOutputs;
    fn x64_vfmsub132ps_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem) -> AssemblerOutputs;
    fn x64_vfmsub213ps_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem) -> AssemblerOutputs;
    fn x64_vfmsub231ps_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem) -> AssemblerOutputs;
    fn x64_vfmsub132pd_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem) -> AssemblerOutputs;
    fn x64_vfmsub213pd_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem) -> AssemblerOutputs;
    fn x64_vfmsub231pd_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem) -> AssemblerOutputs;
    fn x64_vfnmsub132ss_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem) -> AssemblerOutputs;
    fn x64_vfnmsub213ss_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem) -> AssemblerOutputs;
    fn x64_vfnmsub231ss_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem) -> AssemblerOutputs;
    fn x64_vfnmsub132sd_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem) -> AssemblerOutputs;
    fn x64_vfnmsub213sd_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem) -> AssemblerOutputs;
    fn x64_vfnmsub231sd_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem) -> AssemblerOutputs;
    fn x64_vfnmsub132ps_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem) -> AssemblerOutputs;
    fn x64_vfnmsub213ps_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem) -> AssemblerOutputs;
    fn x64_vfnmsub231ps_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem) -> AssemblerOutputs;
    fn x64_vfnmsub132pd_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem) -> AssemblerOutputs;
    fn x64_vfnmsub213pd_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem) -> AssemblerOutputs;
    fn x64_vfnmsub231pd_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem) -> AssemblerOutputs;
    fn x64_jmpq_m_raw(&mut self, arg0: &GprMem) -> AssemblerOutputs;
    fn x64_jmp_d8_raw(&mut self, arg0: i8) -> AssemblerOutputs;
    fn x64_jmp_d32_raw(&mut self, arg0: i32) -> AssemblerOutputs;
    fn x64_ja_d8_raw(&mut self, arg0: i8) -> AssemblerOutputs;
    fn x64_ja_d32_raw(&mut self, arg0: i32) -> AssemblerOutputs;
    fn x64_jae_d8_raw(&mut self, arg0: i8) -> AssemblerOutputs;
    fn x64_jae_d32_raw(&mut self, arg0: i32) -> AssemblerOutputs;
    fn x64_jb_d8_raw(&mut self, arg0: i8) -> AssemblerOutputs;
    fn x64_jb_d32_raw(&mut self, arg0: i32) -> AssemblerOutputs;
    fn x64_jbe_d8_raw(&mut self, arg0: i8) -> AssemblerOutputs;
    fn x64_jbe_d32_raw(&mut self, arg0: i32) -> AssemblerOutputs;
    fn x64_je_d8_raw(&mut self, arg0: i8) -> AssemblerOutputs;
    fn x64_je_d32_raw(&mut self, arg0: i32) -> AssemblerOutputs;
    fn x64_jg_d8_raw(&mut self, arg0: i8) -> AssemblerOutputs;
    fn x64_jg_d32_raw(&mut self, arg0: i32) -> AssemblerOutputs;
    fn x64_jge_d8_raw(&mut self, arg0: i8) -> AssemblerOutputs;
    fn x64_jge_d32_raw(&mut self, arg0: i32) -> AssemblerOutputs;
    fn x64_jl_d8_raw(&mut self, arg0: i8) -> AssemblerOutputs;
    fn x64_jl_d32_raw(&mut self, arg0: i32) -> AssemblerOutputs;
    fn x64_jle_d8_raw(&mut self, arg0: i8) -> AssemblerOutputs;
    fn x64_jle_d32_raw(&mut self, arg0: i32) -> AssemblerOutputs;
    fn x64_jne_d8_raw(&mut self, arg0: i8) -> AssemblerOutputs;
    fn x64_jne_d32_raw(&mut self, arg0: i32) -> AssemblerOutputs;
    fn x64_jno_d8_raw(&mut self, arg0: i8) -> AssemblerOutputs;
    fn x64_jno_d32_raw(&mut self, arg0: i32) -> AssemblerOutputs;
    fn x64_jnp_d8_raw(&mut self, arg0: i8) -> AssemblerOutputs;
    fn x64_jnp_d32_raw(&mut self, arg0: i32) -> AssemblerOutputs;
    fn x64_jns_d8_raw(&mut self, arg0: i8) -> AssemblerOutputs;
    fn x64_jns_d32_raw(&mut self, arg0: i32) -> AssemblerOutputs;
    fn x64_jo_d8_raw(&mut self, arg0: i8) -> AssemblerOutputs;
    fn x64_jo_d32_raw(&mut self, arg0: i32) -> AssemblerOutputs;
    fn x64_jp_d8_raw(&mut self, arg0: i8) -> AssemblerOutputs;
    fn x64_jp_d32_raw(&mut self, arg0: i32) -> AssemblerOutputs;
    fn x64_js_d8_raw(&mut self, arg0: i8) -> AssemblerOutputs;
    fn x64_js_d32_raw(&mut self, arg0: i32) -> AssemblerOutputs;
    fn x64_extractps_a_raw(&mut self, arg0: &GprMem, arg1: Xmm, arg2: u8) -> AssemblerOutputs;
    fn x64_pextrb_a_raw(&mut self, arg0: &GprMem, arg1: Xmm, arg2: u8) -> AssemblerOutputs;
    fn x64_pextrw_a_raw(&mut self, arg0: Xmm, arg1: u8) -> AssemblerOutputs;
    fn x64_pextrw_b_raw(&mut self, arg0: &GprMem, arg1: Xmm, arg2: u8) -> AssemblerOutputs;
    fn x64_pextrd_a_raw(&mut self, arg0: &GprMem, arg1: Xmm, arg2: u8) -> AssemblerOutputs;
    fn x64_pextrq_a_raw(&mut self, arg0: &GprMem, arg1: Xmm, arg2: u8) -> AssemblerOutputs;
    fn x64_vextractps_b_raw(&mut self, arg0: &GprMem, arg1: Xmm, arg2: u8) -> AssemblerOutputs;
    fn x64_vpextrb_a_raw(&mut self, arg0: &GprMem, arg1: Xmm, arg2: u8) -> AssemblerOutputs;
    fn x64_vpextrw_a_raw(&mut self, arg0: Xmm, arg1: u8) -> AssemblerOutputs;
    fn x64_vpextrw_b_raw(&mut self, arg0: &GprMem, arg1: Xmm, arg2: u8) -> AssemblerOutputs;
    fn x64_vpextrd_a_raw(&mut self, arg0: &GprMem, arg1: Xmm, arg2: u8) -> AssemblerOutputs;
    fn x64_vpextrq_a_raw(&mut self, arg0: &GprMem, arg1: Xmm, arg2: u8) -> AssemblerOutputs;
    fn x64_insertps_a_raw(&mut self, arg0: Xmm, arg1: &XmmMem, arg2: u8) -> AssemblerOutputs;
    fn x64_pinsrb_a_raw(&mut self, arg0: Xmm, arg1: &GprMem, arg2: u8) -> AssemblerOutputs;
    fn x64_pinsrw_a_raw(&mut self, arg0: Xmm, arg1: &GprMem, arg2: u8) -> AssemblerOutputs;
    fn x64_pinsrd_a_raw(&mut self, arg0: Xmm, arg1: &GprMem, arg2: u8) -> AssemblerOutputs;
    fn x64_pinsrq_a_raw(&mut self, arg0: Xmm, arg1: &GprMem, arg2: u8) -> AssemblerOutputs;
    fn x64_vinsertps_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem, arg2: u8) -> AssemblerOutputs;
    fn x64_vpinsrb_b_raw(&mut self, arg0: Xmm, arg1: &GprMem, arg2: u8) -> AssemblerOutputs;
    fn x64_vpinsrw_b_raw(&mut self, arg0: Xmm, arg1: &GprMem, arg2: u8) -> AssemblerOutputs;
    fn x64_vpinsrd_b_raw(&mut self, arg0: Xmm, arg1: &GprMem, arg2: u8) -> AssemblerOutputs;
    fn x64_vpinsrq_b_raw(&mut self, arg0: Xmm, arg1: &GprMem, arg2: u8) -> AssemblerOutputs;
    fn x64_movmskps_rm_raw(&mut self, arg0: Xmm) -> AssemblerOutputs;
    fn x64_movmskpd_rm_raw(&mut self, arg0: Xmm) -> AssemblerOutputs;
    fn x64_pmovmskb_rm_raw(&mut self, arg0: Xmm) -> AssemblerOutputs;
    fn x64_vmovmskps_rm_raw(&mut self, arg0: Xmm) -> AssemblerOutputs;
    fn x64_vmovmskpd_rm_raw(&mut self, arg0: Xmm) -> AssemblerOutputs;
    fn x64_vpmovmskb_rm_raw(&mut self, arg0: Xmm) -> AssemblerOutputs;
    fn x64_movhps_a_raw(&mut self, arg0: Xmm, arg1: &SyntheticAmode) -> AssemblerOutputs;
    fn x64_movlhps_rm_raw(&mut self, arg0: Xmm, arg1: Xmm) -> AssemblerOutputs;
    fn x64_vmovhps_b_raw(&mut self, arg0: Xmm, arg1: &SyntheticAmode) -> AssemblerOutputs;
    fn x64_vmovlhps_rvm_raw(&mut self, arg0: Xmm, arg1: Xmm) -> AssemblerOutputs;
    fn x64_movddup_a_raw(&mut self, arg0: &XmmMem) -> AssemblerOutputs;
    fn x64_vmovddup_a_raw(&mut self, arg0: &XmmMem) -> AssemblerOutputs;
    fn x64_pblendw_rmi_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned, arg2: u8) -> AssemblerOutputs;
    fn x64_pblendvb_rm_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned, arg2: Xmm) -> AssemblerOutputs;
    fn x64_blendvps_rm0_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned, arg2: Xmm) -> AssemblerOutputs;
    fn x64_blendvpd_rm0_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned, arg2: Xmm) -> AssemblerOutputs;
    fn x64_vpblendw_rvmi_raw(&mut self, arg0: Xmm, arg1: &XmmMem, arg2: u8) -> AssemblerOutputs;
    fn x64_vpblendvb_rvmr_raw(&mut self, arg0: Xmm, arg1: &XmmMem, arg2: Xmm) -> AssemblerOutputs;
    fn x64_vblendvps_rvmr_raw(&mut self, arg0: Xmm, arg1: &XmmMem, arg2: Xmm) -> AssemblerOutputs;
    fn x64_vblendvpd_rvmr_raw(&mut self, arg0: Xmm, arg1: &XmmMem, arg2: Xmm) -> AssemblerOutputs;
    fn x64_shufpd_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned, arg2: u8) -> AssemblerOutputs;
    fn x64_vshufpd_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem, arg2: u8) -> AssemblerOutputs;
    fn x64_shufps_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned, arg2: u8) -> AssemblerOutputs;
    fn x64_vshufps_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem, arg2: u8) -> AssemblerOutputs;
    fn x64_pshufb_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_pshufd_a_raw(&mut self, arg0: &XmmMemAligned, arg1: u8) -> AssemblerOutputs;
    fn x64_pshuflw_a_raw(&mut self, arg0: &XmmMemAligned, arg1: u8) -> AssemblerOutputs;
    fn x64_pshufhw_a_raw(&mut self, arg0: &XmmMemAligned, arg1: u8) -> AssemblerOutputs;
    fn x64_vpshufb_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vpshufd_a_raw(&mut self, arg0: &XmmMem, arg1: u8) -> AssemblerOutputs;
    fn x64_vpshuflw_a_raw(&mut self, arg0: &XmmMem, arg1: u8) -> AssemblerOutputs;
    fn x64_vpshufhw_a_raw(&mut self, arg0: &XmmMem, arg1: u8) -> AssemblerOutputs;
    fn x64_vbroadcastss_a_m_raw(&mut self, arg0: &SyntheticAmode) -> AssemblerOutputs;
    fn x64_vbroadcastss_a_r_raw(&mut self, arg0: Xmm) -> AssemblerOutputs;
    fn x64_vpbroadcastb_a_raw(&mut self, arg0: &XmmMem) -> AssemblerOutputs;
    fn x64_vpbroadcastw_a_raw(&mut self, arg0: &XmmMem) -> AssemblerOutputs;
    fn x64_vpbroadcastd_a_raw(&mut self, arg0: &XmmMem) -> AssemblerOutputs;
    fn x64_vpbroadcastq_a_raw(&mut self, arg0: &XmmMem) -> AssemblerOutputs;
    fn x64_vpermi2b_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem) -> AssemblerOutputs;
    fn x64_maxss_a_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_maxsd_a_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_maxps_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_maxpd_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_vmaxss_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vmaxsd_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vmaxps_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vmaxpd_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_pmaxsb_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_pmaxsw_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_pmaxsd_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_pmaxub_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_pmaxuw_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_pmaxud_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_vpmaxsb_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vpmaxsw_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vpmaxsd_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vpmaxub_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vpmaxuw_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vpmaxud_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_minss_a_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_minsd_a_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_minps_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_minpd_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_vminss_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vminsd_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vminps_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vminpd_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_pminsb_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_pminsw_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_pminsd_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_pminub_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_pminuw_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_pminud_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_vpminsb_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vpminsw_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vpminsd_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vpminub_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vpminuw_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vpminud_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_mfence_zo_raw(&mut self, ) -> AssemblerOutputs;
    fn x64_sfence_zo_raw(&mut self, ) -> AssemblerOutputs;
    fn x64_lfence_zo_raw(&mut self, ) -> AssemblerOutputs;
    fn x64_hlt_zo_raw(&mut self, ) -> AssemblerOutputs;
    fn x64_ud2_zo_raw(&mut self, arg0: &TrapCode) -> AssemblerOutputs;
    fn x64_int3_zo_raw(&mut self, ) -> AssemblerOutputs;
    fn x64_retq_zo_raw(&mut self, ) -> AssemblerOutputs;
    fn x64_retq_i_raw(&mut self, arg0: u16) -> AssemblerOutputs;
    fn x64_leaw_rm_raw(&mut self, arg0: &SyntheticAmode) -> AssemblerOutputs;
    fn x64_leal_rm_raw(&mut self, arg0: &SyntheticAmode) -> AssemblerOutputs;
    fn x64_leaq_rm_raw(&mut self, arg0: &SyntheticAmode) -> AssemblerOutputs;
    fn x64_callq_d_raw(&mut self, arg0: i32) -> AssemblerOutputs;
    fn x64_callq_m_raw(&mut self, arg0: &GprMem) -> AssemblerOutputs;
    fn x64_movb_mr_raw(&mut self, arg0: &GprMem, arg1: Gpr) -> AssemblerOutputs;
    fn x64_movw_mr_raw(&mut self, arg0: &GprMem, arg1: Gpr) -> AssemblerOutputs;
    fn x64_movl_mr_raw(&mut self, arg0: &GprMem, arg1: Gpr) -> AssemblerOutputs;
    fn x64_movq_mr_raw(&mut self, arg0: &GprMem, arg1: Gpr) -> AssemblerOutputs;
    fn x64_movb_rm_raw(&mut self, arg0: &GprMem) -> AssemblerOutputs;
    fn x64_movw_rm_raw(&mut self, arg0: &GprMem) -> AssemblerOutputs;
    fn x64_movl_rm_raw(&mut self, arg0: &GprMem) -> AssemblerOutputs;
    fn x64_movq_rm_raw(&mut self, arg0: &GprMem) -> AssemblerOutputs;
    fn x64_movb_oi_raw(&mut self, arg0: u8) -> AssemblerOutputs;
    fn x64_movw_oi_raw(&mut self, arg0: u16) -> AssemblerOutputs;
    fn x64_movl_oi_raw(&mut self, arg0: u32) -> AssemblerOutputs;
    fn x64_movabsq_oi_raw(&mut self, arg0: u64) -> AssemblerOutputs;
    fn x64_movb_mi_raw(&mut self, arg0: &GprMem, arg1: u8) -> AssemblerOutputs;
    fn x64_movw_mi_raw(&mut self, arg0: &GprMem, arg1: u16) -> AssemblerOutputs;
    fn x64_movl_mi_raw(&mut self, arg0: &GprMem, arg1: u32) -> AssemblerOutputs;
    fn x64_movq_mi_sxl_raw(&mut self, arg0: &GprMem, arg1: i32) -> AssemblerOutputs;
    fn x64_movsbw_rm_raw(&mut self, arg0: &GprMem) -> AssemblerOutputs;
    fn x64_movsbl_rm_raw(&mut self, arg0: &GprMem) -> AssemblerOutputs;
    fn x64_movsbq_rm_raw(&mut self, arg0: &GprMem) -> AssemblerOutputs;
    fn x64_movsww_rm_raw(&mut self, arg0: &GprMem) -> AssemblerOutputs;
    fn x64_movswl_rm_raw(&mut self, arg0: &GprMem) -> AssemblerOutputs;
    fn x64_movswq_rm_raw(&mut self, arg0: &GprMem) -> AssemblerOutputs;
    fn x64_movslq_rm_raw(&mut self, arg0: &GprMem) -> AssemblerOutputs;
    fn x64_movzbw_rm_raw(&mut self, arg0: &GprMem) -> AssemblerOutputs;
    fn x64_movzbl_rm_raw(&mut self, arg0: &GprMem) -> AssemblerOutputs;
    fn x64_movzbq_rm_raw(&mut self, arg0: &GprMem) -> AssemblerOutputs;
    fn x64_movzww_rm_raw(&mut self, arg0: &GprMem) -> AssemblerOutputs;
    fn x64_movzwl_rm_raw(&mut self, arg0: &GprMem) -> AssemblerOutputs;
    fn x64_movzwq_rm_raw(&mut self, arg0: &GprMem) -> AssemblerOutputs;
    fn x64_movd_a_raw(&mut self, arg0: &GprMem) -> AssemblerOutputs;
    fn x64_movq_a_raw(&mut self, arg0: &GprMem) -> AssemblerOutputs;
    fn x64_movd_b_raw(&mut self, arg0: &GprMem, arg1: Xmm) -> AssemblerOutputs;
    fn x64_movq_b_raw(&mut self, arg0: &GprMem, arg1: Xmm) -> AssemblerOutputs;
    fn x64_vmovd_a_raw(&mut self, arg0: &GprMem) -> AssemblerOutputs;
    fn x64_vmovq_a_raw(&mut self, arg0: &GprMem) -> AssemblerOutputs;
    fn x64_vmovd_b_raw(&mut self, arg0: &GprMem, arg1: Xmm) -> AssemblerOutputs;
    fn x64_vmovq_b_raw(&mut self, arg0: &GprMem, arg1: Xmm) -> AssemblerOutputs;
    fn x64_movss_a_m_raw(&mut self, arg0: &SyntheticAmode) -> AssemblerOutputs;
    fn x64_movss_a_r_raw(&mut self, arg0: Xmm, arg1: Xmm) -> AssemblerOutputs;
    fn x64_movss_c_m_raw(&mut self, arg0: &SyntheticAmode, arg1: Xmm) -> AssemblerOutputs;
    fn x64_movsd_a_m_raw(&mut self, arg0: &SyntheticAmode) -> AssemblerOutputs;
    fn x64_movsd_a_r_raw(&mut self, arg0: Xmm, arg1: Xmm) -> AssemblerOutputs;
    fn x64_movsd_c_m_raw(&mut self, arg0: &SyntheticAmode, arg1: Xmm) -> AssemblerOutputs;
    fn x64_vmovss_d_raw(&mut self, arg0: &SyntheticAmode) -> AssemblerOutputs;
    fn x64_vmovss_b_raw(&mut self, arg0: Xmm, arg1: Xmm) -> AssemblerOutputs;
    fn x64_vmovss_c_m_raw(&mut self, arg0: &SyntheticAmode, arg1: Xmm) -> AssemblerOutputs;
    fn x64_vmovsd_d_raw(&mut self, arg0: &SyntheticAmode) -> AssemblerOutputs;
    fn x64_vmovsd_b_raw(&mut self, arg0: Xmm, arg1: Xmm) -> AssemblerOutputs;
    fn x64_vmovsd_c_m_raw(&mut self, arg0: &SyntheticAmode, arg1: Xmm) -> AssemblerOutputs;
    fn x64_movapd_a_raw(&mut self, arg0: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_movapd_b_raw(&mut self, arg0: &XmmMemAligned, arg1: Xmm) -> AssemblerOutputs;
    fn x64_movaps_a_raw(&mut self, arg0: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_movaps_b_raw(&mut self, arg0: &XmmMemAligned, arg1: Xmm) -> AssemblerOutputs;
    fn x64_movdqa_a_raw(&mut self, arg0: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_movdqa_b_raw(&mut self, arg0: &XmmMemAligned, arg1: Xmm) -> AssemblerOutputs;
    fn x64_vmovapd_a_raw(&mut self, arg0: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_vmovapd_b_raw(&mut self, arg0: &XmmMemAligned, arg1: Xmm) -> AssemblerOutputs;
    fn x64_vmovaps_a_raw(&mut self, arg0: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_vmovaps_b_raw(&mut self, arg0: &XmmMemAligned, arg1: Xmm) -> AssemblerOutputs;
    fn x64_vmovdqa_a_raw(&mut self, arg0: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_vmovdqa_b_raw(&mut self, arg0: &XmmMemAligned, arg1: Xmm) -> AssemblerOutputs;
    fn x64_movupd_a_raw(&mut self, arg0: &XmmMem) -> AssemblerOutputs;
    fn x64_movupd_b_raw(&mut self, arg0: &XmmMem, arg1: Xmm) -> AssemblerOutputs;
    fn x64_movups_a_raw(&mut self, arg0: &XmmMem) -> AssemblerOutputs;
    fn x64_movups_b_raw(&mut self, arg0: &XmmMem, arg1: Xmm) -> AssemblerOutputs;
    fn x64_movdqu_a_raw(&mut self, arg0: &XmmMem) -> AssemblerOutputs;
    fn x64_movdqu_b_raw(&mut self, arg0: &XmmMem, arg1: Xmm) -> AssemblerOutputs;
    fn x64_vmovupd_a_raw(&mut self, arg0: &XmmMem) -> AssemblerOutputs;
    fn x64_vmovupd_b_raw(&mut self, arg0: &XmmMem, arg1: Xmm) -> AssemblerOutputs;
    fn x64_vmovups_a_raw(&mut self, arg0: &XmmMem) -> AssemblerOutputs;
    fn x64_vmovups_b_raw(&mut self, arg0: &XmmMem, arg1: Xmm) -> AssemblerOutputs;
    fn x64_vmovdqu_a_raw(&mut self, arg0: &XmmMem) -> AssemblerOutputs;
    fn x64_vmovdqu_b_raw(&mut self, arg0: &XmmMem, arg1: Xmm) -> AssemblerOutputs;
    fn x64_pmovsxbw_a_raw(&mut self, arg0: &XmmMem) -> AssemblerOutputs;
    fn x64_pmovsxbd_a_raw(&mut self, arg0: &XmmMem) -> AssemblerOutputs;
    fn x64_pmovsxbq_a_raw(&mut self, arg0: &XmmMem) -> AssemblerOutputs;
    fn x64_pmovsxwd_a_raw(&mut self, arg0: &XmmMem) -> AssemblerOutputs;
    fn x64_pmovsxwq_a_raw(&mut self, arg0: &XmmMem) -> AssemblerOutputs;
    fn x64_pmovsxdq_a_raw(&mut self, arg0: &XmmMem) -> AssemblerOutputs;
    fn x64_vpmovsxbw_a_raw(&mut self, arg0: &XmmMem) -> AssemblerOutputs;
    fn x64_vpmovsxbd_a_raw(&mut self, arg0: &XmmMem) -> AssemblerOutputs;
    fn x64_vpmovsxbq_a_raw(&mut self, arg0: &XmmMem) -> AssemblerOutputs;
    fn x64_vpmovsxwd_a_raw(&mut self, arg0: &XmmMem) -> AssemblerOutputs;
    fn x64_vpmovsxwq_a_raw(&mut self, arg0: &XmmMem) -> AssemblerOutputs;
    fn x64_vpmovsxdq_a_raw(&mut self, arg0: &XmmMem) -> AssemblerOutputs;
    fn x64_pmovzxbw_a_raw(&mut self, arg0: &XmmMem) -> AssemblerOutputs;
    fn x64_pmovzxbd_a_raw(&mut self, arg0: &XmmMem) -> AssemblerOutputs;
    fn x64_pmovzxbq_a_raw(&mut self, arg0: &XmmMem) -> AssemblerOutputs;
    fn x64_pmovzxwd_a_raw(&mut self, arg0: &XmmMem) -> AssemblerOutputs;
    fn x64_pmovzxwq_a_raw(&mut self, arg0: &XmmMem) -> AssemblerOutputs;
    fn x64_pmovzxdq_a_raw(&mut self, arg0: &XmmMem) -> AssemblerOutputs;
    fn x64_vpmovzxbw_a_raw(&mut self, arg0: &XmmMem) -> AssemblerOutputs;
    fn x64_vpmovzxbd_a_raw(&mut self, arg0: &XmmMem) -> AssemblerOutputs;
    fn x64_vpmovzxbq_a_raw(&mut self, arg0: &XmmMem) -> AssemblerOutputs;
    fn x64_vpmovzxwd_a_raw(&mut self, arg0: &XmmMem) -> AssemblerOutputs;
    fn x64_vpmovzxwq_a_raw(&mut self, arg0: &XmmMem) -> AssemblerOutputs;
    fn x64_vpmovzxdq_a_raw(&mut self, arg0: &XmmMem) -> AssemblerOutputs;
    fn x64_mulb_m_raw(&mut self, arg0: Gpr, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_mulw_m_raw(&mut self, arg0: Gpr, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_mull_m_raw(&mut self, arg0: Gpr, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_mulq_m_raw(&mut self, arg0: Gpr, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_imulb_m_raw(&mut self, arg0: Gpr, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_imulw_m_raw(&mut self, arg0: Gpr, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_imull_m_raw(&mut self, arg0: Gpr, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_imulq_m_raw(&mut self, arg0: Gpr, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_imulw_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_imull_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_imulq_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_imulw_rmi_sxb_raw(&mut self, arg0: &GprMem, arg1: i8) -> AssemblerOutputs;
    fn x64_imull_rmi_sxb_raw(&mut self, arg0: &GprMem, arg1: i8) -> AssemblerOutputs;
    fn x64_imulq_rmi_sxb_raw(&mut self, arg0: &GprMem, arg1: i8) -> AssemblerOutputs;
    fn x64_imulw_rmi_raw(&mut self, arg0: &GprMem, arg1: u16) -> AssemblerOutputs;
    fn x64_imull_rmi_raw(&mut self, arg0: &GprMem, arg1: u32) -> AssemblerOutputs;
    fn x64_imulq_rmi_sxl_raw(&mut self, arg0: &GprMem, arg1: i32) -> AssemblerOutputs;
    fn x64_mulxl_rvm_raw(&mut self, arg0: &GprMem, arg1: Gpr) -> AssemblerOutputs;
    fn x64_mulxq_rvm_raw(&mut self, arg0: &GprMem, arg1: Gpr) -> AssemblerOutputs;
    fn x64_mulss_a_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_mulsd_a_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_mulps_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_mulpd_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_pmuldq_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_pmulhrsw_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_pmulhuw_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_pmulhw_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_pmulld_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_pmullw_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_pmuludq_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_vmulss_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vmulsd_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vmulps_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vmulpd_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vpmuldq_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vpmulhrsw_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vpmulhuw_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vpmulhw_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vpmulld_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vpmullw_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vpmuludq_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vpmulld_c_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vpmullq_c_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_negb_m_raw(&mut self, arg0: &GprMem) -> AssemblerOutputs;
    fn x64_negw_m_raw(&mut self, arg0: &GprMem) -> AssemblerOutputs;
    fn x64_negl_m_raw(&mut self, arg0: &GprMem) -> AssemblerOutputs;
    fn x64_negq_m_raw(&mut self, arg0: &GprMem) -> AssemblerOutputs;
    fn x64_notb_m_raw(&mut self, arg0: &GprMem) -> AssemblerOutputs;
    fn x64_notw_m_raw(&mut self, arg0: &GprMem) -> AssemblerOutputs;
    fn x64_notl_m_raw(&mut self, arg0: &GprMem) -> AssemblerOutputs;
    fn x64_notq_m_raw(&mut self, arg0: &GprMem) -> AssemblerOutputs;
    fn x64_nop_zo_raw(&mut self, ) -> AssemblerOutputs;
    fn x64_nopl_m_raw(&mut self, arg0: &GprMem) -> AssemblerOutputs;
    fn x64_nop_1b_raw(&mut self, ) -> AssemblerOutputs;
    fn x64_nop_2b_raw(&mut self, ) -> AssemblerOutputs;
    fn x64_nop_3b_raw(&mut self, ) -> AssemblerOutputs;
    fn x64_nop_4b_raw(&mut self, ) -> AssemblerOutputs;
    fn x64_nop_5b_raw(&mut self, ) -> AssemblerOutputs;
    fn x64_nop_6b_raw(&mut self, ) -> AssemblerOutputs;
    fn x64_nop_7b_raw(&mut self, ) -> AssemblerOutputs;
    fn x64_nop_8b_raw(&mut self, ) -> AssemblerOutputs;
    fn x64_nop_9b_raw(&mut self, ) -> AssemblerOutputs;
    fn x64_orb_i_raw(&mut self, arg0: Gpr, arg1: u8) -> AssemblerOutputs;
    fn x64_orw_i_raw(&mut self, arg0: Gpr, arg1: u16) -> AssemblerOutputs;
    fn x64_orl_i_raw(&mut self, arg0: Gpr, arg1: u32) -> AssemblerOutputs;
    fn x64_orq_i_sxl_raw(&mut self, arg0: Gpr, arg1: i32) -> AssemblerOutputs;
    fn x64_orb_mi_raw(&mut self, arg0: &GprMem, arg1: u8) -> AssemblerOutputs;
    fn x64_orw_mi_raw(&mut self, arg0: &GprMem, arg1: u16) -> AssemblerOutputs;
    fn x64_orl_mi_raw(&mut self, arg0: &GprMem, arg1: u32) -> AssemblerOutputs;
    fn x64_orq_mi_sxl_raw(&mut self, arg0: &GprMem, arg1: i32) -> AssemblerOutputs;
    fn x64_orl_mi_sxb_raw(&mut self, arg0: &GprMem, arg1: i8) -> AssemblerOutputs;
    fn x64_orq_mi_sxb_raw(&mut self, arg0: &GprMem, arg1: i8) -> AssemblerOutputs;
    fn x64_orb_mr_raw(&mut self, arg0: &GprMem, arg1: Gpr) -> AssemblerOutputs;
    fn x64_orw_mr_raw(&mut self, arg0: &GprMem, arg1: Gpr) -> AssemblerOutputs;
    fn x64_orl_mr_raw(&mut self, arg0: &GprMem, arg1: Gpr) -> AssemblerOutputs;
    fn x64_orq_mr_raw(&mut self, arg0: &GprMem, arg1: Gpr) -> AssemblerOutputs;
    fn x64_orb_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_orw_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_orl_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_orq_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_lock_orb_mi_raw(&mut self, arg0: &SyntheticAmode, arg1: u8) -> AssemblerOutputs;
    fn x64_lock_orw_mi_raw(&mut self, arg0: &SyntheticAmode, arg1: u16) -> AssemblerOutputs;
    fn x64_lock_orl_mi_raw(&mut self, arg0: &SyntheticAmode, arg1: u32) -> AssemblerOutputs;
    fn x64_lock_orq_mi_sxl_raw(&mut self, arg0: &SyntheticAmode, arg1: i32) -> AssemblerOutputs;
    fn x64_lock_orl_mi_sxb_raw(&mut self, arg0: &SyntheticAmode, arg1: i8) -> AssemblerOutputs;
    fn x64_lock_orq_mi_sxb_raw(&mut self, arg0: &SyntheticAmode, arg1: i8) -> AssemblerOutputs;
    fn x64_lock_orb_mr_raw(&mut self, arg0: &SyntheticAmode, arg1: Gpr) -> AssemblerOutputs;
    fn x64_lock_orw_mr_raw(&mut self, arg0: &SyntheticAmode, arg1: Gpr) -> AssemblerOutputs;
    fn x64_lock_orl_mr_raw(&mut self, arg0: &SyntheticAmode, arg1: Gpr) -> AssemblerOutputs;
    fn x64_lock_orq_mr_raw(&mut self, arg0: &SyntheticAmode, arg1: Gpr) -> AssemblerOutputs;
    fn x64_orps_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_orpd_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_por_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_vorps_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vorpd_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vpor_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_packsswb_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_packssdw_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_vpacksswb_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vpackssdw_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_packuswb_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_packusdw_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_vpackuswb_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vpackusdw_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_pmaddwd_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_vpmaddwd_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_pmaddubsw_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_vpmaddubsw_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_rcpps_rm_raw(&mut self, arg0: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_rcpss_rm_raw(&mut self, arg0: &XmmMem) -> AssemblerOutputs;
    fn x64_rsqrtps_rm_raw(&mut self, arg0: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_rsqrtss_rm_raw(&mut self, arg0: &XmmMem) -> AssemblerOutputs;
    fn x64_vrcpps_rm_raw(&mut self, arg0: &XmmMem) -> AssemblerOutputs;
    fn x64_vrcpss_rvm_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vrsqrtps_rm_raw(&mut self, arg0: &XmmMem) -> AssemblerOutputs;
    fn x64_vrsqrtss_rvm_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_roundpd_rmi_raw(&mut self, arg0: &XmmMemAligned, arg1: u8) -> AssemblerOutputs;
    fn x64_roundps_rmi_raw(&mut self, arg0: &XmmMemAligned, arg1: u8) -> AssemblerOutputs;
    fn x64_roundsd_rmi_raw(&mut self, arg0: &XmmMem, arg1: u8) -> AssemblerOutputs;
    fn x64_roundss_rmi_raw(&mut self, arg0: &XmmMem, arg1: u8) -> AssemblerOutputs;
    fn x64_vroundpd_rmi_raw(&mut self, arg0: &XmmMem, arg1: u8) -> AssemblerOutputs;
    fn x64_vroundps_rmi_raw(&mut self, arg0: &XmmMem, arg1: u8) -> AssemblerOutputs;
    fn x64_vroundsd_rvmi_raw(&mut self, arg0: Xmm, arg1: &XmmMem, arg2: u8) -> AssemblerOutputs;
    fn x64_vroundss_rvmi_raw(&mut self, arg0: Xmm, arg1: &XmmMem, arg2: u8) -> AssemblerOutputs;
    fn x64_seta_m_raw(&mut self, arg0: &GprMem) -> AssemblerOutputs;
    fn x64_setae_m_raw(&mut self, arg0: &GprMem) -> AssemblerOutputs;
    fn x64_setb_m_raw(&mut self, arg0: &GprMem) -> AssemblerOutputs;
    fn x64_setbe_m_raw(&mut self, arg0: &GprMem) -> AssemblerOutputs;
    fn x64_sete_m_raw(&mut self, arg0: &GprMem) -> AssemblerOutputs;
    fn x64_setg_m_raw(&mut self, arg0: &GprMem) -> AssemblerOutputs;
    fn x64_setge_m_raw(&mut self, arg0: &GprMem) -> AssemblerOutputs;
    fn x64_setl_m_raw(&mut self, arg0: &GprMem) -> AssemblerOutputs;
    fn x64_setle_m_raw(&mut self, arg0: &GprMem) -> AssemblerOutputs;
    fn x64_setne_m_raw(&mut self, arg0: &GprMem) -> AssemblerOutputs;
    fn x64_setno_m_raw(&mut self, arg0: &GprMem) -> AssemblerOutputs;
    fn x64_setnp_m_raw(&mut self, arg0: &GprMem) -> AssemblerOutputs;
    fn x64_setns_m_raw(&mut self, arg0: &GprMem) -> AssemblerOutputs;
    fn x64_seto_m_raw(&mut self, arg0: &GprMem) -> AssemblerOutputs;
    fn x64_setp_m_raw(&mut self, arg0: &GprMem) -> AssemblerOutputs;
    fn x64_sets_m_raw(&mut self, arg0: &GprMem) -> AssemblerOutputs;
    fn x64_sarb_mc_raw(&mut self, arg0: &GprMem, arg1: Gpr) -> AssemblerOutputs;
    fn x64_sarb_mi_raw(&mut self, arg0: &GprMem, arg1: u8) -> AssemblerOutputs;
    fn x64_sarb_m1_raw(&mut self, arg0: &GprMem) -> AssemblerOutputs;
    fn x64_sarw_mc_raw(&mut self, arg0: &GprMem, arg1: Gpr) -> AssemblerOutputs;
    fn x64_sarw_mi_raw(&mut self, arg0: &GprMem, arg1: u8) -> AssemblerOutputs;
    fn x64_sarw_m1_raw(&mut self, arg0: &GprMem) -> AssemblerOutputs;
    fn x64_sarl_mc_raw(&mut self, arg0: &GprMem, arg1: Gpr) -> AssemblerOutputs;
    fn x64_sarl_mi_raw(&mut self, arg0: &GprMem, arg1: u8) -> AssemblerOutputs;
    fn x64_sarl_m1_raw(&mut self, arg0: &GprMem) -> AssemblerOutputs;
    fn x64_sarq_mc_raw(&mut self, arg0: &GprMem, arg1: Gpr) -> AssemblerOutputs;
    fn x64_sarq_mi_raw(&mut self, arg0: &GprMem, arg1: u8) -> AssemblerOutputs;
    fn x64_sarq_m1_raw(&mut self, arg0: &GprMem) -> AssemblerOutputs;
    fn x64_shlb_mc_raw(&mut self, arg0: &GprMem, arg1: Gpr) -> AssemblerOutputs;
    fn x64_shlb_mi_raw(&mut self, arg0: &GprMem, arg1: u8) -> AssemblerOutputs;
    fn x64_shlb_m1_raw(&mut self, arg0: &GprMem) -> AssemblerOutputs;
    fn x64_shlw_mc_raw(&mut self, arg0: &GprMem, arg1: Gpr) -> AssemblerOutputs;
    fn x64_shlw_mi_raw(&mut self, arg0: &GprMem, arg1: u8) -> AssemblerOutputs;
    fn x64_shlw_m1_raw(&mut self, arg0: &GprMem) -> AssemblerOutputs;
    fn x64_shll_mc_raw(&mut self, arg0: &GprMem, arg1: Gpr) -> AssemblerOutputs;
    fn x64_shll_mi_raw(&mut self, arg0: &GprMem, arg1: u8) -> AssemblerOutputs;
    fn x64_shll_m1_raw(&mut self, arg0: &GprMem) -> AssemblerOutputs;
    fn x64_shlq_mc_raw(&mut self, arg0: &GprMem, arg1: Gpr) -> AssemblerOutputs;
    fn x64_shlq_mi_raw(&mut self, arg0: &GprMem, arg1: u8) -> AssemblerOutputs;
    fn x64_shlq_m1_raw(&mut self, arg0: &GprMem) -> AssemblerOutputs;
    fn x64_shrb_mc_raw(&mut self, arg0: &GprMem, arg1: Gpr) -> AssemblerOutputs;
    fn x64_shrb_mi_raw(&mut self, arg0: &GprMem, arg1: u8) -> AssemblerOutputs;
    fn x64_shrb_m1_raw(&mut self, arg0: &GprMem) -> AssemblerOutputs;
    fn x64_shrw_mc_raw(&mut self, arg0: &GprMem, arg1: Gpr) -> AssemblerOutputs;
    fn x64_shrw_mi_raw(&mut self, arg0: &GprMem, arg1: u8) -> AssemblerOutputs;
    fn x64_shrw_m1_raw(&mut self, arg0: &GprMem) -> AssemblerOutputs;
    fn x64_shrl_mc_raw(&mut self, arg0: &GprMem, arg1: Gpr) -> AssemblerOutputs;
    fn x64_shrl_mi_raw(&mut self, arg0: &GprMem, arg1: u8) -> AssemblerOutputs;
    fn x64_shrl_m1_raw(&mut self, arg0: &GprMem) -> AssemblerOutputs;
    fn x64_shrq_mc_raw(&mut self, arg0: &GprMem, arg1: Gpr) -> AssemblerOutputs;
    fn x64_shrq_mi_raw(&mut self, arg0: &GprMem, arg1: u8) -> AssemblerOutputs;
    fn x64_shrq_m1_raw(&mut self, arg0: &GprMem) -> AssemblerOutputs;
    fn x64_rolb_mc_raw(&mut self, arg0: &GprMem, arg1: Gpr) -> AssemblerOutputs;
    fn x64_rolb_mi_raw(&mut self, arg0: &GprMem, arg1: u8) -> AssemblerOutputs;
    fn x64_rolb_m1_raw(&mut self, arg0: &GprMem) -> AssemblerOutputs;
    fn x64_rolw_mc_raw(&mut self, arg0: &GprMem, arg1: Gpr) -> AssemblerOutputs;
    fn x64_rolw_mi_raw(&mut self, arg0: &GprMem, arg1: u8) -> AssemblerOutputs;
    fn x64_rolw_m1_raw(&mut self, arg0: &GprMem) -> AssemblerOutputs;
    fn x64_roll_mc_raw(&mut self, arg0: &GprMem, arg1: Gpr) -> AssemblerOutputs;
    fn x64_roll_mi_raw(&mut self, arg0: &GprMem, arg1: u8) -> AssemblerOutputs;
    fn x64_roll_m1_raw(&mut self, arg0: &GprMem) -> AssemblerOutputs;
    fn x64_rolq_mc_raw(&mut self, arg0: &GprMem, arg1: Gpr) -> AssemblerOutputs;
    fn x64_rolq_mi_raw(&mut self, arg0: &GprMem, arg1: u8) -> AssemblerOutputs;
    fn x64_rolq_m1_raw(&mut self, arg0: &GprMem) -> AssemblerOutputs;
    fn x64_rorb_mc_raw(&mut self, arg0: &GprMem, arg1: Gpr) -> AssemblerOutputs;
    fn x64_rorb_mi_raw(&mut self, arg0: &GprMem, arg1: u8) -> AssemblerOutputs;
    fn x64_rorb_m1_raw(&mut self, arg0: &GprMem) -> AssemblerOutputs;
    fn x64_rorw_mc_raw(&mut self, arg0: &GprMem, arg1: Gpr) -> AssemblerOutputs;
    fn x64_rorw_mi_raw(&mut self, arg0: &GprMem, arg1: u8) -> AssemblerOutputs;
    fn x64_rorw_m1_raw(&mut self, arg0: &GprMem) -> AssemblerOutputs;
    fn x64_rorl_mc_raw(&mut self, arg0: &GprMem, arg1: Gpr) -> AssemblerOutputs;
    fn x64_rorl_mi_raw(&mut self, arg0: &GprMem, arg1: u8) -> AssemblerOutputs;
    fn x64_rorl_m1_raw(&mut self, arg0: &GprMem) -> AssemblerOutputs;
    fn x64_rorq_mc_raw(&mut self, arg0: &GprMem, arg1: Gpr) -> AssemblerOutputs;
    fn x64_rorq_mi_raw(&mut self, arg0: &GprMem, arg1: u8) -> AssemblerOutputs;
    fn x64_rorq_m1_raw(&mut self, arg0: &GprMem) -> AssemblerOutputs;
    fn x64_shldw_mri_raw(&mut self, arg0: &GprMem, arg1: Gpr, arg2: u8) -> AssemblerOutputs;
    fn x64_shldw_mrc_raw(&mut self, arg0: &GprMem, arg1: Gpr, arg2: Gpr) -> AssemblerOutputs;
    fn x64_shldl_mri_raw(&mut self, arg0: &GprMem, arg1: Gpr, arg2: u8) -> AssemblerOutputs;
    fn x64_shldq_mri_raw(&mut self, arg0: &GprMem, arg1: Gpr, arg2: u8) -> AssemblerOutputs;
    fn x64_shldl_mrc_raw(&mut self, arg0: &GprMem, arg1: Gpr, arg2: Gpr) -> AssemblerOutputs;
    fn x64_shldq_mrc_raw(&mut self, arg0: &GprMem, arg1: Gpr, arg2: Gpr) -> AssemblerOutputs;
    fn x64_sarxl_rmv_raw(&mut self, arg0: &GprMem, arg1: Gpr) -> AssemblerOutputs;
    fn x64_shlxl_rmv_raw(&mut self, arg0: &GprMem, arg1: Gpr) -> AssemblerOutputs;
    fn x64_shrxl_rmv_raw(&mut self, arg0: &GprMem, arg1: Gpr) -> AssemblerOutputs;
    fn x64_sarxq_rmv_raw(&mut self, arg0: &GprMem, arg1: Gpr) -> AssemblerOutputs;
    fn x64_shlxq_rmv_raw(&mut self, arg0: &GprMem, arg1: Gpr) -> AssemblerOutputs;
    fn x64_shrxq_rmv_raw(&mut self, arg0: &GprMem, arg1: Gpr) -> AssemblerOutputs;
    fn x64_rorxl_rmi_raw(&mut self, arg0: &GprMem, arg1: u8) -> AssemblerOutputs;
    fn x64_rorxq_rmi_raw(&mut self, arg0: &GprMem, arg1: u8) -> AssemblerOutputs;
    fn x64_psllw_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_psllw_b_raw(&mut self, arg0: Xmm, arg1: u8) -> AssemblerOutputs;
    fn x64_pslld_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_pslld_b_raw(&mut self, arg0: Xmm, arg1: u8) -> AssemblerOutputs;
    fn x64_psllq_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_psllq_b_raw(&mut self, arg0: Xmm, arg1: u8) -> AssemblerOutputs;
    fn x64_vpsllw_c_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vpsllw_d_raw(&mut self, arg0: Xmm, arg1: u8) -> AssemblerOutputs;
    fn x64_vpslld_c_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vpslld_d_raw(&mut self, arg0: Xmm, arg1: u8) -> AssemblerOutputs;
    fn x64_vpsllq_c_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vpsllq_d_raw(&mut self, arg0: Xmm, arg1: u8) -> AssemblerOutputs;
    fn x64_vpslld_g_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vpslld_f_raw(&mut self, arg0: &XmmMem, arg1: u8) -> AssemblerOutputs;
    fn x64_vpsllq_g_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vpsllq_f_raw(&mut self, arg0: &XmmMem, arg1: u8) -> AssemblerOutputs;
    fn x64_psraw_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_psraw_b_raw(&mut self, arg0: Xmm, arg1: u8) -> AssemblerOutputs;
    fn x64_psrad_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_psrad_b_raw(&mut self, arg0: Xmm, arg1: u8) -> AssemblerOutputs;
    fn x64_psrlw_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_psrlw_b_raw(&mut self, arg0: Xmm, arg1: u8) -> AssemblerOutputs;
    fn x64_psrld_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_psrld_b_raw(&mut self, arg0: Xmm, arg1: u8) -> AssemblerOutputs;
    fn x64_psrlq_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_psrlq_b_raw(&mut self, arg0: Xmm, arg1: u8) -> AssemblerOutputs;
    fn x64_vpsraw_c_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vpsraw_d_raw(&mut self, arg0: Xmm, arg1: u8) -> AssemblerOutputs;
    fn x64_vpsrad_c_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vpsrad_d_raw(&mut self, arg0: Xmm, arg1: u8) -> AssemblerOutputs;
    fn x64_vpsrlw_c_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vpsrlw_d_raw(&mut self, arg0: Xmm, arg1: u8) -> AssemblerOutputs;
    fn x64_vpsrld_c_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vpsrld_d_raw(&mut self, arg0: Xmm, arg1: u8) -> AssemblerOutputs;
    fn x64_vpsrlq_c_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vpsrlq_d_raw(&mut self, arg0: Xmm, arg1: u8) -> AssemblerOutputs;
    fn x64_vpsrad_g_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vpsrad_f_raw(&mut self, arg0: &XmmMem, arg1: u8) -> AssemblerOutputs;
    fn x64_vpsraq_g_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vpsraq_f_raw(&mut self, arg0: &XmmMem, arg1: u8) -> AssemblerOutputs;
    fn x64_vpsrld_g_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vpsrld_f_raw(&mut self, arg0: &XmmMem, arg1: u8) -> AssemblerOutputs;
    fn x64_vpsrlq_g_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vpsrlq_f_raw(&mut self, arg0: &XmmMem, arg1: u8) -> AssemblerOutputs;
    fn x64_sqrtss_a_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_sqrtsd_a_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_sqrtps_a_raw(&mut self, arg0: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_sqrtpd_a_raw(&mut self, arg0: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_vsqrtss_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vsqrtsd_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vsqrtps_b_raw(&mut self, arg0: &XmmMem) -> AssemblerOutputs;
    fn x64_vsqrtpd_b_raw(&mut self, arg0: &XmmMem) -> AssemblerOutputs;
    fn x64_popw_m_raw(&mut self, arg0: &GprMem) -> AssemblerOutputs;
    fn x64_popq_m_raw(&mut self, arg0: &GprMem) -> AssemblerOutputs;
    fn x64_popw_o_raw(&mut self, ) -> AssemblerOutputs;
    fn x64_popq_o_raw(&mut self, ) -> AssemblerOutputs;
    fn x64_subb_i_raw(&mut self, arg0: Gpr, arg1: u8) -> AssemblerOutputs;
    fn x64_subw_i_raw(&mut self, arg0: Gpr, arg1: u16) -> AssemblerOutputs;
    fn x64_subl_i_raw(&mut self, arg0: Gpr, arg1: u32) -> AssemblerOutputs;
    fn x64_subq_i_sxl_raw(&mut self, arg0: Gpr, arg1: i32) -> AssemblerOutputs;
    fn x64_subb_mi_raw(&mut self, arg0: &GprMem, arg1: u8) -> AssemblerOutputs;
    fn x64_subw_mi_raw(&mut self, arg0: &GprMem, arg1: u16) -> AssemblerOutputs;
    fn x64_subl_mi_raw(&mut self, arg0: &GprMem, arg1: u32) -> AssemblerOutputs;
    fn x64_subq_mi_sxl_raw(&mut self, arg0: &GprMem, arg1: i32) -> AssemblerOutputs;
    fn x64_subl_mi_sxb_raw(&mut self, arg0: &GprMem, arg1: i8) -> AssemblerOutputs;
    fn x64_subq_mi_sxb_raw(&mut self, arg0: &GprMem, arg1: i8) -> AssemblerOutputs;
    fn x64_subb_mr_raw(&mut self, arg0: &GprMem, arg1: Gpr) -> AssemblerOutputs;
    fn x64_subw_mr_raw(&mut self, arg0: &GprMem, arg1: Gpr) -> AssemblerOutputs;
    fn x64_subl_mr_raw(&mut self, arg0: &GprMem, arg1: Gpr) -> AssemblerOutputs;
    fn x64_subq_mr_raw(&mut self, arg0: &GprMem, arg1: Gpr) -> AssemblerOutputs;
    fn x64_subb_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_subw_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_subl_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_subq_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_sbbb_i_raw(&mut self, arg0: Gpr, arg1: u8) -> AssemblerOutputs;
    fn x64_sbbw_i_raw(&mut self, arg0: Gpr, arg1: u16) -> AssemblerOutputs;
    fn x64_sbbl_i_raw(&mut self, arg0: Gpr, arg1: u32) -> AssemblerOutputs;
    fn x64_sbbq_i_sxl_raw(&mut self, arg0: Gpr, arg1: i32) -> AssemblerOutputs;
    fn x64_sbbb_mi_raw(&mut self, arg0: &GprMem, arg1: u8) -> AssemblerOutputs;
    fn x64_sbbw_mi_raw(&mut self, arg0: &GprMem, arg1: u16) -> AssemblerOutputs;
    fn x64_sbbl_mi_raw(&mut self, arg0: &GprMem, arg1: u32) -> AssemblerOutputs;
    fn x64_sbbq_mi_sxl_raw(&mut self, arg0: &GprMem, arg1: i32) -> AssemblerOutputs;
    fn x64_sbbl_mi_sxb_raw(&mut self, arg0: &GprMem, arg1: i8) -> AssemblerOutputs;
    fn x64_sbbq_mi_sxb_raw(&mut self, arg0: &GprMem, arg1: i8) -> AssemblerOutputs;
    fn x64_sbbb_mr_raw(&mut self, arg0: &GprMem, arg1: Gpr) -> AssemblerOutputs;
    fn x64_sbbw_mr_raw(&mut self, arg0: &GprMem, arg1: Gpr) -> AssemblerOutputs;
    fn x64_sbbl_mr_raw(&mut self, arg0: &GprMem, arg1: Gpr) -> AssemblerOutputs;
    fn x64_sbbq_mr_raw(&mut self, arg0: &GprMem, arg1: Gpr) -> AssemblerOutputs;
    fn x64_sbbb_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_sbbw_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_sbbl_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_sbbq_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_lock_subb_mi_raw(&mut self, arg0: &SyntheticAmode, arg1: u8) -> AssemblerOutputs;
    fn x64_lock_subw_mi_raw(&mut self, arg0: &SyntheticAmode, arg1: u16) -> AssemblerOutputs;
    fn x64_lock_subl_mi_raw(&mut self, arg0: &SyntheticAmode, arg1: u32) -> AssemblerOutputs;
    fn x64_lock_subq_mi_sxl_raw(&mut self, arg0: &SyntheticAmode, arg1: i32) -> AssemblerOutputs;
    fn x64_lock_subl_mi_sxb_raw(&mut self, arg0: &SyntheticAmode, arg1: i8) -> AssemblerOutputs;
    fn x64_lock_subq_mi_sxb_raw(&mut self, arg0: &SyntheticAmode, arg1: i8) -> AssemblerOutputs;
    fn x64_lock_subb_mr_raw(&mut self, arg0: &SyntheticAmode, arg1: Gpr) -> AssemblerOutputs;
    fn x64_lock_subw_mr_raw(&mut self, arg0: &SyntheticAmode, arg1: Gpr) -> AssemblerOutputs;
    fn x64_lock_subl_mr_raw(&mut self, arg0: &SyntheticAmode, arg1: Gpr) -> AssemblerOutputs;
    fn x64_lock_subq_mr_raw(&mut self, arg0: &SyntheticAmode, arg1: Gpr) -> AssemblerOutputs;
    fn x64_lock_sbbb_mi_raw(&mut self, arg0: &SyntheticAmode, arg1: u8) -> AssemblerOutputs;
    fn x64_lock_sbbw_mi_raw(&mut self, arg0: &SyntheticAmode, arg1: u16) -> AssemblerOutputs;
    fn x64_lock_sbbl_mi_raw(&mut self, arg0: &SyntheticAmode, arg1: u32) -> AssemblerOutputs;
    fn x64_lock_sbbq_mi_sxl_raw(&mut self, arg0: &SyntheticAmode, arg1: i32) -> AssemblerOutputs;
    fn x64_lock_sbbl_mi_sxb_raw(&mut self, arg0: &SyntheticAmode, arg1: i8) -> AssemblerOutputs;
    fn x64_lock_sbbq_mi_sxb_raw(&mut self, arg0: &SyntheticAmode, arg1: i8) -> AssemblerOutputs;
    fn x64_lock_sbbb_mr_raw(&mut self, arg0: &SyntheticAmode, arg1: Gpr) -> AssemblerOutputs;
    fn x64_lock_sbbw_mr_raw(&mut self, arg0: &SyntheticAmode, arg1: Gpr) -> AssemblerOutputs;
    fn x64_lock_sbbl_mr_raw(&mut self, arg0: &SyntheticAmode, arg1: Gpr) -> AssemblerOutputs;
    fn x64_lock_sbbq_mr_raw(&mut self, arg0: &SyntheticAmode, arg1: Gpr) -> AssemblerOutputs;
    fn x64_subss_a_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_subsd_a_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_subps_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_subpd_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_psubb_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_psubw_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_psubd_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_psubq_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_psubsb_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_psubsw_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_psubusb_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_psubusw_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_vsubss_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vsubsd_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vsubps_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vsubpd_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vpsubb_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vpsubw_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vpsubd_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vpsubq_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vpsubsb_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vpsubsw_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vpsubusb_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vpsubusw_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_unpcklps_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_unpcklpd_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_unpckhps_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_vunpcklps_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vunpcklpd_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vunpckhps_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_punpckhbw_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_punpckhwd_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_punpckhdq_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_punpckhqdq_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_punpcklwd_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_punpcklbw_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_punpckldq_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_punpcklqdq_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_vpunpckhbw_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vpunpckhwd_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vpunpckhdq_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vpunpckhqdq_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vpunpcklwd_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vpunpcklbw_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vpunpckldq_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vpunpcklqdq_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_xorb_i_raw(&mut self, arg0: Gpr, arg1: u8) -> AssemblerOutputs;
    fn x64_xorw_i_raw(&mut self, arg0: Gpr, arg1: u16) -> AssemblerOutputs;
    fn x64_xorl_i_raw(&mut self, arg0: Gpr, arg1: u32) -> AssemblerOutputs;
    fn x64_xorq_i_sxl_raw(&mut self, arg0: Gpr, arg1: i32) -> AssemblerOutputs;
    fn x64_xorb_mi_raw(&mut self, arg0: &GprMem, arg1: u8) -> AssemblerOutputs;
    fn x64_xorw_mi_raw(&mut self, arg0: &GprMem, arg1: u16) -> AssemblerOutputs;
    fn x64_xorl_mi_raw(&mut self, arg0: &GprMem, arg1: u32) -> AssemblerOutputs;
    fn x64_xorq_mi_sxl_raw(&mut self, arg0: &GprMem, arg1: i32) -> AssemblerOutputs;
    fn x64_xorl_mi_sxb_raw(&mut self, arg0: &GprMem, arg1: i8) -> AssemblerOutputs;
    fn x64_xorq_mi_sxb_raw(&mut self, arg0: &GprMem, arg1: i8) -> AssemblerOutputs;
    fn x64_xorb_mr_raw(&mut self, arg0: &GprMem, arg1: Gpr) -> AssemblerOutputs;
    fn x64_xorw_mr_raw(&mut self, arg0: &GprMem, arg1: Gpr) -> AssemblerOutputs;
    fn x64_xorl_mr_raw(&mut self, arg0: &GprMem, arg1: Gpr) -> AssemblerOutputs;
    fn x64_xorq_mr_raw(&mut self, arg0: &GprMem, arg1: Gpr) -> AssemblerOutputs;
    fn x64_xorb_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_xorw_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_xorl_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_xorq_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem) -> AssemblerOutputs;
    fn x64_lock_xorb_mi_raw(&mut self, arg0: &SyntheticAmode, arg1: u8) -> AssemblerOutputs;
    fn x64_lock_xorw_mi_raw(&mut self, arg0: &SyntheticAmode, arg1: u16) -> AssemblerOutputs;
    fn x64_lock_xorl_mi_raw(&mut self, arg0: &SyntheticAmode, arg1: u32) -> AssemblerOutputs;
    fn x64_lock_xorq_mi_sxl_raw(&mut self, arg0: &SyntheticAmode, arg1: i32) -> AssemblerOutputs;
    fn x64_lock_xorl_mi_sxb_raw(&mut self, arg0: &SyntheticAmode, arg1: i8) -> AssemblerOutputs;
    fn x64_lock_xorq_mi_sxb_raw(&mut self, arg0: &SyntheticAmode, arg1: i8) -> AssemblerOutputs;
    fn x64_lock_xorb_mr_raw(&mut self, arg0: &SyntheticAmode, arg1: Gpr) -> AssemblerOutputs;
    fn x64_lock_xorw_mr_raw(&mut self, arg0: &SyntheticAmode, arg1: Gpr) -> AssemblerOutputs;
    fn x64_lock_xorl_mr_raw(&mut self, arg0: &SyntheticAmode, arg1: Gpr) -> AssemblerOutputs;
    fn x64_lock_xorq_mr_raw(&mut self, arg0: &SyntheticAmode, arg1: Gpr) -> AssemblerOutputs;
    fn x64_xorps_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_xorpd_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_pxor_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned) -> AssemblerOutputs;
    fn x64_vxorps_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vxorpd_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
    fn x64_vpxor_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem) -> AssemblerOutputs;
}

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 439.
#[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 492.
#[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 511.
#[derive(Clone, Debug)]
pub enum ConsumesAndProducesFlags {
    SideEffect {
        inst: MInst,
    },
    ReturnsReg {
        inst: MInst,
        result: Reg,
    },
}

/// Internal type ConsumesFlags: defined at src/prelude_lower.isle line 519.
#[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/x64/inst.isle line 7.
#[derive(Clone)]
pub enum MInst {
    CheckedSRemSeq {
        size: OperandSize,
        dividend_lo: Gpr,
        dividend_hi: Gpr,
        divisor: Gpr,
        dst_quotient: WritableGpr,
        dst_remainder: WritableGpr,
    },
    CheckedSRemSeq8 {
        dividend: Gpr,
        divisor: Gpr,
        dst: WritableGpr,
    },
    MovFromPReg {
        src: PReg,
        dst: WritableGpr,
    },
    MovToPReg {
        src: Gpr,
        dst: PReg,
    },
    XmmCmove {
        ty: Type,
        cc: CC,
        consequent: Xmm,
        alternative: Xmm,
        dst: WritableXmm,
    },
    StackProbeLoop {
        tmp: WritableReg,
        frame_size: u32,
        guard_size: u32,
    },
    CvtUint64ToFloatSeq {
        dst_size: OperandSize,
        src: Gpr,
        dst: WritableXmm,
        tmp_gpr1: WritableGpr,
        tmp_gpr2: WritableGpr,
    },
    CvtFloatToSintSeq {
        dst_size: OperandSize,
        src_size: OperandSize,
        is_saturating: bool,
        src: Xmm,
        dst: WritableGpr,
        tmp_gpr: WritableGpr,
        tmp_xmm: WritableXmm,
    },
    CvtFloatToUintSeq {
        dst_size: OperandSize,
        src_size: OperandSize,
        is_saturating: bool,
        src: Xmm,
        dst: WritableGpr,
        tmp_gpr: WritableGpr,
        tmp_xmm: WritableXmm,
        tmp_xmm2: WritableXmm,
    },
    XmmMinMaxSeq {
        size: OperandSize,
        is_min: bool,
        lhs: Xmm,
        rhs: Xmm,
        dst: WritableXmm,
    },
    CallKnown {
        info: BoxCallInfo,
    },
    CallUnknown {
        info: BoxCallIndInfo,
    },
    ReturnCallKnown {
        info: BoxReturnCallInfo,
    },
    ReturnCallUnknown {
        info: BoxReturnCallIndInfo,
    },
    Args {
        args: VecArgPair,
    },
    Rets {
        rets: VecRetPair,
    },
    StackSwitchBasic {
        store_context_ptr: Gpr,
        load_context_ptr: Gpr,
        in_payload0: Gpr,
        out_payload0: WritableGpr,
    },
    JmpKnown {
        dst: MachLabel,
    },
    WinchJmpIf {
        cc: CC,
        taken: MachLabel,
    },
    JmpCond {
        cc: CC,
        taken: MachLabel,
        not_taken: MachLabel,
    },
    JmpCondOr {
        cc1: CC,
        cc2: CC,
        taken: MachLabel,
        not_taken: MachLabel,
    },
    JmpTableSeq {
        idx: Reg,
        tmp1: WritableReg,
        tmp2: WritableReg,
        default_target: MachLabel,
        targets: BoxVecMachLabel,
    },
    TrapIf {
        cc: CC,
        trap_code: TrapCode,
    },
    TrapIfAnd {
        cc1: CC,
        cc2: CC,
        trap_code: TrapCode,
    },
    TrapIfOr {
        cc1: CC,
        cc2: CC,
        trap_code: TrapCode,
    },
    LoadExtName {
        dst: WritableGpr,
        name: BoxExternalName,
        offset: i64,
        distance: RelocDistance,
    },
    AtomicRmwSeq {
        ty: Type,
        op: AtomicRmwSeqOp,
        mem: SyntheticAmode,
        operand: Gpr,
        temp: WritableGpr,
        dst_old: WritableGpr,
    },
    Atomic128RmwSeq {
        op: Atomic128RmwSeqOp,
        mem: BoxSyntheticAmode,
        operand_low: Gpr,
        operand_high: Gpr,
        temp_low: WritableGpr,
        temp_high: WritableGpr,
        dst_old_low: WritableGpr,
        dst_old_high: WritableGpr,
    },
    Atomic128XchgSeq {
        mem: SyntheticAmode,
        operand_low: Gpr,
        operand_high: Gpr,
        dst_old_low: WritableGpr,
        dst_old_high: WritableGpr,
    },
    XmmUninitializedValue {
        dst: WritableXmm,
    },
    GprUninitializedValue {
        dst: WritableGpr,
    },
    ElfTlsGetAddr {
        symbol: ExternalName,
        dst: WritableGpr,
    },
    MachOTlsGetAddr {
        symbol: ExternalName,
        dst: WritableGpr,
    },
    CoffTlsGetAddr {
        symbol: ExternalName,
        dst: WritableGpr,
        tmp: WritableGpr,
    },
    Unwind {
        inst: UnwindInst,
    },
    DummyUse {
        reg: Reg,
    },
    LabelAddress {
        dst: WritableGpr,
        label: MachLabel,
    },
    SequencePoint,
    External {
        inst: AssemblerInst,
    },
}

/// Internal type Amode: defined at src/isa/x64/inst.isle line 419.
#[derive(Clone, Debug)]
pub enum Amode {
    ImmReg {
        simm32: i32,
        base: Reg,
        flags: MemFlags,
    },
    ImmRegRegShift {
        simm32: i32,
        base: Gpr,
        index: Gpr,
        shift: u8,
        flags: MemFlags,
    },
    RipRelative {
        target: MachLabel,
    },
}

/// Internal type Imm8Gpr: defined at src/isa/x64/inst.isle line 607.
#[derive(Clone, Debug)]
pub enum Imm8Gpr {
    Imm8 {
        imm: u8,
    },
    Gpr {
        reg: Gpr,
    },
}

/// Internal type RegisterClass: defined at src/isa/x64/inst.isle line 922.
#[derive(Clone, Debug)]
pub enum RegisterClass {
    Gpr {
        single_register: bool,
    },
    Xmm,
}

/// Internal type ExtendKind: defined at src/isa/x64/inst.isle line 1175.
#[derive(Copy, Clone, PartialEq, Eq, Debug)]
pub enum ExtendKind {
    Sign,
    Zero,
}

/// Internal type ProduceFlagsOp: defined at src/isa/x64/inst.isle line 1533.
#[derive(Copy, Clone, PartialEq, Eq, Debug)]
pub enum ProduceFlagsOp {
    Add,
    Sub,
}

/// Internal type ChainFlagsOp: defined at src/isa/x64/inst.isle line 1550.
#[derive(Copy, Clone, PartialEq, Eq, Debug)]
pub enum ChainFlagsOp {
    Adc,
    Sbb,
}

/// Internal type ProduceFlagsSideEffectOp: defined at src/isa/x64/inst.isle line 1564.
#[derive(Copy, Clone, PartialEq, Eq, Debug)]
pub enum ProduceFlagsSideEffectOp {
    Or,
    Sbb,
}

/// Internal type CondResult: defined at src/isa/x64/inst.isle line 3405.
#[derive(Clone, Debug)]
pub enum CondResult {
    CC {
        producer: ProducesFlags,
        cc: CC,
    },
    And {
        producer: ProducesFlags,
        cc1: CC,
        cc2: CC,
    },
    Or {
        producer: ProducesFlags,
        cc1: CC,
        cc2: CC,
    },
}

/// Internal type AtomicRmwSeqOp: defined at src/isa/x64/inst.isle line 3742.
#[derive(Copy, Clone, PartialEq, Eq, Debug)]
pub enum AtomicRmwSeqOp {
    And,
    Nand,
    Or,
    Xor,
    Umin,
    Umax,
    Smin,
    Smax,
}

/// Internal type Atomic128RmwSeqOp: defined at src/isa/x64/inst.isle line 3762.
#[derive(Copy, Clone, PartialEq, Eq, Debug)]
pub enum Atomic128RmwSeqOp {
    Add,
    Sub,
    And,
    Nand,
    Or,
    Xor,
    Umin,
    Umax,
    Smin,
    Smax,
}

/// Internal type AssemblerOutputs: defined at <OUT_DIR>/assembler.isle line 0.
#[derive(Clone, Debug)]
pub enum AssemblerOutputs {
    SideEffect {
        inst: MInst,
    },
    RetGpr {
        inst: MInst,
        gpr: Gpr,
    },
    RetXmm {
        inst: MInst,
        xmm: Xmm,
    },
    RetValueRegs {
        inst: MInst,
        regs: ValueRegs,
    },
}

// 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 293.
    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 162.
    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 173.
        return v6;
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "multi_reg_to_pair_and_single", "src/prelude_lower.isle line 172")
}

// 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 178.
        return v4;
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "multi_reg_to_pair", "src/prelude_lower.isle line 177")
}

// 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 183.
        return v3;
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "multi_reg_to_single", "src/prelude_lower.isle line 182")
}

// 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 451.
            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 453.
            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 456.
            return v12;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "emit_side_effect", "src/prelude_lower.isle line 450")
}

// 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 466.
    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 471.
                    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 473.
                    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 475.
                return v10;
            }
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "side_effect_concat", "src/prelude_lower.isle line 470")
}

// 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 481.
    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 507.
            return v4;
        }
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "produces_flags_concat", "src/prelude_lower.isle line 506")
}

// 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 537.
            return v2;
        }
        &ProducesFlags::ProducesFlagsReturnsResultWithConsumer {
            inst: ref v3,
            result: v4,
        } => {
            // Rule at src/prelude_lower.isle line 538.
            return v4;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "produces_flags_get_reg", "src/prelude_lower.isle line 536")
}

// 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 543.
            return v3;
        }
        &ProducesFlags::ProducesFlagsReturnsResultWithConsumer {
            inst: ref v4,
            result: v5,
        } => {
            let v6 = ProducesFlags::ProducesFlagsSideEffect {
                inst: v4.clone(),
            };
            // Rule at src/prelude_lower.isle line 545.
            return v6;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "produces_flags_ignore", "src/prelude_lower.isle line 542")
}

// 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 558.
                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 552.
                return v7;
            }
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "consumes_flags_concat", "src/prelude_lower.isle line 551")
}

// 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 565.
        return v2;
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "consumes_flags_get_reg", "src/prelude_lower.isle line 564")
}

// 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 567.
        return v3;
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "consumes_flags_get_regs", "src/prelude_lower.isle line 566")
}

// 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 595.
                    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 601.
                    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 613.
                    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 629.
                    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 636.
                    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 649.
                    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 589.
                    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 581.
                    return v8;
                }
                _ => {}
            }
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "with_flags", "src/prelude_lower.isle line 579")
}

// 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 667.
    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 674.
    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 685.
                    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 690.
                    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 695.
                    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 700.
                    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 705.
                return v12;
            }
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "with_flags_side_effect", "src/prelude_lower.isle line 683")
}

// 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 714.
                            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 722.
                            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 731.
                            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 739.
                            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 748.
                            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 808.
                            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 816.
                            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 825.
                            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 833.
                            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 842.
                            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 761.
                            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 769.
                            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 778.
                            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 786.
                            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 795.
                            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 855.
                            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 863.
                            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 872.
                            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 880.
                            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 889.
                            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 901.
                        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 909.
                        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 926.
                        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 918.
                        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 934.
                        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 943.
                        return v68;
                    }
                    _ => {}
                }
            }
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "with_flags_chained", "src/prelude_lower.isle line 711")
}

// 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 1153.
    return v3;
}

// Generated as internal constructor for term operand_size_bits.
pub fn constructor_operand_size_bits<C: Context>(
    ctx: &mut C,
    arg0: &OperandSize,
) -> u16 {
    match arg0 {
        &OperandSize::Size8 => {
            // Rule at src/isa/x64/inst.isle line 356.
            return 0x8_u16;
        }
        &OperandSize::Size16 => {
            // Rule at src/isa/x64/inst.isle line 357.
            return 0x10_u16;
        }
        &OperandSize::Size32 => {
            // Rule at src/isa/x64/inst.isle line 358.
            return 0x20_u16;
        }
        &OperandSize::Size64 => {
            // Rule at src/isa/x64/inst.isle line 359.
            return 0x40_u16;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "operand_size_bits", "src/isa/x64/inst.isle line 355")
}

// Generated as internal constructor for term reg_mem_to_reg_mem_imm.
pub fn constructor_reg_mem_to_reg_mem_imm<C: Context>(
    ctx: &mut C,
    arg0: &RegMem,
) -> RegMemImm {
    match arg0 {
        &RegMem::Reg {
            reg: v1,
        } => {
            let v2 = RegMemImm::Reg {
                reg: v1,
            };
            // Rule at src/isa/x64/inst.isle line 383.
            return v2;
        }
        &RegMem::Mem {
            addr: ref v3,
        } => {
            let v4 = RegMemImm::Mem {
                addr: v3.clone(),
            };
            // Rule at src/isa/x64/inst.isle line 385.
            return v4;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "reg_mem_to_reg_mem_imm", "src/isa/x64/inst.isle line 382")
}

// Generated as internal constructor for term stackslot_amode.
pub fn constructor_stackslot_amode<C: Context>(
    ctx: &mut C,
    arg0: StackSlot,
    arg1: Offset32,
    arg2: Offset32,
) -> SyntheticAmode {
    let v3 = C::abi_stackslot_offset_into_slot_region(ctx, arg0, arg1, arg2);
    let v4 = &C::synthetic_amode_slot(ctx, v3);
    // Rule at src/isa/x64/inst.isle line 413.
    return v4.clone();
}

// Generated as internal constructor for term to_amode.
pub fn constructor_to_amode<C: Context>(
    ctx: &mut C,
    arg0: MemFlags,
    arg1: Value,
    arg2: Offset32,
) -> SyntheticAmode {
    let v5 = C::def_inst(ctx, arg1);
    if let Some(v6) = v5 {
        let v7 = &C::inst_data_value(ctx, v6);
        match v7 {
            &InstructionData::Binary {
                opcode: ref v8,
                args: ref v9,
            } => {
                if let &Opcode::Iadd = v8 {
                    let v10 = C::unpack_value_array_2(ctx, v9);
                    let v13 = &constructor_to_amode_add(ctx, arg0, v10.0, v10.1, arg2);
                    let v14 = &C::amode_to_synthetic_amode(ctx, v13);
                    // Rule at src/isa/x64/inst.isle line 511.
                    return v14.clone();
                }
            }
            &InstructionData::StackLoad {
                opcode: ref v15,
                stack_slot: v16,
                offset: v17,
            } => {
                if let &Opcode::StackAddr = v15 {
                    let v18 = &constructor_stackslot_amode(ctx, v16, v17, arg2);
                    // Rule at src/isa/x64/inst.isle line 514.
                    return v18.clone();
                }
            }
            _ => {}
        }
    }
    let v3 = &constructor_amode_imm_reg(ctx, arg0, arg1, arg2);
    let v4 = &C::amode_to_synthetic_amode(ctx, v3);
    // Rule at src/isa/x64/inst.isle line 509.
    return v4.clone();
}

// Generated as internal constructor for term to_amode_add.
pub fn constructor_to_amode_add<C: Context>(
    ctx: &mut C,
    arg0: MemFlags,
    arg1: Value,
    arg2: Value,
    arg3: Offset32,
) -> Amode {
    let v46 = C::def_inst(ctx, arg2);
    if let Some(v47) = v46 {
        let v48 = &C::inst_data_value(ctx, v47);
        if let &InstructionData::Binary {
            opcode: ref v49,
            args: ref v50,
        } = v48 {
            if let &Opcode::Iadd = v49 {
                let v51 = C::unpack_value_array_2(ctx, v50);
                let v62 = C::i64_from_iconst(ctx, v51.0);
                if let Some(v63) = v62 {
                    let v64 = C::i64_from_i32(ctx, v63);
                    if let Some(v65) = v64 {
                        let v9 = C::offset32_to_i32(ctx, arg3);
                        let v66 = C::i32_checked_add(ctx, v9, v65);
                        if let Some(v67) = v66 {
                            let v68 = C::i32_to_offset32(ctx, v67);
                            let v69 = &constructor_amode_imm_reg_reg_shift(ctx, arg0, arg1, v51.1, v68);
                            // Rule at src/isa/x64/inst.isle line 553.
                            return v69.clone();
                        }
                    }
                }
                let v54 = C::i64_from_iconst(ctx, v51.1);
                if let Some(v55) = v54 {
                    let v56 = C::i64_from_i32(ctx, v55);
                    if let Some(v57) = v56 {
                        let v9 = C::offset32_to_i32(ctx, arg3);
                        let v58 = C::i32_checked_add(ctx, v9, v57);
                        if let Some(v59) = v58 {
                            let v60 = C::i32_to_offset32(ctx, v59);
                            let v61 = &constructor_amode_imm_reg_reg_shift(ctx, arg0, arg1, v51.0, v60);
                            // Rule at src/isa/x64/inst.isle line 550.
                            return v61.clone();
                        }
                    }
                }
            }
        }
    }
    let v22 = C::def_inst(ctx, arg1);
    if let Some(v23) = v22 {
        let v24 = &C::inst_data_value(ctx, v23);
        if let &InstructionData::Binary {
            opcode: ref v25,
            args: ref v26,
        } = v24 {
            if let &Opcode::Iadd = v25 {
                let v27 = C::unpack_value_array_2(ctx, v26);
                let v38 = C::i64_from_iconst(ctx, v27.0);
                if let Some(v39) = v38 {
                    let v40 = C::i64_from_i32(ctx, v39);
                    if let Some(v41) = v40 {
                        let v9 = C::offset32_to_i32(ctx, arg3);
                        let v42 = C::i32_checked_add(ctx, v9, v41);
                        if let Some(v43) = v42 {
                            let v44 = C::i32_to_offset32(ctx, v43);
                            let v45 = &constructor_amode_imm_reg_reg_shift(ctx, arg0, v27.1, arg2, v44);
                            // Rule at src/isa/x64/inst.isle line 547.
                            return v45.clone();
                        }
                    }
                }
                let v30 = C::i64_from_iconst(ctx, v27.1);
                if let Some(v31) = v30 {
                    let v32 = C::i64_from_i32(ctx, v31);
                    if let Some(v33) = v32 {
                        let v9 = C::offset32_to_i32(ctx, arg3);
                        let v34 = C::i32_checked_add(ctx, v9, v33);
                        if let Some(v35) = v34 {
                            let v36 = C::i32_to_offset32(ctx, v35);
                            let v37 = &constructor_amode_imm_reg_reg_shift(ctx, arg0, v27.0, arg2, v36);
                            // Rule at src/isa/x64/inst.isle line 544.
                            return v37.clone();
                        }
                    }
                }
            }
        }
    }
    let v14 = C::i64_from_iconst(ctx, arg1);
    if let Some(v15) = v14 {
        let v16 = C::i64_from_i32(ctx, v15);
        if let Some(v17) = v16 {
            let v9 = C::offset32_to_i32(ctx, arg3);
            let v18 = C::i32_checked_add(ctx, v9, v17);
            if let Some(v19) = v18 {
                let v20 = C::i32_to_offset32(ctx, v19);
                let v21 = &constructor_amode_imm_reg(ctx, arg0, arg2, v20);
                // Rule at src/isa/x64/inst.isle line 541.
                return v21.clone();
            }
        }
    }
    let v5 = C::i64_from_iconst(ctx, arg2);
    if let Some(v6) = v5 {
        let v7 = C::i64_from_i32(ctx, v6);
        if let Some(v8) = v7 {
            let v9 = C::offset32_to_i32(ctx, arg3);
            let v10 = C::i32_checked_add(ctx, v9, v8);
            if let Some(v11) = v10 {
                let v12 = C::i32_to_offset32(ctx, v11);
                let v13 = &constructor_amode_imm_reg(ctx, arg0, arg1, v12);
                // Rule at src/isa/x64/inst.isle line 538.
                return v13.clone();
            }
        }
    }
    let v4 = &constructor_amode_imm_reg_reg_shift(ctx, arg0, arg1, arg2, arg3);
    // Rule at src/isa/x64/inst.isle line 536.
    return v4.clone();
}

// Generated as internal constructor for term amode_imm_reg.
pub fn constructor_amode_imm_reg<C: Context>(
    ctx: &mut C,
    arg0: MemFlags,
    arg1: Value,
    arg2: Offset32,
) -> Amode {
    let v6 = C::def_inst(ctx, arg1);
    if let Some(v7) = v6 {
        let v8 = &C::inst_data_value(ctx, v7);
        if let &InstructionData::Binary {
            opcode: ref v9,
            args: ref v10,
        } = v8 {
            if let &Opcode::Iadd = v9 {
                let v11 = C::unpack_value_array_2(ctx, v10);
                let v14 = &constructor_amode_imm_reg_reg_shift(ctx, arg0, v11.0, v11.1, arg2);
                // Rule at src/isa/x64/inst.isle line 567.
                return v14.clone();
            }
        }
    }
    let v4 = C::put_in_reg(ctx, arg1);
    let v3 = C::offset32_to_i32(ctx, arg2);
    let v5 = Amode::ImmReg {
        simm32: v3,
        base: v4,
        flags: arg0,
    };
    // Rule at src/isa/x64/inst.isle line 565.
    return v5;
}

// Generated as internal constructor for term amode_imm_reg_reg_shift.
pub fn constructor_amode_imm_reg_reg_shift<C: Context>(
    ctx: &mut C,
    arg0: MemFlags,
    arg1: Value,
    arg2: Value,
    arg3: Offset32,
) -> Amode {
    let v29 = C::def_inst(ctx, arg1);
    if let Some(v30) = v29 {
        let v31 = &C::inst_data_value(ctx, v30);
        if let &InstructionData::Binary {
            opcode: ref v32,
            args: ref v33,
        } = v31 {
            if let &Opcode::Ishl = v32 {
                let v34 = C::unpack_value_array_2(ctx, v33);
                let v37 = C::def_inst(ctx, v34.1);
                if let Some(v38) = v37 {
                    let v39 = &C::inst_data_value(ctx, v38);
                    if let &InstructionData::UnaryImm {
                        opcode: ref v40,
                        imm: v41,
                    } = v39 {
                        if let &Opcode::Iconst = v40 {
                            let v42 = C::uimm8(ctx, v41);
                            if let Some(v43) = v42 {
                                let v44 = C::u8_into_u32(ctx, v43);
                                let v45 = C::u32_lt_eq(ctx, v44, 0x3_u32);
                                if v45 == true {
                                    let v46 = constructor_put_in_gpr(ctx, arg2);
                                    let v47 = constructor_put_in_gpr(ctx, v34.0);
                                    let v4 = C::offset32_to_i32(ctx, arg3);
                                    let v48 = Amode::ImmRegRegShift {
                                        simm32: v4,
                                        base: v46,
                                        index: v47,
                                        shift: v43,
                                        flags: arg0,
                                    };
                                    // Rule at src/isa/x64/inst.isle line 584.
                                    return v48;
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    let v9 = C::def_inst(ctx, arg2);
    if let Some(v10) = v9 {
        let v11 = &C::inst_data_value(ctx, v10);
        if let &InstructionData::Binary {
            opcode: ref v12,
            args: ref v13,
        } = v11 {
            if let &Opcode::Ishl = v12 {
                let v14 = C::unpack_value_array_2(ctx, v13);
                let v17 = C::def_inst(ctx, v14.1);
                if let Some(v18) = v17 {
                    let v19 = &C::inst_data_value(ctx, v18);
                    if let &InstructionData::UnaryImm {
                        opcode: ref v20,
                        imm: v21,
                    } = v19 {
                        if let &Opcode::Iconst = v20 {
                            let v22 = C::uimm8(ctx, v21);
                            if let Some(v23) = v22 {
                                let v24 = C::u8_into_u32(ctx, v23);
                                let v26 = C::u32_lt_eq(ctx, v24, 0x3_u32);
                                if v26 == true {
                                    let v5 = constructor_put_in_gpr(ctx, arg1);
                                    let v27 = constructor_put_in_gpr(ctx, v14.0);
                                    let v4 = C::offset32_to_i32(ctx, arg3);
                                    let v28 = Amode::ImmRegRegShift {
                                        simm32: v4,
                                        base: v5,
                                        index: v27,
                                        shift: v23,
                                        flags: arg0,
                                    };
                                    // Rule at src/isa/x64/inst.isle line 581.
                                    return v28;
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    let v5 = constructor_put_in_gpr(ctx, arg1);
    let v6 = constructor_put_in_gpr(ctx, arg2);
    let v4 = C::offset32_to_i32(ctx, arg3);
    let v8 = Amode::ImmRegRegShift {
        simm32: v4,
        base: v5,
        index: v6,
        shift: 0x0_u8,
        flags: arg0,
    };
    // Rule at src/isa/x64/inst.isle line 579.
    return v8;
}

// Generated as internal constructor for term put_masked_in_imm8_gpr.
pub fn constructor_put_masked_in_imm8_gpr<C: Context>(
    ctx: &mut C,
    arg0: Value,
    arg1: Type,
) -> Imm8Gpr {
    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 v4,
            imm: v5,
        } = v3 {
            if let &Opcode::Iconst = v4 {
                let v8 = C::shift_mask(ctx, arg1);
                let v6 = C::u64_from_imm64(ctx, v5);
                let v9 = C::u8_into_u64(ctx, v8);
                let v10 = C::u64_and(ctx, v6, v9);
                let v11 = C::u64_truncate_into_u8(ctx, v10);
                let v12 = Imm8Gpr::Imm8 {
                    imm: v11,
                };
                // Rule at src/isa/x64/inst.isle line 621.
                return v12;
            }
        }
    }
    let v13 = C::fits_in_16(ctx, arg1);
    if let Some(v14) = v13 {
        let v16 = C::put_in_regs(ctx, arg0);
        let v18 = constructor_value_regs_get_gpr(ctx, v16, 0x0_usize);
        let v19 = C::shift_mask(ctx, v14);
        let v20 = C::u8_into_u32(ctx, v19);
        let v21 = RegMemImm::Imm {
            simm32: v20,
        };
        let v22 = &C::gpr_mem_imm_new(ctx, &v21);
        let v23 = constructor_x64_and(ctx, I64, v18, v22);
        let v24 = &constructor_gpr_to_imm8_gpr(ctx, v23);
        // Rule at src/isa/x64/inst.isle line 623.
        return v24.clone();
    }
    let v16 = C::put_in_regs(ctx, arg0);
    let v18 = constructor_value_regs_get_gpr(ctx, v16, 0x0_usize);
    let v25 = &constructor_gpr_to_imm8_gpr(ctx, v18);
    // Rule at src/isa/x64/inst.isle line 625.
    return v25.clone();
}

// Generated as internal constructor for term reg_to_gpr_mem_imm.
pub fn constructor_reg_to_gpr_mem_imm<C: Context>(
    ctx: &mut C,
    arg0: Reg,
) -> GprMemImm {
    let v1 = C::gpr_new(ctx, arg0);
    let v2 = &C::gpr_to_gpr_mem_imm(ctx, v1);
    // Rule at src/isa/x64/inst.isle line 828.
    return v2.clone();
}

// Generated as internal constructor for term put_in_gpr.
pub fn constructor_put_in_gpr<C: Context>(
    ctx: &mut C,
    arg0: Value,
) -> Gpr {
    let v1 = C::value_type(ctx, arg0);
    let v2 = &C::type_register_class(ctx, v1);
    if let Some(v3) = v2 {
        match v3 {
            &RegisterClass::Gpr {
                single_register: v4,
            } => {
                let v5 = C::put_in_reg(ctx, arg0);
                let v6 = C::gpr_new(ctx, v5);
                // Rule at src/isa/x64/inst.isle line 839.
                return v6;
            }
            &RegisterClass::Xmm => {
                let v5 = C::put_in_reg(ctx, arg0);
                let v8 = C::xmm_new(ctx, v5);
                let v7 = C::ty_bits(ctx, v1);
                let v9 = constructor_bitcast_xmm_to_gpr(ctx, v7, v8);
                // Rule at src/isa/x64/inst.isle line 846.
                return v9;
            }
            _ => {}
        }
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "put_in_gpr", "src/isa/x64/inst.isle line 836")
}

// Generated as internal constructor for term put_in_gpr_mem.
pub fn constructor_put_in_gpr_mem<C: Context>(
    ctx: &mut C,
    arg0: Value,
) -> GprMem {
    let v1 = &C::put_in_reg_mem(ctx, arg0);
    let v2 = &C::reg_mem_to_gpr_mem(ctx, v1);
    // Rule at src/isa/x64/inst.isle line 855.
    return v2.clone();
}

// Generated as internal constructor for term put_in_gpr_mem_imm.
pub fn constructor_put_in_gpr_mem_imm<C: Context>(
    ctx: &mut C,
    arg0: Value,
) -> GprMemImm {
    let v1 = &C::put_in_reg_mem_imm(ctx, arg0);
    let v2 = &C::gpr_mem_imm_new(ctx, v1);
    // Rule at src/isa/x64/inst.isle line 862.
    return v2.clone();
}

// Generated as internal constructor for term put_in_xmm.
pub fn constructor_put_in_xmm<C: Context>(
    ctx: &mut C,
    arg0: Value,
) -> Xmm {
    let v1 = C::put_in_reg(ctx, arg0);
    let v2 = C::xmm_new(ctx, v1);
    // Rule at src/isa/x64/inst.isle line 869.
    return v2;
}

// Generated as internal constructor for term output_gpr.
pub fn constructor_output_gpr<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
) -> InstOutput {
    let v1 = C::gpr_to_reg(ctx, arg0);
    let v2 = constructor_output_reg(ctx, v1);
    // Rule at src/isa/x64/inst.isle line 888.
    return v2;
}

// Generated as internal constructor for term value_gprs.
pub fn constructor_value_gprs<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: Gpr,
) -> ValueRegs {
    let v2 = C::gpr_to_reg(ctx, arg0);
    let v3 = C::gpr_to_reg(ctx, arg1);
    let v4 = C::value_regs(ctx, v2, v3);
    // Rule at src/isa/x64/inst.isle line 893.
    return v4;
}

// Generated as internal constructor for term output_xmm.
pub fn constructor_output_xmm<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
) -> InstOutput {
    let v1 = C::xmm_to_reg(ctx, arg0);
    let v2 = constructor_output_reg(ctx, v1);
    // Rule at src/isa/x64/inst.isle line 898.
    return v2;
}

// Generated as internal constructor for term value_regs_get_gpr.
pub fn constructor_value_regs_get_gpr<C: Context>(
    ctx: &mut C,
    arg0: ValueRegs,
    arg1: usize,
) -> Gpr {
    let v2 = C::value_regs_get(ctx, arg0, arg1);
    let v3 = C::gpr_new(ctx, v2);
    // Rule at src/isa/x64/inst.isle line 905.
    return v3;
}

// Generated as internal constructor for term gpr_to_imm8_gpr.
pub fn constructor_gpr_to_imm8_gpr<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
) -> Imm8Gpr {
    let v1 = Imm8Gpr::Gpr {
        reg: arg0,
    };
    // Rule at src/isa/x64/inst.isle line 910.
    return v1;
}

// Generated as internal constructor for term lo_gpr.
pub fn constructor_lo_gpr<C: Context>(
    ctx: &mut C,
    arg0: Value,
) -> Gpr {
    let v1 = constructor_lo_reg(ctx, arg0);
    let v2 = C::gpr_new(ctx, v1);
    // Rule at src/isa/x64/inst.isle line 914.
    return v2;
}

// Generated as internal constructor for term sink_load_to_gpr_mem_imm.
pub fn constructor_sink_load_to_gpr_mem_imm<C: Context>(
    ctx: &mut C,
    arg0: &SinkableLoad,
) -> GprMemImm {
    let v1 = &constructor_sink_load_to_reg_mem_imm(ctx, arg0);
    let v2 = &C::gpr_mem_imm_new(ctx, v1);
    // Rule at src/isa/x64/inst.isle line 1074.
    return v2.clone();
}

// Generated as internal constructor for term sink_load_to_xmm_mem.
pub fn constructor_sink_load_to_xmm_mem<C: Context>(
    ctx: &mut C,
    arg0: &SinkableLoad,
) -> XmmMem {
    let v1 = &constructor_sink_load_to_reg_mem(ctx, arg0);
    let v2 = &C::reg_mem_to_xmm_mem(ctx, v1);
    // Rule at src/isa/x64/inst.isle line 1078.
    return v2.clone();
}

// Generated as internal constructor for term sink_load_to_reg_mem.
pub fn constructor_sink_load_to_reg_mem<C: Context>(
    ctx: &mut C,
    arg0: &SinkableLoad,
) -> RegMem {
    let v1 = &C::sink_load(ctx, arg0);
    let v2 = RegMem::Mem {
        addr: v1.clone(),
    };
    // Rule at src/isa/x64/inst.isle line 1082.
    return v2;
}

// Generated as internal constructor for term sink_load_to_gpr_mem.
pub fn constructor_sink_load_to_gpr_mem<C: Context>(
    ctx: &mut C,
    arg0: &SinkableLoad,
) -> GprMem {
    let v1 = &C::sink_load(ctx, arg0);
    let v2 = RegMem::Mem {
        addr: v1.clone(),
    };
    let v3 = &C::reg_mem_to_gpr_mem(ctx, &v2);
    // Rule at src/isa/x64/inst.isle line 1085.
    return v3.clone();
}

// Generated as internal constructor for term sink_load_to_reg_mem_imm.
pub fn constructor_sink_load_to_reg_mem_imm<C: Context>(
    ctx: &mut C,
    arg0: &SinkableLoad,
) -> RegMemImm {
    let v1 = &C::sink_load(ctx, arg0);
    let v2 = RegMemImm::Mem {
        addr: v1.clone(),
    };
    // Rule at src/isa/x64/inst.isle line 1090.
    return v2;
}

// Generated as internal constructor for term xmm_uninit_value.
pub fn constructor_xmm_uninit_value<C: Context>(
    ctx: &mut C,
) -> Xmm {
    let v0 = C::temp_writable_xmm(ctx);
    let v1 = MInst::XmmUninitializedValue {
        dst: v0,
    };
    let v2 = C::emit(ctx, &v1);
    let v3 = C::writable_xmm_to_xmm(ctx, v0);
    // Rule at src/isa/x64/inst.isle line 1102.
    return v3;
}

// Generated as internal constructor for term gpr_uninit_value.
pub fn constructor_gpr_uninit_value<C: Context>(
    ctx: &mut C,
) -> Gpr {
    let v0 = C::temp_writable_gpr(ctx);
    let v1 = MInst::GprUninitializedValue {
        dst: v0,
    };
    let v2 = C::emit(ctx, &v1);
    let v3 = C::writable_gpr_to_gpr(ctx, v0);
    // Rule at src/isa/x64/inst.isle line 1109.
    return v3;
}

// Generated as internal constructor for term load_ext_name.
pub fn constructor_load_ext_name<C: Context>(
    ctx: &mut C,
    arg0: ExternalName,
    arg1: i64,
    arg2: &RelocDistance,
) -> Gpr {
    let v3 = C::temp_writable_gpr(ctx);
    let v4 = C::box_external_name(ctx, arg0);
    let v5 = MInst::LoadExtName {
        dst: v3,
        name: v4,
        offset: arg1,
        distance: arg2.clone(),
    };
    let v6 = C::emit(ctx, &v5);
    let v7 = C::writable_gpr_to_gpr(ctx, v3);
    // Rule at src/isa/x64/inst.isle line 1116.
    return v7;
}

// Generated as internal constructor for term xmm_min_max_seq.
pub fn constructor_xmm_min_max_seq<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: bool,
    arg2: Xmm,
    arg3: Xmm,
) -> Xmm {
    let v4 = C::temp_writable_xmm(ctx);
    let v5 = &C::operand_size_of_type_32_64(ctx, arg0);
    let v6 = MInst::XmmMinMaxSeq {
        size: v5.clone(),
        is_min: arg1,
        lhs: arg2,
        rhs: arg3,
        dst: v4,
    };
    let v7 = C::emit(ctx, &v6);
    let v8 = C::writable_xmm_to_xmm(ctx, v4);
    // Rule at src/isa/x64/inst.isle line 1123.
    return v8;
}

// Generated as internal constructor for term cvt_u64_to_float_seq.
pub fn constructor_cvt_u64_to_float_seq<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Gpr,
) -> Xmm {
    let v2 = &C::raw_operand_size_of_type(ctx, arg0);
    let v3 = C::temp_writable_xmm(ctx);
    let v4 = C::temp_writable_gpr(ctx);
    let v5 = C::temp_writable_gpr(ctx);
    let v6 = MInst::CvtUint64ToFloatSeq {
        dst_size: v2.clone(),
        src: arg1,
        dst: v3,
        tmp_gpr1: v4,
        tmp_gpr2: v5,
    };
    let v7 = C::emit(ctx, &v6);
    let v8 = C::writable_xmm_to_xmm(ctx, v3);
    // Rule at src/isa/x64/inst.isle line 1130.
    return v8;
}

// Generated as internal constructor for term cvt_float_to_uint_seq.
pub fn constructor_cvt_float_to_uint_seq<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: bool,
) -> Gpr {
    let v4 = &C::raw_operand_size_of_type(ctx, arg0);
    let v2 = C::value_type(ctx, arg1);
    let v5 = &C::raw_operand_size_of_type(ctx, v2);
    let v6 = C::temp_writable_gpr(ctx);
    let v7 = C::temp_writable_xmm(ctx);
    let v8 = C::temp_writable_xmm(ctx);
    let v9 = C::temp_writable_gpr(ctx);
    let v10 = constructor_put_in_xmm(ctx, arg1);
    let v11 = MInst::CvtFloatToUintSeq {
        dst_size: v4.clone(),
        src_size: v5.clone(),
        is_saturating: arg2,
        src: v10,
        dst: v6,
        tmp_gpr: v9,
        tmp_xmm: v7,
        tmp_xmm2: v8,
    };
    let v12 = C::emit(ctx, &v11);
    let v13 = C::writable_gpr_to_gpr(ctx, v6);
    // Rule at src/isa/x64/inst.isle line 1139.
    return v13;
}

// Generated as internal constructor for term cvt_float_to_sint_seq.
pub fn constructor_cvt_float_to_sint_seq<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: bool,
) -> Gpr {
    let v4 = &C::raw_operand_size_of_type(ctx, arg0);
    let v2 = C::value_type(ctx, arg1);
    let v5 = &C::raw_operand_size_of_type(ctx, v2);
    let v6 = C::temp_writable_gpr(ctx);
    let v7 = C::temp_writable_xmm(ctx);
    let v8 = C::temp_writable_gpr(ctx);
    let v9 = constructor_put_in_xmm(ctx, arg1);
    let v10 = MInst::CvtFloatToSintSeq {
        dst_size: v4.clone(),
        src_size: v5.clone(),
        is_saturating: arg2,
        src: v9,
        dst: v6,
        tmp_gpr: v8,
        tmp_xmm: v7,
    };
    let v11 = C::emit(ctx, &v10);
    let v12 = C::writable_gpr_to_gpr(ctx, v6);
    // Rule at src/isa/x64/inst.isle line 1151.
    return v12;
}

// Generated as internal constructor for term mov_from_preg.
pub fn constructor_mov_from_preg<C: Context>(
    ctx: &mut C,
    arg0: PReg,
) -> Reg {
    let v1 = C::temp_writable_gpr(ctx);
    let v2 = MInst::MovFromPReg {
        src: arg0,
        dst: v1,
    };
    let v3 = C::emit(ctx, &v2);
    let v4 = constructor_writable_gpr_to_r_reg(ctx, v1);
    // Rule at src/isa/x64/inst.isle line 1163.
    return v4;
}

// Generated as internal constructor for term extend_to_gpr.
pub fn constructor_extend_to_gpr<C: Context>(
    ctx: &mut C,
    arg0: Value,
    arg1: Type,
    arg2: &ExtendKind,
) -> Gpr {
    let v1 = C::value_type(ctx, arg0);
    if v1 == arg1 {
        let v4 = constructor_put_in_gpr(ctx, arg0);
        // Rule at src/isa/x64/inst.isle line 1211.
        return v4;
    }
    if v1 == I32 {
        if arg1 == I64 {
            if let &ExtendKind::Zero = arg2 {
                let v5 = constructor_value32_zeros_upper32(ctx, arg0);
                if v5 == true {
                    let v6 = C::put_in_reg(ctx, arg0);
                    let v10 = C::add_range_fact(ctx, v6, 0x40_u16, 0x0_u64, 0xffffffff_u64);
                    let v11 = C::gpr_new(ctx, v10);
                    // Rule at src/isa/x64/inst.isle line 1219.
                    return v11;
                }
            }
        }
    }
    let v12 = &C::sinkable_load_exact(ctx, arg0);
    if let Some(v13) = v12 {
        let v14 = &constructor_sink_load_to_gpr_mem(ctx, v13);
        let v15 = constructor_extend_to_gpr_types(ctx, v14, v1, arg1, arg2);
        // Rule at src/isa/x64/inst.isle line 1225.
        return v15;
    }
    let v16 = &constructor_put_in_gpr_mem(ctx, arg0);
    let v17 = constructor_extend_to_gpr_types(ctx, v16, v1, arg1, arg2);
    // Rule at src/isa/x64/inst.isle line 1229.
    return v17;
}

// Generated as internal constructor for term extend_to_gpr_types.
pub fn constructor_extend_to_gpr_types<C: Context>(
    ctx: &mut C,
    arg0: &GprMem,
    arg1: Type,
    arg2: Type,
    arg3: &ExtendKind,
) -> Gpr {
    let v5 = &C::operand_size_of_type_32_64(ctx, arg2);
    let v6 = constructor_operand_size_bits(ctx, v5);
    let v4 = C::ty_bits_u16(ctx, arg1);
    let v7 = &C::ext_mode(ctx, v4, v6);
    let v8 = constructor_extend(ctx, arg3, arg2, v7, arg0);
    // Rule at src/isa/x64/inst.isle line 1234.
    return v8;
}

// Generated as internal constructor for term extend.
pub fn constructor_extend<C: Context>(
    ctx: &mut C,
    arg0: &ExtendKind,
    arg1: Type,
    arg2: &ExtMode,
    arg3: &GprMem,
) -> Gpr {
    match arg0 {
        &ExtendKind::Sign => {
            let v5 = constructor_x64_movsx(ctx, arg2, arg3);
            // Rule at src/isa/x64/inst.isle line 1253.
            return v5;
        }
        &ExtendKind::Zero => {
            let v4 = constructor_x64_movzx(ctx, arg2, arg3);
            // Rule at src/isa/x64/inst.isle line 1249.
            return v4;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "extend", "src/isa/x64/inst.isle line 1246")
}

// Generated as internal constructor for term value32_zeros_upper32.
pub fn constructor_value32_zeros_upper32<C: Context>(
    ctx: &mut C,
    arg0: Value,
) -> bool {
    let v1 = C::def_inst(ctx, arg0);
    if let Some(v2) = v1 {
        let v3 = &C::inst_data_value(ctx, v2);
        match v3 {
            &InstructionData::Binary {
                opcode: ref v4,
                args: ref v5,
            } => {
                match v4 {
                    &Opcode::Iadd => {
                        let v9 = true;
                        // Rule at src/isa/x64/inst.isle line 1260.
                        return v9;
                    }
                    &Opcode::Isub => {
                        let v9 = true;
                        // Rule at src/isa/x64/inst.isle line 1261.
                        return v9;
                    }
                    &Opcode::Imul => {
                        let v9 = true;
                        // Rule at src/isa/x64/inst.isle line 1262.
                        return v9;
                    }
                    &Opcode::Band => {
                        let v9 = true;
                        // Rule at src/isa/x64/inst.isle line 1263.
                        return v9;
                    }
                    &Opcode::Bor => {
                        let v9 = true;
                        // Rule at src/isa/x64/inst.isle line 1264.
                        return v9;
                    }
                    &Opcode::Bxor => {
                        let v9 = true;
                        // Rule at src/isa/x64/inst.isle line 1265.
                        return v9;
                    }
                    &Opcode::Ishl => {
                        let v9 = true;
                        // Rule at src/isa/x64/inst.isle line 1266.
                        return v9;
                    }
                    &Opcode::Ushr => {
                        let v9 = true;
                        // Rule at src/isa/x64/inst.isle line 1267.
                        return v9;
                    }
                    _ => {}
                }
            }
            &InstructionData::Load {
                opcode: ref v10,
                arg: v11,
                flags: v12,
                offset: v13,
            } => {
                if let &Opcode::Uload32 = v10 {
                    let v9 = true;
                    // Rule at src/isa/x64/inst.isle line 1268.
                    return v9;
                }
            }
            _ => {}
        }
    }
    let v14 = false;
    // Rule at src/isa/x64/inst.isle line 1269.
    return v14;
}

// Generated as internal constructor for term vec_int_type.
pub fn constructor_vec_int_type<C: Context>(
    ctx: &mut C,
    arg0: Type,
) -> Type {
    let v1 = C::multi_lane(ctx, arg0);
    if let Some(v2) = v1 {
        match v2.0 {
            0x8_u32 => {
                if v2.1 == 0x10_u32 {
                    // Rule at src/isa/x64/inst.isle line 1275.
                    return I8X16;
                }
            }
            0x10_u32 => {
                if v2.1 == 0x8_u32 {
                    // Rule at src/isa/x64/inst.isle line 1276.
                    return I16X8;
                }
            }
            0x20_u32 => {
                if v2.1 == 0x4_u32 {
                    // Rule at src/isa/x64/inst.isle line 1277.
                    return I32X4;
                }
            }
            0x40_u32 => {
                if v2.1 == 0x2_u32 {
                    // Rule at src/isa/x64/inst.isle line 1278.
                    return I64X2;
                }
            }
            _ => {}
        }
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "vec_int_type", "src/isa/x64/inst.isle line 1274")
}

// Generated as internal constructor for term x64_xor_vector.
pub fn constructor_x64_xor_vector<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Xmm,
    arg2: &XmmMem,
) -> Xmm {
    match arg0 {
        F16 => {
            let v3 = constructor_x64_xorps(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 1282.
            return v3;
        }
        F32 => {
            let v3 = constructor_x64_xorps(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 1283.
            return v3;
        }
        F64 => {
            let v4 = constructor_x64_xorpd(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 1284.
            return v4;
        }
        F128 => {
            let v3 = constructor_x64_xorps(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 1285.
            return v3;
        }
        F32X4 => {
            let v3 = constructor_x64_xorps(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 1286.
            return v3;
        }
        F64X2 => {
            let v4 = constructor_x64_xorpd(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 1287.
            return v4;
        }
        _ => {}
    }
    let v5 = C::multi_lane(ctx, arg0);
    if let Some(v6) = v5 {
        let v9 = constructor_x64_pxor(ctx, arg1, arg2);
        // Rule at src/isa/x64/inst.isle line 1288.
        return v9;
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_xor_vector", "src/isa/x64/inst.isle line 1281")
}

// Generated as internal constructor for term vector_all_ones.
pub fn constructor_vector_all_ones<C: Context>(
    ctx: &mut C,
) -> Xmm {
    let v0 = constructor_xmm_uninit_value(ctx);
    let v1 = &C::xmm_to_xmm_mem(ctx, v0);
    let v2 = constructor_x64_pcmpeqd(ctx, v0, v1);
    // Rule at src/isa/x64/inst.isle line 1300.
    return v2;
}

// Generated as internal constructor for term mov_rmi_to_xmm.
pub fn constructor_mov_rmi_to_xmm<C: Context>(
    ctx: &mut C,
    arg0: &RegMemImm,
) -> XmmMemImm {
    match arg0 {
        &RegMemImm::Reg {
            reg: v4,
        } => {
            let v5 = &C::reg_to_gpr_mem(ctx, v4);
            let v6 = constructor_x64_movd_to_xmm(ctx, v5);
            let v7 = &C::xmm_to_xmm_mem_imm(ctx, v6);
            // Rule at src/isa/x64/inst.isle line 1308.
            return v7.clone();
        }
        &RegMemImm::Mem {
            addr: ref v1,
        } => {
            let v2 = &C::xmm_mem_imm_new(ctx, arg0);
            // Rule at src/isa/x64/inst.isle line 1306.
            return v2.clone();
        }
        &RegMemImm::Imm {
            simm32: v3,
        } => {
            let v2 = &C::xmm_mem_imm_new(ctx, arg0);
            // Rule at src/isa/x64/inst.isle line 1307.
            return v2.clone();
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "mov_rmi_to_xmm", "src/isa/x64/inst.isle line 1305")
}

// Generated as internal constructor for term call_known.
pub fn constructor_call_known<C: Context>(
    ctx: &mut C,
    arg0: &BoxCallInfo,
) -> SideEffectNoResult {
    let v1 = MInst::CallKnown {
        info: arg0.clone(),
    };
    let v2 = SideEffectNoResult::Inst {
        inst: v1,
    };
    // Rule at src/isa/x64/inst.isle line 1326.
    return v2;
}

// Generated as internal constructor for term call_unknown.
pub fn constructor_call_unknown<C: Context>(
    ctx: &mut C,
    arg0: &BoxCallIndInfo,
) -> SideEffectNoResult {
    let v1 = MInst::CallUnknown {
        info: arg0.clone(),
    };
    let v2 = SideEffectNoResult::Inst {
        inst: v1,
    };
    // Rule at src/isa/x64/inst.isle line 1331.
    return v2;
}

// Generated as internal constructor for term return_call_known.
pub fn constructor_return_call_known<C: Context>(
    ctx: &mut C,
    arg0: &BoxReturnCallInfo,
) -> SideEffectNoResult {
    let v1 = MInst::ReturnCallKnown {
        info: arg0.clone(),
    };
    let v2 = SideEffectNoResult::Inst {
        inst: v1,
    };
    // Rule at src/isa/x64/inst.isle line 1336.
    return v2;
}

// Generated as internal constructor for term return_call_unknown.
pub fn constructor_return_call_unknown<C: Context>(
    ctx: &mut C,
    arg0: &BoxReturnCallIndInfo,
) -> SideEffectNoResult {
    let v1 = MInst::ReturnCallUnknown {
        info: arg0.clone(),
    };
    let v2 = SideEffectNoResult::Inst {
        inst: v1,
    };
    // Rule at src/isa/x64/inst.isle line 1341.
    return v2;
}

// Generated as internal constructor for term x64_stack_switch_basic.
pub fn constructor_x64_stack_switch_basic<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: Gpr,
    arg2: Gpr,
) -> Gpr {
    let v3 = C::temp_writable_gpr(ctx);
    let v4 = MInst::StackSwitchBasic {
        store_context_ptr: arg0,
        load_context_ptr: arg1,
        in_payload0: arg2,
        out_payload0: v3,
    };
    let v5 = C::emit(ctx, &v4);
    let v6 = C::writable_gpr_to_gpr(ctx, v3);
    // Rule at src/isa/x64/inst.isle line 1347.
    return v6;
}

// Generated as internal constructor for term x64_load.
pub fn constructor_x64_load<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: &SyntheticAmode,
    arg2: &ExtKind,
) -> Reg {
    match arg0 {
        I64 => {
            let v11 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg1);
            let v12 = constructor_x64_movq_rm(ctx, v11);
            let v13 = C::gpr_to_reg(ctx, v12);
            // Rule at src/isa/x64/inst.isle line 1364.
            return v13;
        }
        F32 => {
            let v14 = constructor_x64_movss_load(ctx, arg1);
            let v15 = C::xmm_to_reg(ctx, v14);
            // Rule at src/isa/x64/inst.isle line 1367.
            return v15;
        }
        F64 => {
            let v16 = constructor_x64_movsd_load(ctx, arg1);
            let v17 = C::xmm_to_reg(ctx, v16);
            // Rule at src/isa/x64/inst.isle line 1370.
            return v17;
        }
        F128 => {
            let v18 = &constructor_synthetic_amode_to_xmm_mem(ctx, arg1);
            let v19 = constructor_x64_movdqu_load(ctx, v18);
            let v20 = C::xmm_to_reg(ctx, v19);
            // Rule at src/isa/x64/inst.isle line 1373.
            return v20;
        }
        F32X4 => {
            let v21 = constructor_x64_movups_load(ctx, arg1);
            let v22 = C::xmm_to_reg(ctx, v21);
            // Rule at src/isa/x64/inst.isle line 1376.
            return v22;
        }
        F64X2 => {
            let v23 = constructor_x64_movupd_load(ctx, arg1);
            let v24 = C::xmm_to_reg(ctx, v23);
            // Rule at src/isa/x64/inst.isle line 1379.
            return v24;
        }
        _ => {}
    }
    let v1 = C::fits_in_32(ctx, arg0);
    if let Some(v2) = v1 {
        if let &ExtKind::SignExtend = arg2 {
            let v5 = C::ty_bytes(ctx, v2);
            let v7 = &C::ext_mode(ctx, v5, 0x8_u16);
            let v8 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg1);
            let v9 = constructor_x64_movsx(ctx, v7, v8);
            let v10 = C::gpr_to_reg(ctx, v9);
            // Rule at src/isa/x64/inst.isle line 1360.
            return v10;
        }
    }
    let v25 = C::multi_lane(ctx, arg0);
    if let Some(v26) = v25 {
        let v18 = &constructor_synthetic_amode_to_xmm_mem(ctx, arg1);
        let v19 = constructor_x64_movdqu_load(ctx, v18);
        let v20 = C::xmm_to_reg(ctx, v19);
        // Rule at src/isa/x64/inst.isle line 1382.
        return v20;
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_load", "src/isa/x64/inst.isle line 1358")
}

// Generated as internal constructor for term x64_mov.
pub fn constructor_x64_mov<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
) -> Reg {
    let v1 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v2 = constructor_x64_movq_rm(ctx, v1);
    let v3 = C::gpr_to_reg(ctx, v2);
    // Rule at src/isa/x64/inst.isle line 1388.
    return v3;
}

// Generated as internal constructor for term x64_movzx.
pub fn constructor_x64_movzx<C: Context>(
    ctx: &mut C,
    arg0: &ExtMode,
    arg1: &GprMem,
) -> Gpr {
    match arg0 {
        &ExtMode::BL => {
            let v2 = constructor_x64_movzbl_rm(ctx, arg1);
            // Rule at src/isa/x64/inst.isle line 1412.
            return v2;
        }
        &ExtMode::BQ => {
            let v3 = constructor_x64_movzbq_rm(ctx, arg1);
            // Rule at src/isa/x64/inst.isle line 1413.
            return v3;
        }
        &ExtMode::WL => {
            let v4 = constructor_x64_movzwl_rm(ctx, arg1);
            // Rule at src/isa/x64/inst.isle line 1414.
            return v4;
        }
        &ExtMode::WQ => {
            let v5 = constructor_x64_movzwq_rm(ctx, arg1);
            // Rule at src/isa/x64/inst.isle line 1415.
            return v5;
        }
        &ExtMode::LQ => {
            let v6 = constructor_x64_movl_rm(ctx, arg1);
            // Rule at src/isa/x64/inst.isle line 1421.
            return v6;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_movzx", "src/isa/x64/inst.isle line 1390")
}

// Generated as internal constructor for term x64_movsx.
pub fn constructor_x64_movsx<C: Context>(
    ctx: &mut C,
    arg0: &ExtMode,
    arg1: &GprMem,
) -> Gpr {
    match arg0 {
        &ExtMode::BL => {
            let v2 = constructor_x64_movsbl_rm(ctx, arg1);
            // Rule at src/isa/x64/inst.isle line 1424.
            return v2;
        }
        &ExtMode::BQ => {
            let v3 = constructor_x64_movsbq_rm(ctx, arg1);
            // Rule at src/isa/x64/inst.isle line 1425.
            return v3;
        }
        &ExtMode::WL => {
            let v4 = constructor_x64_movswl_rm(ctx, arg1);
            // Rule at src/isa/x64/inst.isle line 1426.
            return v4;
        }
        &ExtMode::WQ => {
            let v5 = constructor_x64_movswq_rm(ctx, arg1);
            // Rule at src/isa/x64/inst.isle line 1427.
            return v5;
        }
        &ExtMode::LQ => {
            let v6 = constructor_x64_movslq_rm(ctx, arg1);
            // Rule at src/isa/x64/inst.isle line 1428.
            return v6;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_movsx", "src/isa/x64/inst.isle line 1423")
}

// Generated as internal constructor for term x64_movss_load.
pub fn constructor_x64_movss_load<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
) -> Xmm {
    let v1 = constructor_x64_movss_a_m_or_avx(ctx, arg0);
    // Rule at src/isa/x64/inst.isle line 1431.
    return v1;
}

// Generated as internal constructor for term x64_movss_store.
pub fn constructor_x64_movss_store<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Xmm,
) -> SideEffectNoResult {
    let v2 = &constructor_x64_movss_c_m_mem_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 1434.
    return v2.clone();
}

// Generated as internal constructor for term x64_movsd_load.
pub fn constructor_x64_movsd_load<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
) -> Xmm {
    let v1 = constructor_x64_movsd_a_m_or_avx(ctx, arg0);
    // Rule at src/isa/x64/inst.isle line 1437.
    return v1;
}

// Generated as internal constructor for term x64_movsd_store.
pub fn constructor_x64_movsd_store<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Xmm,
) -> SideEffectNoResult {
    let v2 = &constructor_x64_movsd_c_m_mem_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 1440.
    return v2.clone();
}

// Generated as internal constructor for term x64_movups_load.
pub fn constructor_x64_movups_load<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
) -> Xmm {
    let v1 = &constructor_synthetic_amode_to_xmm_mem(ctx, arg0);
    let v2 = constructor_x64_movups_a_or_avx(ctx, v1);
    // Rule at src/isa/x64/inst.isle line 1443.
    return v2;
}

// Generated as internal constructor for term x64_movups_store.
pub fn constructor_x64_movups_store<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Xmm,
) -> SideEffectNoResult {
    let v2 = &constructor_x64_movups_b_mem_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 1446.
    return v2.clone();
}

// Generated as internal constructor for term x64_movupd_load.
pub fn constructor_x64_movupd_load<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
) -> Xmm {
    let v1 = &constructor_synthetic_amode_to_xmm_mem(ctx, arg0);
    let v2 = constructor_x64_movupd_a_or_avx(ctx, v1);
    // Rule at src/isa/x64/inst.isle line 1449.
    return v2;
}

// Generated as internal constructor for term x64_movupd_store.
pub fn constructor_x64_movupd_store<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Xmm,
) -> SideEffectNoResult {
    let v2 = &constructor_x64_movupd_b_mem_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 1452.
    return v2.clone();
}

// Generated as internal constructor for term x64_movd_to_gpr.
pub fn constructor_x64_movd_to_gpr<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
) -> Gpr {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vmovd_b(ctx, arg0);
        // Rule at src/isa/x64/inst.isle line 1457.
        return v3;
    }
    let v1 = constructor_x64_movd_b(ctx, arg0);
    // Rule at src/isa/x64/inst.isle line 1456.
    return v1;
}

// Generated as internal constructor for term x64_movd_to_xmm.
pub fn constructor_x64_movd_to_xmm<C: Context>(
    ctx: &mut C,
    arg0: &GprMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vmovd_a(ctx, arg0);
        // Rule at src/isa/x64/inst.isle line 1464.
        return v3;
    }
    let v1 = constructor_x64_movd_a(ctx, arg0);
    // Rule at src/isa/x64/inst.isle line 1463.
    return v1;
}

// Generated as internal constructor for term x64_movq_to_xmm.
pub fn constructor_x64_movq_to_xmm<C: Context>(
    ctx: &mut C,
    arg0: &GprMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vmovq_a(ctx, arg0);
        // Rule at src/isa/x64/inst.isle line 1471.
        return v3;
    }
    let v1 = constructor_x64_movq_a(ctx, arg0);
    // Rule at src/isa/x64/inst.isle line 1470.
    return v1;
}

// Generated as internal constructor for term x64_movq_to_gpr.
pub fn constructor_x64_movq_to_gpr<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
) -> Gpr {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vmovq_b(ctx, arg0);
        // Rule at src/isa/x64/inst.isle line 1478.
        return v3;
    }
    let v1 = constructor_x64_movq_b(ctx, arg0);
    // Rule at src/isa/x64/inst.isle line 1477.
    return v1;
}

// Generated as internal constructor for term x64_movdqu_load.
pub fn constructor_x64_movdqu_load<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = constructor_x64_movdqu_a_or_avx(ctx, arg0);
    // Rule at src/isa/x64/inst.isle line 1483.
    return v1;
}

// Generated as internal constructor for term x64_movdqu_store.
pub fn constructor_x64_movdqu_store<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Xmm,
) -> SideEffectNoResult {
    let v2 = &constructor_x64_movdqu_b_mem_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 1486.
    return v2.clone();
}

// Generated as internal constructor for term x64_pmovsxbw.
pub fn constructor_x64_pmovsxbw<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = constructor_x64_pmovsxbw_a_or_avx(ctx, arg0);
    // Rule at src/isa/x64/inst.isle line 1489.
    return v1;
}

// Generated as internal constructor for term x64_pmovzxbw.
pub fn constructor_x64_pmovzxbw<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = constructor_x64_pmovzxbw_a_or_avx(ctx, arg0);
    // Rule at src/isa/x64/inst.isle line 1492.
    return v1;
}

// Generated as internal constructor for term x64_pmovsxwd.
pub fn constructor_x64_pmovsxwd<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = constructor_x64_pmovsxwd_a_or_avx(ctx, arg0);
    // Rule at src/isa/x64/inst.isle line 1495.
    return v1;
}

// Generated as internal constructor for term x64_pmovzxwd.
pub fn constructor_x64_pmovzxwd<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = constructor_x64_pmovzxwd_a_or_avx(ctx, arg0);
    // Rule at src/isa/x64/inst.isle line 1498.
    return v1;
}

// Generated as internal constructor for term x64_pmovsxdq.
pub fn constructor_x64_pmovsxdq<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = constructor_x64_pmovsxdq_a_or_avx(ctx, arg0);
    // Rule at src/isa/x64/inst.isle line 1501.
    return v1;
}

// Generated as internal constructor for term x64_pmovzxdq.
pub fn constructor_x64_pmovzxdq<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = constructor_x64_pmovzxdq_a_or_avx(ctx, arg0);
    // Rule at src/isa/x64/inst.isle line 1504.
    return v1;
}

// Generated as internal constructor for term x64_movrm.
pub fn constructor_x64_movrm<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: &SyntheticAmode,
    arg2: Gpr,
) -> SideEffectNoResult {
    match arg0 {
        I8 => {
            let v3 = &constructor_x64_movb_mr_mem(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 1509.
            return v3.clone();
        }
        I16 => {
            let v4 = &constructor_x64_movw_mr_mem(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 1510.
            return v4.clone();
        }
        I32 => {
            let v5 = &constructor_x64_movl_mr_mem(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 1511.
            return v5.clone();
        }
        I64 => {
            let v6 = &constructor_x64_movq_mr_mem(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 1512.
            return v6.clone();
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_movrm", "src/isa/x64/inst.isle line 1506")
}

// Generated as internal constructor for term x64_movimm_m.
pub fn constructor_x64_movimm_m<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: &SyntheticAmode,
    arg2: i32,
) -> SideEffectNoResult {
    match arg0 {
        I8 => {
            let v3 = C::i32_from_i8(ctx, arg2);
            if let Some(v4) = v3 {
                let v5 = C::i8_cast_unsigned(ctx, v4);
                let v6 = &constructor_x64_movb_mi_mem(ctx, arg1, v5);
                // Rule at src/isa/x64/inst.isle line 1515.
                return v6.clone();
            }
        }
        I16 => {
            let v7 = C::i32_from_i16(ctx, arg2);
            if let Some(v8) = v7 {
                let v9 = C::i16_cast_unsigned(ctx, v8);
                let v10 = &constructor_x64_movw_mi_mem(ctx, arg1, v9);
                // Rule at src/isa/x64/inst.isle line 1516.
                return v10.clone();
            }
        }
        I32 => {
            let v11 = C::i32_cast_unsigned(ctx, arg2);
            let v12 = &constructor_x64_movl_mi_mem(ctx, arg1, v11);
            // Rule at src/isa/x64/inst.isle line 1517.
            return v12.clone();
        }
        I64 => {
            let v13 = &constructor_x64_movq_mi_sxl_mem(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 1518.
            return v13.clone();
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_movimm_m", "src/isa/x64/inst.isle line 1514")
}

// Generated as internal constructor for term x64_xmm_load_const.
pub fn constructor_x64_xmm_load_const<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: VCodeConstant,
) -> Xmm {
    let v2 = &C::const_to_synthetic_amode(ctx, arg1);
    let v4 = constructor_x64_load(ctx, arg0, v2, &ExtKind::None);
    let v5 = C::xmm_new(ctx, v4);
    // Rule at src/isa/x64/inst.isle line 1522.
    return v5;
}

// Generated as internal constructor for term x64_produce_flags.
pub fn constructor_x64_produce_flags<C: Context>(
    ctx: &mut C,
    arg0: &ProduceFlagsOp,
    arg1: Type,
    arg2: Gpr,
    arg3: &GprMemImm,
) -> ProducesFlags {
    match arg0 {
        &ProduceFlagsOp::Add => {
            let v4 = &constructor_x64_add_with_flags_paired(ctx, arg1, arg2, arg3);
            // Rule at src/isa/x64/inst.isle line 1536.
            return v4.clone();
        }
        &ProduceFlagsOp::Sub => {
            let v5 = &constructor_x64_sub_with_flags_paired(ctx, arg1, arg2, arg3);
            // Rule at src/isa/x64/inst.isle line 1538.
            return v5.clone();
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_produce_flags", "src/isa/x64/inst.isle line 1535")
}

// Generated as internal constructor for term asm_produce_flags.
pub fn constructor_asm_produce_flags<C: Context>(
    ctx: &mut C,
    arg0: &AssemblerOutputs,
) -> ProducesFlags {
    match arg0 {
        &AssemblerOutputs::RetGpr {
            inst: ref v1,
            gpr: v2,
        } => {
            let v3 = C::gpr_to_reg(ctx, v2);
            let v4 = ProducesFlags::ProducesFlagsReturnsResultWithConsumer {
                inst: v1.clone(),
                result: v3,
            };
            // Rule at src/isa/x64/inst.isle line 1544.
            return v4;
        }
        &AssemblerOutputs::RetValueRegs {
            inst: ref v5,
            regs: v6,
        } => {
            let v8 = constructor_value_regs_get_gpr(ctx, v6, 0x0_usize);
            let v9 = C::gpr_to_reg(ctx, v8);
            let v10 = ProducesFlags::ProducesFlagsReturnsResultWithConsumer {
                inst: v5.clone(),
                result: v9,
            };
            // Rule at src/isa/x64/inst.isle line 1546.
            return v10;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "asm_produce_flags", "src/isa/x64/inst.isle line 1543")
}

// Generated as internal constructor for term x64_chain_flags.
pub fn constructor_x64_chain_flags<C: Context>(
    ctx: &mut C,
    arg0: &ChainFlagsOp,
    arg1: Type,
    arg2: Gpr,
    arg3: Gpr,
) -> ConsumesAndProducesFlags {
    match arg0 {
        &ChainFlagsOp::Adc => {
            let v4 = &C::gpr_to_gpr_mem_imm(ctx, arg3);
            let v5 = &constructor_x64_adc_chained(ctx, arg1, arg2, v4);
            // Rule at src/isa/x64/inst.isle line 1553.
            return v5.clone();
        }
        &ChainFlagsOp::Sbb => {
            let v4 = &C::gpr_to_gpr_mem_imm(ctx, arg3);
            let v6 = &constructor_x64_sbb_chained(ctx, arg1, arg2, v4);
            // Rule at src/isa/x64/inst.isle line 1555.
            return v6.clone();
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_chain_flags", "src/isa/x64/inst.isle line 1552")
}

// Generated as internal constructor for term asm_chain_flags.
pub fn constructor_asm_chain_flags<C: Context>(
    ctx: &mut C,
    arg0: &AssemblerOutputs,
) -> ConsumesAndProducesFlags {
    if let &AssemblerOutputs::RetGpr {
        inst: ref v1,
        gpr: v2,
    } = arg0 {
        let v3 = C::gpr_to_reg(ctx, v2);
        let v4 = ConsumesAndProducesFlags::ReturnsReg {
            inst: v1.clone(),
            result: v3,
        };
        // Rule at src/isa/x64/inst.isle line 1559.
        return v4;
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "asm_chain_flags", "src/isa/x64/inst.isle line 1558")
}

// Generated as internal constructor for term x64_produce_flags_side_effect.
pub fn constructor_x64_produce_flags_side_effect<C: Context>(
    ctx: &mut C,
    arg0: &ProduceFlagsSideEffectOp,
    arg1: Type,
    arg2: Gpr,
    arg3: &GprMemImm,
) -> ProducesFlags {
    match arg0 {
        &ProduceFlagsSideEffectOp::Or => {
            let v2 = C::fits_in_64(ctx, arg1);
            if let Some(v3) = v2 {
                let v6 = &constructor_x64_or_with_flags_paired_side_effect(ctx, v3, arg2, arg3);
                // Rule at src/isa/x64/inst.isle line 1567.
                return v6.clone();
            }
        }
        &ProduceFlagsSideEffectOp::Sbb => {
            let v2 = C::fits_in_64(ctx, arg1);
            if let Some(v3) = v2 {
                let v7 = &constructor_x64_sbb_paired_side_effect(ctx, v3, arg2, arg3);
                // Rule at src/isa/x64/inst.isle line 1569.
                return v7.clone();
            }
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_produce_flags_side_effect", "src/isa/x64/inst.isle line 1566")
}

// Generated as internal constructor for term asm_produce_flags_side_effect.
pub fn constructor_asm_produce_flags_side_effect<C: Context>(
    ctx: &mut C,
    arg0: &AssemblerOutputs,
) -> ProducesFlags {
    match arg0 {
        &AssemblerOutputs::SideEffect {
            inst: ref v4,
        } => {
            let v5 = ProducesFlags::ProducesFlagsSideEffect {
                inst: v4.clone(),
            };
            // Rule at src/isa/x64/inst.isle line 1575.
            return v5;
        }
        &AssemblerOutputs::RetGpr {
            inst: ref v1,
            gpr: v2,
        } => {
            let v3 = ProducesFlags::ProducesFlagsSideEffect {
                inst: v1.clone(),
            };
            // Rule at src/isa/x64/inst.isle line 1573.
            return v3;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "asm_produce_flags_side_effect", "src/isa/x64/inst.isle line 1572")
}

// Generated as internal constructor for term asm_consume_flags.
pub fn constructor_asm_consume_flags<C: Context>(
    ctx: &mut C,
    arg0: &AssemblerOutputs,
) -> ConsumesFlags {
    if let &AssemblerOutputs::RetGpr {
        inst: ref v1,
        gpr: v2,
    } = arg0 {
        let v3 = C::gpr_to_reg(ctx, v2);
        let v4 = ConsumesFlags::ConsumesFlagsReturnsResultWithProducer {
            inst: v1.clone(),
            result: v3,
        };
        // Rule at src/isa/x64/inst.isle line 1581.
        return v4;
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "asm_consume_flags", "src/isa/x64/inst.isle line 1580")
}

// Generated as internal constructor for term asm_consumes_flags_returns_gpr.
pub fn constructor_asm_consumes_flags_returns_gpr<C: Context>(
    ctx: &mut C,
    arg0: &AssemblerOutputs,
) -> ConsumesFlags {
    if let &AssemblerOutputs::RetGpr {
        inst: ref v1,
        gpr: v2,
    } = arg0 {
        let v3 = C::gpr_to_reg(ctx, v2);
        let v4 = ConsumesFlags::ConsumesFlagsReturnsReg {
            inst: v1.clone(),
            result: v3,
        };
        // Rule at src/isa/x64/inst.isle line 1585.
        return v4;
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "asm_consumes_flags_returns_gpr", "src/isa/x64/inst.isle line 1584")
}

// Generated as internal constructor for term x64_add_raw.
pub fn constructor_x64_add_raw<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Gpr,
    arg2: &GprMemImm,
) -> AssemblerOutputs {
    match arg0 {
        I8 => {
            let v8 = C::is_imm8(ctx, arg2);
            if let Some(v9) = v8 {
                let v5 = &C::gpr_to_gpr_mem(ctx, arg1);
                let v10 = &C::x64_addb_mi_raw(ctx, v5, v9);
                // Rule at src/isa/x64/inst.isle line 1604.
                return v10.clone();
            }
            let v20 = &C::is_gpr_mem(ctx, arg2);
            if let Some(v21) = v20 {
                let v22 = &C::x64_addb_rm_raw(ctx, arg1, v21);
                // Rule at src/isa/x64/inst.isle line 1610.
                return v22.clone();
            }
        }
        I16 => {
            let v11 = C::is_imm16(ctx, arg2);
            if let Some(v12) = v11 {
                let v5 = &C::gpr_to_gpr_mem(ctx, arg1);
                let v13 = &C::x64_addw_mi_raw(ctx, v5, v12);
                // Rule at src/isa/x64/inst.isle line 1605.
                return v13.clone();
            }
            let v20 = &C::is_gpr_mem(ctx, arg2);
            if let Some(v21) = v20 {
                let v23 = &C::x64_addw_rm_raw(ctx, arg1, v21);
                // Rule at src/isa/x64/inst.isle line 1611.
                return v23.clone();
            }
        }
        I32 => {
            let v3 = C::is_simm8(ctx, arg2);
            if let Some(v4) = v3 {
                let v5 = &C::gpr_to_gpr_mem(ctx, arg1);
                let v6 = &C::x64_addl_mi_sxb_raw(ctx, v5, v4);
                // Rule at src/isa/x64/inst.isle line 1600.
                return v6.clone();
            }
            let v14 = C::is_imm32(ctx, arg2);
            if let Some(v15) = v14 {
                let v5 = &C::gpr_to_gpr_mem(ctx, arg1);
                let v16 = &C::x64_addl_mi_raw(ctx, v5, v15);
                // Rule at src/isa/x64/inst.isle line 1606.
                return v16.clone();
            }
            let v20 = &C::is_gpr_mem(ctx, arg2);
            if let Some(v21) = v20 {
                let v24 = &C::x64_addl_rm_raw(ctx, arg1, v21);
                // Rule at src/isa/x64/inst.isle line 1612.
                return v24.clone();
            }
        }
        I64 => {
            let v3 = C::is_simm8(ctx, arg2);
            if let Some(v4) = v3 {
                let v5 = &C::gpr_to_gpr_mem(ctx, arg1);
                let v7 = &C::x64_addq_mi_sxb_raw(ctx, v5, v4);
                // Rule at src/isa/x64/inst.isle line 1601.
                return v7.clone();
            }
            let v17 = C::is_simm32(ctx, arg2);
            if let Some(v18) = v17 {
                let v5 = &C::gpr_to_gpr_mem(ctx, arg1);
                let v19 = &C::x64_addq_mi_sxl_raw(ctx, v5, v18);
                // Rule at src/isa/x64/inst.isle line 1607.
                return v19.clone();
            }
            let v20 = &C::is_gpr_mem(ctx, arg2);
            if let Some(v21) = v20 {
                let v25 = &C::x64_addq_rm_raw(ctx, arg1, v21);
                // Rule at src/isa/x64/inst.isle line 1613.
                return v25.clone();
            }
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_add_raw", "src/isa/x64/inst.isle line 1597")
}

// Generated as internal constructor for term x64_add_break_deps.
pub fn constructor_x64_add_break_deps<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Gpr,
    arg2: &GprMemImm,
) -> AssemblerOutputs {
    match arg0 {
        I8 => {
            let v3 = C::is_gpr(ctx, arg2);
            if let Some(v4) = v3 {
                let v5 = &C::gpr_to_gpr_mem(ctx, v4);
                let v6 = &C::x64_addl_rm_raw(ctx, arg1, v5);
                // Rule at src/isa/x64/inst.isle line 1619.
                return v6.clone();
            }
        }
        I16 => {
            let v3 = C::is_gpr(ctx, arg2);
            if let Some(v4) = v3 {
                let v5 = &C::gpr_to_gpr_mem(ctx, v4);
                let v6 = &C::x64_addl_rm_raw(ctx, arg1, v5);
                // Rule at src/isa/x64/inst.isle line 1620.
                return v6.clone();
            }
        }
        _ => {}
    }
    let v7 = &constructor_x64_add_raw(ctx, arg0, arg1, arg2);
    // Rule at src/isa/x64/inst.isle line 1621.
    return v7.clone();
}

// Generated as internal constructor for term x64_add.
pub fn constructor_x64_add<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Gpr,
    arg2: &GprMemImm,
) -> Gpr {
    let v3 = &constructor_x64_add_break_deps(ctx, arg0, arg1, arg2);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at src/isa/x64/inst.isle line 1625.
    return v4;
}

// Generated as internal constructor for term x64_add_with_flags_paired.
pub fn constructor_x64_add_with_flags_paired<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Gpr,
    arg2: &GprMemImm,
) -> ProducesFlags {
    let v3 = &constructor_x64_add_raw(ctx, arg0, arg1, arg2);
    let v4 = &constructor_asm_produce_flags(ctx, v3);
    // Rule at src/isa/x64/inst.isle line 1632.
    return v4.clone();
}

// Generated as internal constructor for term x64_adc_raw.
pub fn constructor_x64_adc_raw<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Gpr,
    arg2: &GprMemImm,
) -> AssemblerOutputs {
    if arg0 == I64 {
        let v3 = C::is_simm8(ctx, arg2);
        if let Some(v4) = v3 {
            let v5 = &C::gpr_to_gpr_mem(ctx, arg1);
            let v6 = &C::x64_adcq_mi_sxb_raw(ctx, v5, v4);
            // Rule at src/isa/x64/inst.isle line 1641.
            return v6.clone();
        }
        let v7 = C::is_simm32(ctx, arg2);
        if let Some(v8) = v7 {
            let v5 = &C::gpr_to_gpr_mem(ctx, arg1);
            let v9 = &C::x64_adcq_mi_sxl_raw(ctx, v5, v8);
            // Rule at src/isa/x64/inst.isle line 1642.
            return v9.clone();
        }
        let v10 = &C::is_gpr_mem(ctx, arg2);
        if let Some(v11) = v10 {
            let v12 = &C::x64_adcq_rm_raw(ctx, arg1, v11);
            // Rule at src/isa/x64/inst.isle line 1643.
            return v12.clone();
        }
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_adc_raw", "src/isa/x64/inst.isle line 1640")
}

// Generated as internal constructor for term x64_adc_paired.
pub fn constructor_x64_adc_paired<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Gpr,
    arg2: &GprMemImm,
) -> ConsumesFlags {
    let v3 = &constructor_x64_adc_raw(ctx, arg0, arg1, arg2);
    let v4 = &constructor_asm_consume_flags(ctx, v3);
    // Rule at src/isa/x64/inst.isle line 1647.
    return v4.clone();
}

// Generated as internal constructor for term x64_adc_chained.
pub fn constructor_x64_adc_chained<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Gpr,
    arg2: &GprMemImm,
) -> ConsumesAndProducesFlags {
    let v3 = &constructor_x64_adc_raw(ctx, arg0, arg1, arg2);
    let v4 = &constructor_asm_chain_flags(ctx, v3);
    // Rule at src/isa/x64/inst.isle line 1652.
    return v4.clone();
}

// Generated as internal constructor for term x64_sub_raw.
pub fn constructor_x64_sub_raw<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Gpr,
    arg2: &GprMemImm,
) -> AssemblerOutputs {
    match arg0 {
        I8 => {
            let v8 = C::is_imm8(ctx, arg2);
            if let Some(v9) = v8 {
                let v5 = &C::gpr_to_gpr_mem(ctx, arg1);
                let v10 = &C::x64_subb_mi_raw(ctx, v5, v9);
                // Rule at src/isa/x64/inst.isle line 1665.
                return v10.clone();
            }
            let v20 = &C::is_gpr_mem(ctx, arg2);
            if let Some(v21) = v20 {
                let v22 = &C::x64_subb_rm_raw(ctx, arg1, v21);
                // Rule at src/isa/x64/inst.isle line 1671.
                return v22.clone();
            }
        }
        I16 => {
            let v11 = C::is_imm16(ctx, arg2);
            if let Some(v12) = v11 {
                let v5 = &C::gpr_to_gpr_mem(ctx, arg1);
                let v13 = &C::x64_subw_mi_raw(ctx, v5, v12);
                // Rule at src/isa/x64/inst.isle line 1666.
                return v13.clone();
            }
            let v20 = &C::is_gpr_mem(ctx, arg2);
            if let Some(v21) = v20 {
                let v23 = &C::x64_subw_rm_raw(ctx, arg1, v21);
                // Rule at src/isa/x64/inst.isle line 1672.
                return v23.clone();
            }
        }
        I32 => {
            let v3 = C::is_simm8(ctx, arg2);
            if let Some(v4) = v3 {
                let v5 = &C::gpr_to_gpr_mem(ctx, arg1);
                let v6 = &C::x64_subl_mi_sxb_raw(ctx, v5, v4);
                // Rule at src/isa/x64/inst.isle line 1661.
                return v6.clone();
            }
            let v14 = C::is_imm32(ctx, arg2);
            if let Some(v15) = v14 {
                let v5 = &C::gpr_to_gpr_mem(ctx, arg1);
                let v16 = &C::x64_subl_mi_raw(ctx, v5, v15);
                // Rule at src/isa/x64/inst.isle line 1667.
                return v16.clone();
            }
            let v20 = &C::is_gpr_mem(ctx, arg2);
            if let Some(v21) = v20 {
                let v24 = &C::x64_subl_rm_raw(ctx, arg1, v21);
                // Rule at src/isa/x64/inst.isle line 1673.
                return v24.clone();
            }
        }
        I64 => {
            let v3 = C::is_simm8(ctx, arg2);
            if let Some(v4) = v3 {
                let v5 = &C::gpr_to_gpr_mem(ctx, arg1);
                let v7 = &C::x64_subq_mi_sxb_raw(ctx, v5, v4);
                // Rule at src/isa/x64/inst.isle line 1662.
                return v7.clone();
            }
            let v17 = C::is_simm32(ctx, arg2);
            if let Some(v18) = v17 {
                let v5 = &C::gpr_to_gpr_mem(ctx, arg1);
                let v19 = &C::x64_subq_mi_sxl_raw(ctx, v5, v18);
                // Rule at src/isa/x64/inst.isle line 1668.
                return v19.clone();
            }
            let v20 = &C::is_gpr_mem(ctx, arg2);
            if let Some(v21) = v20 {
                let v25 = &C::x64_subq_rm_raw(ctx, arg1, v21);
                // Rule at src/isa/x64/inst.isle line 1674.
                return v25.clone();
            }
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_sub_raw", "src/isa/x64/inst.isle line 1658")
}

// Generated as internal constructor for term x64_sub_break_deps.
pub fn constructor_x64_sub_break_deps<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Gpr,
    arg2: &GprMemImm,
) -> AssemblerOutputs {
    match arg0 {
        I8 => {
            let v3 = C::is_gpr(ctx, arg2);
            if let Some(v4) = v3 {
                let v5 = &C::gpr_to_gpr_mem(ctx, v4);
                let v6 = &C::x64_subl_rm_raw(ctx, arg1, v5);
                // Rule at src/isa/x64/inst.isle line 1680.
                return v6.clone();
            }
        }
        I16 => {
            let v3 = C::is_gpr(ctx, arg2);
            if let Some(v4) = v3 {
                let v5 = &C::gpr_to_gpr_mem(ctx, v4);
                let v6 = &C::x64_subl_rm_raw(ctx, arg1, v5);
                // Rule at src/isa/x64/inst.isle line 1681.
                return v6.clone();
            }
        }
        _ => {}
    }
    let v7 = &constructor_x64_sub_raw(ctx, arg0, arg1, arg2);
    // Rule at src/isa/x64/inst.isle line 1682.
    return v7.clone();
}

// Generated as internal constructor for term x64_sub.
pub fn constructor_x64_sub<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Gpr,
    arg2: &GprMemImm,
) -> Gpr {
    let v3 = &constructor_x64_sub_break_deps(ctx, arg0, arg1, arg2);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at src/isa/x64/inst.isle line 1686.
    return v4;
}

// Generated as internal constructor for term x64_sub_with_flags_paired.
pub fn constructor_x64_sub_with_flags_paired<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Gpr,
    arg2: &GprMemImm,
) -> ProducesFlags {
    let v3 = &constructor_x64_sub_raw(ctx, arg0, arg1, arg2);
    let v4 = &constructor_asm_produce_flags(ctx, v3);
    // Rule at src/isa/x64/inst.isle line 1692.
    return v4.clone();
}

// Generated as internal constructor for term x64_sbb_raw.
pub fn constructor_x64_sbb_raw<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Gpr,
    arg2: &GprMemImm,
) -> AssemblerOutputs {
    match arg0 {
        I8 => {
            let v8 = C::is_imm8(ctx, arg2);
            if let Some(v9) = v8 {
                let v5 = &C::gpr_to_gpr_mem(ctx, arg1);
                let v10 = &C::x64_sbbb_mi_raw(ctx, v5, v9);
                // Rule at src/isa/x64/inst.isle line 1706.
                return v10.clone();
            }
            let v20 = &C::is_gpr_mem(ctx, arg2);
            if let Some(v21) = v20 {
                let v22 = &C::x64_sbbb_rm_raw(ctx, arg1, v21);
                // Rule at src/isa/x64/inst.isle line 1712.
                return v22.clone();
            }
        }
        I16 => {
            let v11 = C::is_imm16(ctx, arg2);
            if let Some(v12) = v11 {
                let v5 = &C::gpr_to_gpr_mem(ctx, arg1);
                let v13 = &C::x64_sbbw_mi_raw(ctx, v5, v12);
                // Rule at src/isa/x64/inst.isle line 1707.
                return v13.clone();
            }
            let v20 = &C::is_gpr_mem(ctx, arg2);
            if let Some(v21) = v20 {
                let v23 = &C::x64_sbbw_rm_raw(ctx, arg1, v21);
                // Rule at src/isa/x64/inst.isle line 1713.
                return v23.clone();
            }
        }
        I32 => {
            let v3 = C::is_simm8(ctx, arg2);
            if let Some(v4) = v3 {
                let v5 = &C::gpr_to_gpr_mem(ctx, arg1);
                let v6 = &C::x64_sbbl_mi_sxb_raw(ctx, v5, v4);
                // Rule at src/isa/x64/inst.isle line 1702.
                return v6.clone();
            }
            let v14 = C::is_imm32(ctx, arg2);
            if let Some(v15) = v14 {
                let v5 = &C::gpr_to_gpr_mem(ctx, arg1);
                let v16 = &C::x64_sbbl_mi_raw(ctx, v5, v15);
                // Rule at src/isa/x64/inst.isle line 1708.
                return v16.clone();
            }
            let v20 = &C::is_gpr_mem(ctx, arg2);
            if let Some(v21) = v20 {
                let v24 = &C::x64_sbbl_rm_raw(ctx, arg1, v21);
                // Rule at src/isa/x64/inst.isle line 1714.
                return v24.clone();
            }
        }
        I64 => {
            let v3 = C::is_simm8(ctx, arg2);
            if let Some(v4) = v3 {
                let v5 = &C::gpr_to_gpr_mem(ctx, arg1);
                let v7 = &C::x64_sbbq_mi_sxb_raw(ctx, v5, v4);
                // Rule at src/isa/x64/inst.isle line 1703.
                return v7.clone();
            }
            let v17 = C::is_simm32(ctx, arg2);
            if let Some(v18) = v17 {
                let v5 = &C::gpr_to_gpr_mem(ctx, arg1);
                let v19 = &C::x64_sbbq_mi_sxl_raw(ctx, v5, v18);
                // Rule at src/isa/x64/inst.isle line 1709.
                return v19.clone();
            }
            let v20 = &C::is_gpr_mem(ctx, arg2);
            if let Some(v21) = v20 {
                let v25 = &C::x64_sbbq_rm_raw(ctx, arg1, v21);
                // Rule at src/isa/x64/inst.isle line 1715.
                return v25.clone();
            }
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_sbb_raw", "src/isa/x64/inst.isle line 1699")
}

// Generated as internal constructor for term x64_sbb_break_deps.
pub fn constructor_x64_sbb_break_deps<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Gpr,
    arg2: &GprMemImm,
) -> AssemblerOutputs {
    match arg0 {
        I8 => {
            let v3 = C::is_gpr(ctx, arg2);
            if let Some(v4) = v3 {
                let v5 = &C::gpr_to_gpr_mem(ctx, v4);
                let v6 = &C::x64_sbbl_rm_raw(ctx, arg1, v5);
                // Rule at src/isa/x64/inst.isle line 1721.
                return v6.clone();
            }
        }
        I16 => {
            let v3 = C::is_gpr(ctx, arg2);
            if let Some(v4) = v3 {
                let v5 = &C::gpr_to_gpr_mem(ctx, v4);
                let v6 = &C::x64_sbbl_rm_raw(ctx, arg1, v5);
                // Rule at src/isa/x64/inst.isle line 1722.
                return v6.clone();
            }
        }
        _ => {}
    }
    let v7 = &constructor_x64_sbb_raw(ctx, arg0, arg1, arg2);
    // Rule at src/isa/x64/inst.isle line 1723.
    return v7.clone();
}

// Generated as internal constructor for term x64_sbb_paired.
pub fn constructor_x64_sbb_paired<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Gpr,
    arg2: &GprMemImm,
) -> ConsumesFlags {
    let v3 = &constructor_x64_sbb_break_deps(ctx, arg0, arg1, arg2);
    let v4 = &constructor_asm_consume_flags(ctx, v3);
    // Rule at src/isa/x64/inst.isle line 1728.
    return v4.clone();
}

// Generated as internal constructor for term x64_sbb_chained.
pub fn constructor_x64_sbb_chained<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Gpr,
    arg2: &GprMemImm,
) -> ConsumesAndProducesFlags {
    let v3 = &constructor_x64_sbb_raw(ctx, arg0, arg1, arg2);
    let v4 = &constructor_asm_chain_flags(ctx, v3);
    // Rule at src/isa/x64/inst.isle line 1733.
    return v4.clone();
}

// Generated as internal constructor for term x64_sbb_paired_side_effect.
pub fn constructor_x64_sbb_paired_side_effect<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Gpr,
    arg2: &GprMemImm,
) -> ProducesFlags {
    let v3 = &constructor_x64_sbb_raw(ctx, arg0, arg1, arg2);
    let v4 = &constructor_asm_produce_flags_side_effect(ctx, v3);
    // Rule at src/isa/x64/inst.isle line 1738.
    return v4.clone();
}

// Generated as internal constructor for term x64_mul_raw.
pub fn constructor_x64_mul_raw<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: bool,
    arg2: Gpr,
    arg3: &GprMem,
) -> AssemblerOutputs {
    match arg0 {
        I16 => {
            match arg1 {
                false => {
                    let v4 = &C::x64_mulw_m_raw(ctx, arg2, arg3);
                    // Rule at src/isa/x64/inst.isle line 1746.
                    return v4.clone();
                }
                true => {
                    let v7 = &C::x64_imulw_m_raw(ctx, arg2, arg3);
                    // Rule at src/isa/x64/inst.isle line 1749.
                    return v7.clone();
                }
                _ => {}
            }
        }
        I32 => {
            match arg1 {
                false => {
                    let v5 = &C::x64_mull_m_raw(ctx, arg2, arg3);
                    // Rule at src/isa/x64/inst.isle line 1747.
                    return v5.clone();
                }
                true => {
                    let v8 = &C::x64_imull_m_raw(ctx, arg2, arg3);
                    // Rule at src/isa/x64/inst.isle line 1750.
                    return v8.clone();
                }
                _ => {}
            }
        }
        I64 => {
            match arg1 {
                false => {
                    let v6 = &C::x64_mulq_m_raw(ctx, arg2, arg3);
                    // Rule at src/isa/x64/inst.isle line 1748.
                    return v6.clone();
                }
                true => {
                    let v9 = &C::x64_imulq_m_raw(ctx, arg2, arg3);
                    // Rule at src/isa/x64/inst.isle line 1751.
                    return v9.clone();
                }
                _ => {}
            }
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_mul_raw", "src/isa/x64/inst.isle line 1745")
}

// Generated as internal constructor for term x64_mul.
pub fn constructor_x64_mul<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: bool,
    arg2: Gpr,
    arg3: &GprMem,
) -> ValueRegs {
    match arg0 {
        I32 => {
            if arg1 == false {
                let v6 = C::has_bmi2(ctx);
                if v6 == true {
                    let v7 = constructor_x64_mulxl_rvm(ctx, arg3, arg2);
                    let v9 = C::value_regs_get(ctx, v7, 0x1_usize);
                    let v11 = C::value_regs_get(ctx, v7, 0x0_usize);
                    let v12 = C::value_regs(ctx, v9, v11);
                    // Rule at src/isa/x64/inst.isle line 1762.
                    return v12;
                }
            }
        }
        I64 => {
            if arg1 == false {
                let v6 = C::has_bmi2(ctx);
                if v6 == true {
                    let v13 = constructor_x64_mulxq_rvm(ctx, arg3, arg2);
                    let v14 = C::value_regs_get(ctx, v13, 0x1_usize);
                    let v15 = C::value_regs_get(ctx, v13, 0x0_usize);
                    let v16 = C::value_regs(ctx, v14, v15);
                    // Rule at src/isa/x64/inst.isle line 1766.
                    return v16;
                }
            }
        }
        _ => {}
    }
    let v4 = &constructor_x64_mul_raw(ctx, arg0, arg1, arg2, arg3);
    let v5 = constructor_emit_ret_value_regs(ctx, v4);
    // Rule at src/isa/x64/inst.isle line 1754.
    return v5;
}

// Generated as internal constructor for term x64_mulx_hi.
pub fn constructor_x64_mulx_hi<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Gpr,
    arg2: &GprMem,
) -> Gpr {
    match arg0 {
        I32 => {
            let v3 = C::x64_mulxl_rvm_hi(ctx, arg2, arg1);
            // Rule at src/isa/x64/inst.isle line 1772.
            return v3;
        }
        I64 => {
            let v4 = C::x64_mulxq_rvm_hi(ctx, arg2, arg1);
            // Rule at src/isa/x64/inst.isle line 1773.
            return v4;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_mulx_hi", "src/isa/x64/inst.isle line 1771")
}

// Generated as internal constructor for term x64_mul_lo_with_flags_paired.
pub fn constructor_x64_mul_lo_with_flags_paired<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: bool,
    arg2: Gpr,
    arg3: &GprMem,
) -> ProducesFlags {
    let v4 = &constructor_x64_mul_raw(ctx, arg0, arg1, arg2, arg3);
    let v5 = &constructor_asm_produce_flags(ctx, v4);
    // Rule at src/isa/x64/inst.isle line 1781.
    return v5.clone();
}

// Generated as internal constructor for term x64_imul.
pub fn constructor_x64_imul<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Gpr,
    arg2: &GprMem,
) -> Gpr {
    match arg0 {
        I16 => {
            let v3 = constructor_x64_imulw_rm(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 1790.
            return v3;
        }
        I32 => {
            let v4 = constructor_x64_imull_rm(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 1791.
            return v4;
        }
        I64 => {
            let v5 = constructor_x64_imulq_rm(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 1792.
            return v5;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_imul", "src/isa/x64/inst.isle line 1789")
}

// Generated as internal constructor for term x64_imul_imm.
pub fn constructor_x64_imul_imm<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: &GprMem,
    arg2: i32,
) -> Gpr {
    match arg0 {
        I16 => {
            let v3 = C::i32_from_i8(ctx, arg2);
            if let Some(v4) = v3 {
                let v5 = constructor_x64_imulw_rmi_sxb(ctx, arg1, v4);
                // Rule at src/isa/x64/inst.isle line 1797.
                return v5;
            }
            let v8 = C::i32_from_i16(ctx, arg2);
            if let Some(v9) = v8 {
                let v10 = C::i16_cast_unsigned(ctx, v9);
                let v11 = constructor_x64_imulw_rmi(ctx, arg1, v10);
                // Rule at src/isa/x64/inst.isle line 1800.
                return v11;
            }
        }
        I32 => {
            let v3 = C::i32_from_i8(ctx, arg2);
            if let Some(v4) = v3 {
                let v6 = constructor_x64_imull_rmi_sxb(ctx, arg1, v4);
                // Rule at src/isa/x64/inst.isle line 1798.
                return v6;
            }
            let v12 = C::i32_cast_unsigned(ctx, arg2);
            let v13 = constructor_x64_imull_rmi(ctx, arg1, v12);
            // Rule at src/isa/x64/inst.isle line 1801.
            return v13;
        }
        I64 => {
            let v3 = C::i32_from_i8(ctx, arg2);
            if let Some(v4) = v3 {
                let v7 = constructor_x64_imulq_rmi_sxb(ctx, arg1, v4);
                // Rule at src/isa/x64/inst.isle line 1799.
                return v7;
            }
            let v14 = constructor_x64_imulq_rmi_sxl(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 1802.
            return v14;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_imul_imm", "src/isa/x64/inst.isle line 1796")
}

// Generated as internal constructor for term x64_mul8_raw.
pub fn constructor_x64_mul8_raw<C: Context>(
    ctx: &mut C,
    arg0: bool,
    arg1: Gpr,
    arg2: &GprMem,
) -> AssemblerOutputs {
    match arg0 {
        false => {
            let v3 = &C::x64_mulb_m_raw(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 1807.
            return v3.clone();
        }
        true => {
            let v4 = &C::x64_imulb_m_raw(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 1808.
            return v4.clone();
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_mul8_raw", "src/isa/x64/inst.isle line 1806")
}

// Generated as internal constructor for term x64_mul8.
pub fn constructor_x64_mul8<C: Context>(
    ctx: &mut C,
    arg0: bool,
    arg1: Gpr,
    arg2: &GprMem,
) -> Gpr {
    let v3 = &constructor_x64_mul8_raw(ctx, arg0, arg1, arg2);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at src/isa/x64/inst.isle line 1811.
    return v4;
}

// Generated as internal constructor for term x64_mul8_with_flags_paired.
pub fn constructor_x64_mul8_with_flags_paired<C: Context>(
    ctx: &mut C,
    arg0: bool,
    arg1: Gpr,
    arg2: &GprMem,
) -> ProducesFlags {
    let v3 = &constructor_x64_mul8_raw(ctx, arg0, arg1, arg2);
    let v4 = &constructor_asm_produce_flags(ctx, v3);
    // Rule at src/isa/x64/inst.isle line 1815.
    return v4.clone();
}

// Generated as internal constructor for term x64_and.
pub fn constructor_x64_and<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Gpr,
    arg2: &GprMemImm,
) -> Gpr {
    match arg0 {
        I8 => {
            let v7 = C::is_imm8(ctx, arg2);
            if let Some(v8) = v7 {
                let v9 = constructor_x64_andb_mi(ctx, arg1, v8);
                // Rule at src/isa/x64/inst.isle line 1828.
                return v9;
            }
            let v19 = C::is_gpr(ctx, arg2);
            if let Some(v20) = v19 {
                let v21 = &C::gpr_to_gpr_mem(ctx, v20);
                let v22 = constructor_x64_andl_rm(ctx, arg1, v21);
                // Rule at src/isa/x64/inst.isle line 1835.
                return v22;
            }
            let v23 = &C::is_gpr_mem(ctx, arg2);
            if let Some(v24) = v23 {
                let v25 = constructor_x64_andb_rm(ctx, arg1, v24);
                // Rule at src/isa/x64/inst.isle line 1839.
                return v25;
            }
        }
        I16 => {
            let v10 = C::is_imm16(ctx, arg2);
            if let Some(v11) = v10 {
                let v12 = constructor_x64_andw_mi(ctx, arg1, v11);
                // Rule at src/isa/x64/inst.isle line 1829.
                return v12;
            }
            let v19 = C::is_gpr(ctx, arg2);
            if let Some(v20) = v19 {
                let v21 = &C::gpr_to_gpr_mem(ctx, v20);
                let v22 = constructor_x64_andl_rm(ctx, arg1, v21);
                // Rule at src/isa/x64/inst.isle line 1836.
                return v22;
            }
            let v23 = &C::is_gpr_mem(ctx, arg2);
            if let Some(v24) = v23 {
                let v26 = constructor_x64_andw_rm(ctx, arg1, v24);
                // Rule at src/isa/x64/inst.isle line 1840.
                return v26;
            }
        }
        I32 => {
            let v3 = C::is_simm8(ctx, arg2);
            if let Some(v4) = v3 {
                let v5 = constructor_x64_andl_mi_sxb(ctx, arg1, v4);
                // Rule at src/isa/x64/inst.isle line 1824.
                return v5;
            }
            let v13 = C::is_imm32(ctx, arg2);
            if let Some(v14) = v13 {
                let v15 = constructor_x64_andl_mi(ctx, arg1, v14);
                // Rule at src/isa/x64/inst.isle line 1830.
                return v15;
            }
            let v23 = &C::is_gpr_mem(ctx, arg2);
            if let Some(v24) = v23 {
                let v27 = constructor_x64_andl_rm(ctx, arg1, v24);
                // Rule at src/isa/x64/inst.isle line 1841.
                return v27;
            }
        }
        I64 => {
            let v3 = C::is_simm8(ctx, arg2);
            if let Some(v4) = v3 {
                let v6 = constructor_x64_andq_mi_sxb(ctx, arg1, v4);
                // Rule at src/isa/x64/inst.isle line 1825.
                return v6;
            }
            let v16 = C::is_simm32(ctx, arg2);
            if let Some(v17) = v16 {
                let v18 = constructor_x64_andq_mi_sxl(ctx, arg1, v17);
                // Rule at src/isa/x64/inst.isle line 1831.
                return v18;
            }
            let v23 = &C::is_gpr_mem(ctx, arg2);
            if let Some(v24) = v23 {
                let v28 = constructor_x64_andq_rm(ctx, arg1, v24);
                // Rule at src/isa/x64/inst.isle line 1842.
                return v28;
            }
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_and", "src/isa/x64/inst.isle line 1821")
}

// Generated as internal constructor for term x64_or_raw.
pub fn constructor_x64_or_raw<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Gpr,
    arg2: &GprMemImm,
) -> AssemblerOutputs {
    match arg0 {
        I8 => {
            let v8 = C::is_imm8(ctx, arg2);
            if let Some(v9) = v8 {
                let v5 = &C::gpr_to_gpr_mem(ctx, arg1);
                let v10 = &C::x64_orb_mi_raw(ctx, v5, v9);
                // Rule at src/isa/x64/inst.isle line 1854.
                return v10.clone();
            }
            let v20 = &C::is_gpr_mem(ctx, arg2);
            if let Some(v21) = v20 {
                let v22 = &C::x64_orb_rm_raw(ctx, arg1, v21);
                // Rule at src/isa/x64/inst.isle line 1860.
                return v22.clone();
            }
        }
        I16 => {
            let v11 = C::is_imm16(ctx, arg2);
            if let Some(v12) = v11 {
                let v5 = &C::gpr_to_gpr_mem(ctx, arg1);
                let v13 = &C::x64_orw_mi_raw(ctx, v5, v12);
                // Rule at src/isa/x64/inst.isle line 1855.
                return v13.clone();
            }
            let v20 = &C::is_gpr_mem(ctx, arg2);
            if let Some(v21) = v20 {
                let v23 = &C::x64_orw_rm_raw(ctx, arg1, v21);
                // Rule at src/isa/x64/inst.isle line 1861.
                return v23.clone();
            }
        }
        I32 => {
            let v3 = C::is_simm8(ctx, arg2);
            if let Some(v4) = v3 {
                let v5 = &C::gpr_to_gpr_mem(ctx, arg1);
                let v6 = &C::x64_orl_mi_sxb_raw(ctx, v5, v4);
                // Rule at src/isa/x64/inst.isle line 1850.
                return v6.clone();
            }
            let v14 = C::is_imm32(ctx, arg2);
            if let Some(v15) = v14 {
                let v5 = &C::gpr_to_gpr_mem(ctx, arg1);
                let v16 = &C::x64_orl_mi_raw(ctx, v5, v15);
                // Rule at src/isa/x64/inst.isle line 1856.
                return v16.clone();
            }
            let v20 = &C::is_gpr_mem(ctx, arg2);
            if let Some(v21) = v20 {
                let v24 = &C::x64_orl_rm_raw(ctx, arg1, v21);
                // Rule at src/isa/x64/inst.isle line 1862.
                return v24.clone();
            }
        }
        I64 => {
            let v3 = C::is_simm8(ctx, arg2);
            if let Some(v4) = v3 {
                let v5 = &C::gpr_to_gpr_mem(ctx, arg1);
                let v7 = &C::x64_orq_mi_sxb_raw(ctx, v5, v4);
                // Rule at src/isa/x64/inst.isle line 1851.
                return v7.clone();
            }
            let v17 = C::is_simm32(ctx, arg2);
            if let Some(v18) = v17 {
                let v5 = &C::gpr_to_gpr_mem(ctx, arg1);
                let v19 = &C::x64_orq_mi_sxl_raw(ctx, v5, v18);
                // Rule at src/isa/x64/inst.isle line 1857.
                return v19.clone();
            }
            let v20 = &C::is_gpr_mem(ctx, arg2);
            if let Some(v21) = v20 {
                let v25 = &C::x64_orq_rm_raw(ctx, arg1, v21);
                // Rule at src/isa/x64/inst.isle line 1863.
                return v25.clone();
            }
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_or_raw", "src/isa/x64/inst.isle line 1847")
}

// Generated as internal constructor for term x64_or_break_deps.
pub fn constructor_x64_or_break_deps<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Gpr,
    arg2: &GprMemImm,
) -> AssemblerOutputs {
    match arg0 {
        I8 => {
            let v3 = C::is_gpr(ctx, arg2);
            if let Some(v4) = v3 {
                let v5 = &C::gpr_to_gpr_mem(ctx, v4);
                let v6 = &C::x64_orl_rm_raw(ctx, arg1, v5);
                // Rule at src/isa/x64/inst.isle line 1868.
                return v6.clone();
            }
        }
        I16 => {
            let v3 = C::is_gpr(ctx, arg2);
            if let Some(v4) = v3 {
                let v5 = &C::gpr_to_gpr_mem(ctx, v4);
                let v6 = &C::x64_orl_rm_raw(ctx, arg1, v5);
                // Rule at src/isa/x64/inst.isle line 1869.
                return v6.clone();
            }
        }
        _ => {}
    }
    let v7 = &constructor_x64_or_raw(ctx, arg0, arg1, arg2);
    // Rule at src/isa/x64/inst.isle line 1870.
    return v7.clone();
}

// Generated as internal constructor for term x64_or.
pub fn constructor_x64_or<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Gpr,
    arg2: &GprMemImm,
) -> Gpr {
    let v3 = &constructor_x64_or_break_deps(ctx, arg0, arg1, arg2);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at src/isa/x64/inst.isle line 1874.
    return v4;
}

// Generated as internal constructor for term x64_or_with_flags_paired_side_effect.
pub fn constructor_x64_or_with_flags_paired_side_effect<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Gpr,
    arg2: &GprMemImm,
) -> ProducesFlags {
    let v3 = &constructor_x64_or_raw(ctx, arg0, arg1, arg2);
    let v4 = &constructor_asm_produce_flags_side_effect(ctx, v3);
    // Rule at src/isa/x64/inst.isle line 1880.
    return v4.clone();
}

// Generated as internal constructor for term x64_xor.
pub fn constructor_x64_xor<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Gpr,
    arg2: &GprMemImm,
) -> Gpr {
    match arg0 {
        I8 => {
            let v7 = C::is_imm8(ctx, arg2);
            if let Some(v8) = v7 {
                let v9 = constructor_x64_xorb_mi(ctx, arg1, v8);
                // Rule at src/isa/x64/inst.isle line 1893.
                return v9;
            }
            let v19 = C::is_gpr(ctx, arg2);
            if let Some(v20) = v19 {
                let v21 = &C::gpr_to_gpr_mem(ctx, v20);
                let v22 = constructor_x64_xorl_rm(ctx, arg1, v21);
                // Rule at src/isa/x64/inst.isle line 1900.
                return v22;
            }
            let v23 = &C::is_gpr_mem(ctx, arg2);
            if let Some(v24) = v23 {
                let v25 = constructor_x64_xorb_rm(ctx, arg1, v24);
                // Rule at src/isa/x64/inst.isle line 1904.
                return v25;
            }
        }
        I16 => {
            let v10 = C::is_imm16(ctx, arg2);
            if let Some(v11) = v10 {
                let v12 = constructor_x64_xorw_mi(ctx, arg1, v11);
                // Rule at src/isa/x64/inst.isle line 1894.
                return v12;
            }
            let v19 = C::is_gpr(ctx, arg2);
            if let Some(v20) = v19 {
                let v21 = &C::gpr_to_gpr_mem(ctx, v20);
                let v22 = constructor_x64_xorl_rm(ctx, arg1, v21);
                // Rule at src/isa/x64/inst.isle line 1901.
                return v22;
            }
            let v23 = &C::is_gpr_mem(ctx, arg2);
            if let Some(v24) = v23 {
                let v26 = constructor_x64_xorw_rm(ctx, arg1, v24);
                // Rule at src/isa/x64/inst.isle line 1905.
                return v26;
            }
        }
        I32 => {
            let v3 = C::is_simm8(ctx, arg2);
            if let Some(v4) = v3 {
                let v5 = constructor_x64_xorl_mi_sxb(ctx, arg1, v4);
                // Rule at src/isa/x64/inst.isle line 1889.
                return v5;
            }
            let v13 = C::is_imm32(ctx, arg2);
            if let Some(v14) = v13 {
                let v15 = constructor_x64_xorl_mi(ctx, arg1, v14);
                // Rule at src/isa/x64/inst.isle line 1895.
                return v15;
            }
            let v23 = &C::is_gpr_mem(ctx, arg2);
            if let Some(v24) = v23 {
                let v27 = constructor_x64_xorl_rm(ctx, arg1, v24);
                // Rule at src/isa/x64/inst.isle line 1906.
                return v27;
            }
        }
        I64 => {
            let v3 = C::is_simm8(ctx, arg2);
            if let Some(v4) = v3 {
                let v6 = constructor_x64_xorq_mi_sxb(ctx, arg1, v4);
                // Rule at src/isa/x64/inst.isle line 1890.
                return v6;
            }
            let v16 = C::is_simm32(ctx, arg2);
            if let Some(v17) = v16 {
                let v18 = constructor_x64_xorq_mi_sxl(ctx, arg1, v17);
                // Rule at src/isa/x64/inst.isle line 1896.
                return v18;
            }
            let v23 = &C::is_gpr_mem(ctx, arg2);
            if let Some(v24) = v23 {
                let v28 = constructor_x64_xorq_rm(ctx, arg1, v24);
                // Rule at src/isa/x64/inst.isle line 1907.
                return v28;
            }
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_xor", "src/isa/x64/inst.isle line 1886")
}

// Generated as internal constructor for term x64_andn.
pub fn constructor_x64_andn<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Gpr,
    arg2: &GprMem,
) -> Gpr {
    match arg0 {
        I8 => {
            let v3 = constructor_x64_andnl_rvm(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 1915.
            return v3;
        }
        I16 => {
            let v3 = constructor_x64_andnl_rvm(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 1916.
            return v3;
        }
        I32 => {
            let v3 = constructor_x64_andnl_rvm(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 1917.
            return v3;
        }
        I64 => {
            let v4 = constructor_x64_andnq_rvm(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 1918.
            return v4;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_andn", "src/isa/x64/inst.isle line 1914")
}

// Generated as internal constructor for term imm_i64.
pub fn constructor_imm_i64<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: i64,
) -> Reg {
    let v2 = C::i64_cast_unsigned(ctx, arg1);
    let v3 = constructor_imm(ctx, arg0, v2);
    // Rule at src/isa/x64/inst.isle line 1924.
    return v3;
}

// Generated as internal constructor for term imm.
pub fn constructor_imm<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: u64,
) -> Reg {
    if arg1 == 0x0_u64 {
        match arg0 {
            F16 => {
                let v47 = constructor_xmm_zero(ctx, arg0);
                let v48 = C::xmm_to_reg(ctx, v47);
                // Rule at src/isa/x64/inst.isle line 1970.
                return v48;
            }
            F32 => {
                let v47 = constructor_xmm_zero(ctx, arg0);
                let v48 = C::xmm_to_reg(ctx, v47);
                // Rule at src/isa/x64/inst.isle line 1971.
                return v48;
            }
            F64 => {
                let v47 = constructor_xmm_zero(ctx, arg0);
                let v48 = C::xmm_to_reg(ctx, v47);
                // Rule at src/isa/x64/inst.isle line 1972.
                return v48;
            }
            _ => {}
        }
        let v43 = C::multi_lane(ctx, arg0);
        if let Some(v44) = v43 {
            let v47 = constructor_xmm_zero(ctx, arg0);
            let v48 = C::xmm_to_reg(ctx, v47);
            // Rule at src/isa/x64/inst.isle line 1969.
            return v48;
        }
        let v35 = C::fits_in_64(ctx, arg0);
        if let Some(v36) = v35 {
            let v37 = C::ty_int(ctx, v36);
            if let Some(v38) = v37 {
                let v39 = constructor_gpr_uninit_value(ctx);
                let v40 = &C::gpr_to_gpr_mem_imm(ctx, v39);
                let v41 = constructor_x64_xor(ctx, v38, v39, v40);
                let v42 = C::gpr_to_reg(ctx, v41);
                // Rule at src/isa/x64/inst.isle line 1966.
                return v42;
            }
        }
    }
    match arg0 {
        I64 => {
            let v6 = C::u64_from_u32(ctx, arg1);
            if let Some(v7) = v6 {
                let v8 = constructor_x64_movl_oi(ctx, v7);
                let v9 = C::gpr_to_reg(ctx, v8);
                // Rule at src/isa/x64/inst.isle line 1962.
                return v9;
            }
            let v30 = C::u64_cast_signed(ctx, arg1);
            let v31 = C::i64_try_into_i32(ctx, v30);
            if let Some(v32) = v31 {
                let v33 = constructor_x64_movq_mi_sxl(ctx, v32);
                let v34 = C::gpr_to_reg(ctx, v33);
                // Rule at src/isa/x64/inst.isle line 1954.
                return v34;
            }
            let v10 = constructor_x64_movabsq_oi(ctx, arg1);
            let v11 = C::gpr_to_reg(ctx, v10);
            // Rule at src/isa/x64/inst.isle line 1948.
            return v11;
        }
        F16 => {
            let v12 = C::u64_matches_non_zero(ctx, arg1);
            if let Some(v13) = v12 {
                if v13 == true {
                    let v16 = constructor_imm(ctx, I16, arg1);
                    let v17 = C::gpr_new(ctx, v16);
                    let v18 = constructor_bitcast_gpr_to_xmm(ctx, 0x10_u8, v17);
                    let v19 = C::xmm_to_reg(ctx, v18);
                    // Rule at src/isa/x64/inst.isle line 1949.
                    return v19;
                }
            }
        }
        F32 => {
            let v12 = C::u64_matches_non_zero(ctx, arg1);
            if let Some(v13) = v12 {
                if v13 == true {
                    let v21 = constructor_imm(ctx, I32, arg1);
                    let v22 = &C::reg_to_gpr_mem(ctx, v21);
                    let v23 = constructor_x64_movd_to_xmm(ctx, v22);
                    let v24 = C::xmm_to_reg(ctx, v23);
                    // Rule at src/isa/x64/inst.isle line 1950.
                    return v24;
                }
            }
        }
        F64 => {
            let v12 = C::u64_matches_non_zero(ctx, arg1);
            if let Some(v13) = v12 {
                if v13 == true {
                    let v26 = constructor_imm(ctx, I64, arg1);
                    let v27 = &C::reg_to_gpr_mem(ctx, v26);
                    let v28 = constructor_x64_movq_to_xmm(ctx, v27);
                    let v29 = C::xmm_to_reg(ctx, v28);
                    // Rule at src/isa/x64/inst.isle line 1951.
                    return v29;
                }
            }
        }
        _ => {}
    }
    let v1 = C::fits_in_32(ctx, arg0);
    if let Some(v2) = v1 {
        let v3 = C::ty_int(ctx, v2);
        if let Some(v4) = v3 {
            let v6 = C::u64_from_u32(ctx, arg1);
            if let Some(v7) = v6 {
                let v8 = constructor_x64_movl_oi(ctx, v7);
                let v9 = C::gpr_to_reg(ctx, v8);
                // Rule at src/isa/x64/inst.isle line 1945.
                return v9;
            }
        }
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "imm", "src/isa/x64/inst.isle line 1933")
}

// Generated as internal constructor for term xmm_zero.
pub fn constructor_xmm_zero<C: Context>(
    ctx: &mut C,
    arg0: Type,
) -> Xmm {
    let v1 = constructor_xmm_uninit_value(ctx);
    let v2 = &C::xmm_to_xmm_mem(ctx, v1);
    let v3 = constructor_x64_xor_vector(ctx, arg0, v1, v2);
    // Rule at src/isa/x64/inst.isle line 1977.
    return v3;
}

// Generated as internal constructor for term x64_rotl.
pub fn constructor_x64_rotl<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Gpr,
    arg2: &Imm8Gpr,
) -> Gpr {
    match arg2 {
        &Imm8Gpr::Imm8 {
            imm: v5,
        } => {
            let v17 = C::ty_32_or_64(ctx, arg0);
            if let Some(v18) = v17 {
                let v19 = C::has_bmi2(ctx);
                if v19 == true {
                    let v20 = &C::gpr_to_gpr_mem(ctx, arg1);
                    let v21 = C::ty_bits(ctx, v18);
                    let v22 = C::u8_wrapping_sub(ctx, v21, v5);
                    let v23 = constructor_x64_rorx(ctx, v18, v20, v22);
                    // Rule at src/isa/x64/inst.isle line 1995.
                    return v23;
                }
            }
            match arg0 {
                I8 => {
                    if v5 == 0x1_u8 {
                        let v13 = constructor_x64_rolb_m1(ctx, arg1);
                        // Rule at src/isa/x64/inst.isle line 1991.
                        return v13;
                    }
                    let v6 = constructor_x64_rolb_mi(ctx, arg1, v5);
                    // Rule at src/isa/x64/inst.isle line 1984.
                    return v6;
                }
                I16 => {
                    if v5 == 0x1_u8 {
                        let v14 = constructor_x64_rolw_m1(ctx, arg1);
                        // Rule at src/isa/x64/inst.isle line 1992.
                        return v14;
                    }
                    let v8 = constructor_x64_rolw_mi(ctx, arg1, v5);
                    // Rule at src/isa/x64/inst.isle line 1986.
                    return v8;
                }
                I32 => {
                    if v5 == 0x1_u8 {
                        let v15 = constructor_x64_roll_m1(ctx, arg1);
                        // Rule at src/isa/x64/inst.isle line 1993.
                        return v15;
                    }
                    let v10 = constructor_x64_roll_mi(ctx, arg1, v5);
                    // Rule at src/isa/x64/inst.isle line 1988.
                    return v10;
                }
                I64 => {
                    if v5 == 0x1_u8 {
                        let v16 = constructor_x64_rolq_m1(ctx, arg1);
                        // Rule at src/isa/x64/inst.isle line 1994.
                        return v16;
                    }
                    let v12 = constructor_x64_rolq_mi(ctx, arg1, v5);
                    // Rule at src/isa/x64/inst.isle line 1990.
                    return v12;
                }
                _ => {}
            }
        }
        &Imm8Gpr::Gpr {
            reg: v3,
        } => {
            match arg0 {
                I8 => {
                    let v4 = constructor_x64_rolb_mc(ctx, arg1, v3);
                    // Rule at src/isa/x64/inst.isle line 1983.
                    return v4;
                }
                I16 => {
                    let v7 = constructor_x64_rolw_mc(ctx, arg1, v3);
                    // Rule at src/isa/x64/inst.isle line 1985.
                    return v7;
                }
                I32 => {
                    let v9 = constructor_x64_roll_mc(ctx, arg1, v3);
                    // Rule at src/isa/x64/inst.isle line 1987.
                    return v9;
                }
                I64 => {
                    let v11 = constructor_x64_rolq_mc(ctx, arg1, v3);
                    // Rule at src/isa/x64/inst.isle line 1989.
                    return v11;
                }
                _ => {}
            }
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_rotl", "src/isa/x64/inst.isle line 1982")
}

// Generated as internal constructor for term x64_rotr.
pub fn constructor_x64_rotr<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Gpr,
    arg2: &Imm8Gpr,
) -> Gpr {
    match arg2 {
        &Imm8Gpr::Imm8 {
            imm: v5,
        } => {
            let v17 = C::ty_32_or_64(ctx, arg0);
            if let Some(v18) = v17 {
                let v19 = C::has_bmi2(ctx);
                if v19 == true {
                    let v20 = &C::gpr_to_gpr_mem(ctx, arg1);
                    let v21 = constructor_x64_rorx(ctx, v18, v20, v5);
                    // Rule at src/isa/x64/inst.isle line 2013.
                    return v21;
                }
            }
            match arg0 {
                I8 => {
                    if v5 == 0x1_u8 {
                        let v13 = constructor_x64_rorb_m1(ctx, arg1);
                        // Rule at src/isa/x64/inst.isle line 2009.
                        return v13;
                    }
                    let v6 = constructor_x64_rorb_mi(ctx, arg1, v5);
                    // Rule at src/isa/x64/inst.isle line 2002.
                    return v6;
                }
                I16 => {
                    if v5 == 0x1_u8 {
                        let v14 = constructor_x64_rorw_m1(ctx, arg1);
                        // Rule at src/isa/x64/inst.isle line 2010.
                        return v14;
                    }
                    let v8 = constructor_x64_rorw_mi(ctx, arg1, v5);
                    // Rule at src/isa/x64/inst.isle line 2004.
                    return v8;
                }
                I32 => {
                    if v5 == 0x1_u8 {
                        let v15 = constructor_x64_rorl_m1(ctx, arg1);
                        // Rule at src/isa/x64/inst.isle line 2011.
                        return v15;
                    }
                    let v10 = constructor_x64_rorl_mi(ctx, arg1, v5);
                    // Rule at src/isa/x64/inst.isle line 2006.
                    return v10;
                }
                I64 => {
                    if v5 == 0x1_u8 {
                        let v16 = constructor_x64_rorq_m1(ctx, arg1);
                        // Rule at src/isa/x64/inst.isle line 2012.
                        return v16;
                    }
                    let v12 = constructor_x64_rorq_mi(ctx, arg1, v5);
                    // Rule at src/isa/x64/inst.isle line 2008.
                    return v12;
                }
                _ => {}
            }
        }
        &Imm8Gpr::Gpr {
            reg: v3,
        } => {
            match arg0 {
                I8 => {
                    let v4 = constructor_x64_rorb_mc(ctx, arg1, v3);
                    // Rule at src/isa/x64/inst.isle line 2001.
                    return v4;
                }
                I16 => {
                    let v7 = constructor_x64_rorw_mc(ctx, arg1, v3);
                    // Rule at src/isa/x64/inst.isle line 2003.
                    return v7;
                }
                I32 => {
                    let v9 = constructor_x64_rorl_mc(ctx, arg1, v3);
                    // Rule at src/isa/x64/inst.isle line 2005.
                    return v9;
                }
                I64 => {
                    let v11 = constructor_x64_rorq_mc(ctx, arg1, v3);
                    // Rule at src/isa/x64/inst.isle line 2007.
                    return v11;
                }
                _ => {}
            }
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_rotr", "src/isa/x64/inst.isle line 2000")
}

// Generated as internal constructor for term x64_shl.
pub fn constructor_x64_shl<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Gpr,
    arg2: &Imm8Gpr,
) -> Gpr {
    match arg2 {
        &Imm8Gpr::Imm8 {
            imm: v5,
        } => {
            match arg0 {
                I8 => {
                    if v5 == 0x1_u8 {
                        let v13 = constructor_x64_shlb_m1(ctx, arg1);
                        // Rule at src/isa/x64/inst.isle line 2027.
                        return v13;
                    }
                    let v6 = constructor_x64_shlb_mi(ctx, arg1, v5);
                    // Rule at src/isa/x64/inst.isle line 2020.
                    return v6;
                }
                I16 => {
                    if v5 == 0x1_u8 {
                        let v14 = constructor_x64_shlw_m1(ctx, arg1);
                        // Rule at src/isa/x64/inst.isle line 2028.
                        return v14;
                    }
                    let v8 = constructor_x64_shlw_mi(ctx, arg1, v5);
                    // Rule at src/isa/x64/inst.isle line 2022.
                    return v8;
                }
                I32 => {
                    if v5 == 0x1_u8 {
                        let v15 = constructor_x64_shll_m1(ctx, arg1);
                        // Rule at src/isa/x64/inst.isle line 2029.
                        return v15;
                    }
                    let v10 = constructor_x64_shll_mi(ctx, arg1, v5);
                    // Rule at src/isa/x64/inst.isle line 2024.
                    return v10;
                }
                I64 => {
                    if v5 == 0x1_u8 {
                        let v16 = constructor_x64_shlq_m1(ctx, arg1);
                        // Rule at src/isa/x64/inst.isle line 2030.
                        return v16;
                    }
                    let v12 = constructor_x64_shlq_mi(ctx, arg1, v5);
                    // Rule at src/isa/x64/inst.isle line 2026.
                    return v12;
                }
                _ => {}
            }
        }
        &Imm8Gpr::Gpr {
            reg: v3,
        } => {
            let v17 = C::ty_32_or_64(ctx, arg0);
            if let Some(v18) = v17 {
                let v19 = C::has_bmi2(ctx);
                if v19 == true {
                    let v20 = &C::gpr_to_gpr_mem(ctx, arg1);
                    let v21 = constructor_x64_shlx(ctx, v18, v20, v3);
                    // Rule at src/isa/x64/inst.isle line 2035.
                    return v21;
                }
            }
            match arg0 {
                I8 => {
                    let v4 = constructor_x64_shlb_mc(ctx, arg1, v3);
                    // Rule at src/isa/x64/inst.isle line 2019.
                    return v4;
                }
                I16 => {
                    let v7 = constructor_x64_shlw_mc(ctx, arg1, v3);
                    // Rule at src/isa/x64/inst.isle line 2021.
                    return v7;
                }
                I32 => {
                    let v9 = constructor_x64_shll_mc(ctx, arg1, v3);
                    // Rule at src/isa/x64/inst.isle line 2023.
                    return v9;
                }
                I64 => {
                    let v11 = constructor_x64_shlq_mc(ctx, arg1, v3);
                    // Rule at src/isa/x64/inst.isle line 2025.
                    return v11;
                }
                _ => {}
            }
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_shl", "src/isa/x64/inst.isle line 2018")
}

// Generated as internal constructor for term x64_shr.
pub fn constructor_x64_shr<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Gpr,
    arg2: &Imm8Gpr,
) -> Gpr {
    match arg2 {
        &Imm8Gpr::Imm8 {
            imm: v5,
        } => {
            match arg0 {
                I8 => {
                    if v5 == 0x1_u8 {
                        let v13 = constructor_x64_shrb_m1(ctx, arg1);
                        // Rule at src/isa/x64/inst.isle line 2049.
                        return v13;
                    }
                    let v6 = constructor_x64_shrb_mi(ctx, arg1, v5);
                    // Rule at src/isa/x64/inst.isle line 2042.
                    return v6;
                }
                I16 => {
                    if v5 == 0x1_u8 {
                        let v14 = constructor_x64_shrw_m1(ctx, arg1);
                        // Rule at src/isa/x64/inst.isle line 2050.
                        return v14;
                    }
                    let v8 = constructor_x64_shrw_mi(ctx, arg1, v5);
                    // Rule at src/isa/x64/inst.isle line 2044.
                    return v8;
                }
                I32 => {
                    if v5 == 0x1_u8 {
                        let v15 = constructor_x64_shrl_m1(ctx, arg1);
                        // Rule at src/isa/x64/inst.isle line 2051.
                        return v15;
                    }
                    let v10 = constructor_x64_shrl_mi(ctx, arg1, v5);
                    // Rule at src/isa/x64/inst.isle line 2046.
                    return v10;
                }
                I64 => {
                    if v5 == 0x1_u8 {
                        let v16 = constructor_x64_shrq_m1(ctx, arg1);
                        // Rule at src/isa/x64/inst.isle line 2052.
                        return v16;
                    }
                    let v12 = constructor_x64_shrq_mi(ctx, arg1, v5);
                    // Rule at src/isa/x64/inst.isle line 2048.
                    return v12;
                }
                _ => {}
            }
        }
        &Imm8Gpr::Gpr {
            reg: v3,
        } => {
            let v17 = C::ty_32_or_64(ctx, arg0);
            if let Some(v18) = v17 {
                let v19 = C::has_bmi2(ctx);
                if v19 == true {
                    let v20 = &C::gpr_to_gpr_mem(ctx, arg1);
                    let v21 = constructor_x64_shrx(ctx, v18, v20, v3);
                    // Rule at src/isa/x64/inst.isle line 2054.
                    return v21;
                }
            }
            match arg0 {
                I8 => {
                    let v4 = constructor_x64_shrb_mc(ctx, arg1, v3);
                    // Rule at src/isa/x64/inst.isle line 2041.
                    return v4;
                }
                I16 => {
                    let v7 = constructor_x64_shrw_mc(ctx, arg1, v3);
                    // Rule at src/isa/x64/inst.isle line 2043.
                    return v7;
                }
                I32 => {
                    let v9 = constructor_x64_shrl_mc(ctx, arg1, v3);
                    // Rule at src/isa/x64/inst.isle line 2045.
                    return v9;
                }
                I64 => {
                    let v11 = constructor_x64_shrq_mc(ctx, arg1, v3);
                    // Rule at src/isa/x64/inst.isle line 2047.
                    return v11;
                }
                _ => {}
            }
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_shr", "src/isa/x64/inst.isle line 2040")
}

// Generated as internal constructor for term x64_sar.
pub fn constructor_x64_sar<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Gpr,
    arg2: &Imm8Gpr,
) -> Gpr {
    match arg2 {
        &Imm8Gpr::Imm8 {
            imm: v5,
        } => {
            match arg0 {
                I8 => {
                    if v5 == 0x1_u8 {
                        let v13 = constructor_x64_sarb_m1(ctx, arg1);
                        // Rule at src/isa/x64/inst.isle line 2068.
                        return v13;
                    }
                    let v6 = constructor_x64_sarb_mi(ctx, arg1, v5);
                    // Rule at src/isa/x64/inst.isle line 2061.
                    return v6;
                }
                I16 => {
                    if v5 == 0x1_u8 {
                        let v14 = constructor_x64_sarw_m1(ctx, arg1);
                        // Rule at src/isa/x64/inst.isle line 2069.
                        return v14;
                    }
                    let v8 = constructor_x64_sarw_mi(ctx, arg1, v5);
                    // Rule at src/isa/x64/inst.isle line 2063.
                    return v8;
                }
                I32 => {
                    if v5 == 0x1_u8 {
                        let v15 = constructor_x64_sarl_m1(ctx, arg1);
                        // Rule at src/isa/x64/inst.isle line 2070.
                        return v15;
                    }
                    let v10 = constructor_x64_sarl_mi(ctx, arg1, v5);
                    // Rule at src/isa/x64/inst.isle line 2065.
                    return v10;
                }
                I64 => {
                    if v5 == 0x1_u8 {
                        let v16 = constructor_x64_sarq_m1(ctx, arg1);
                        // Rule at src/isa/x64/inst.isle line 2071.
                        return v16;
                    }
                    let v12 = constructor_x64_sarq_mi(ctx, arg1, v5);
                    // Rule at src/isa/x64/inst.isle line 2067.
                    return v12;
                }
                _ => {}
            }
        }
        &Imm8Gpr::Gpr {
            reg: v3,
        } => {
            let v17 = C::ty_32_or_64(ctx, arg0);
            if let Some(v18) = v17 {
                let v19 = C::has_bmi2(ctx);
                if v19 == true {
                    let v20 = &C::gpr_to_gpr_mem(ctx, arg1);
                    let v21 = constructor_x64_sarx(ctx, v18, v20, v3);
                    // Rule at src/isa/x64/inst.isle line 2073.
                    return v21;
                }
            }
            match arg0 {
                I8 => {
                    let v4 = constructor_x64_sarb_mc(ctx, arg1, v3);
                    // Rule at src/isa/x64/inst.isle line 2060.
                    return v4;
                }
                I16 => {
                    let v7 = constructor_x64_sarw_mc(ctx, arg1, v3);
                    // Rule at src/isa/x64/inst.isle line 2062.
                    return v7;
                }
                I32 => {
                    let v9 = constructor_x64_sarl_mc(ctx, arg1, v3);
                    // Rule at src/isa/x64/inst.isle line 2064.
                    return v9;
                }
                I64 => {
                    let v11 = constructor_x64_sarq_mc(ctx, arg1, v3);
                    // Rule at src/isa/x64/inst.isle line 2066.
                    return v11;
                }
                _ => {}
            }
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_sar", "src/isa/x64/inst.isle line 2059")
}

// Generated as internal constructor for term x64_shld.
pub fn constructor_x64_shld<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Gpr,
    arg2: Gpr,
    arg3: u8,
) -> Gpr {
    match arg0 {
        I16 => {
            let v4 = constructor_x64_shldw_mri(ctx, arg1, arg2, arg3);
            // Rule at src/isa/x64/inst.isle line 2080.
            return v4;
        }
        I32 => {
            let v5 = constructor_x64_shldl_mri(ctx, arg1, arg2, arg3);
            // Rule at src/isa/x64/inst.isle line 2081.
            return v5;
        }
        I64 => {
            let v6 = constructor_x64_shldq_mri(ctx, arg1, arg2, arg3);
            // Rule at src/isa/x64/inst.isle line 2082.
            return v6;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_shld", "src/isa/x64/inst.isle line 2078")
}

// Generated as internal constructor for term x64_bzhi.
pub fn constructor_x64_bzhi<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: &GprMem,
    arg2: Gpr,
) -> Gpr {
    match arg0 {
        I32 => {
            let v3 = constructor_x64_bzhil_rmv(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 2086.
            return v3;
        }
        I64 => {
            let v4 = constructor_x64_bzhiq_rmv(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 2087.
            return v4;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_bzhi", "src/isa/x64/inst.isle line 2085")
}

// Generated as internal constructor for term x64_bswap.
pub fn constructor_x64_bswap<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Gpr,
) -> Gpr {
    match arg0 {
        I32 => {
            let v2 = constructor_x64_bswapl_o(ctx, arg1);
            // Rule at src/isa/x64/inst.isle line 2093.
            return v2;
        }
        I64 => {
            let v3 = constructor_x64_bswapq_o(ctx, arg1);
            // Rule at src/isa/x64/inst.isle line 2094.
            return v3;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_bswap", "src/isa/x64/inst.isle line 2092")
}

// Generated as internal constructor for term x64_cmp.
pub fn constructor_x64_cmp<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Gpr,
    arg2: &GprMemImm,
) -> ProducesFlags {
    match arg0 {
        I8 => {
            let v9 = C::is_imm8(ctx, arg2);
            if let Some(v10) = v9 {
                let v5 = &C::gpr_to_gpr_mem(ctx, arg1);
                let v11 = &constructor_x64_cmpb_mi(ctx, v5, v10);
                // Rule at src/isa/x64/inst.isle line 2105.
                return v11.clone();
            }
            let v21 = &C::is_gpr_mem(ctx, arg2);
            if let Some(v22) = v21 {
                let v23 = &constructor_x64_cmpb_rm(ctx, arg1, v22);
                // Rule at src/isa/x64/inst.isle line 2111.
                return v23.clone();
            }
        }
        I16 => {
            let v3 = C::is_simm8(ctx, arg2);
            if let Some(v4) = v3 {
                let v5 = &C::gpr_to_gpr_mem(ctx, arg1);
                let v6 = &constructor_x64_cmpw_mi_sxb(ctx, v5, v4);
                // Rule at src/isa/x64/inst.isle line 2100.
                return v6.clone();
            }
            let v12 = C::is_imm16(ctx, arg2);
            if let Some(v13) = v12 {
                let v5 = &C::gpr_to_gpr_mem(ctx, arg1);
                let v14 = &constructor_x64_cmpw_mi(ctx, v5, v13);
                // Rule at src/isa/x64/inst.isle line 2106.
                return v14.clone();
            }
            let v21 = &C::is_gpr_mem(ctx, arg2);
            if let Some(v22) = v21 {
                let v24 = &constructor_x64_cmpw_rm(ctx, arg1, v22);
                // Rule at src/isa/x64/inst.isle line 2112.
                return v24.clone();
            }
        }
        I32 => {
            let v3 = C::is_simm8(ctx, arg2);
            if let Some(v4) = v3 {
                let v5 = &C::gpr_to_gpr_mem(ctx, arg1);
                let v7 = &constructor_x64_cmpl_mi_sxb(ctx, v5, v4);
                // Rule at src/isa/x64/inst.isle line 2101.
                return v7.clone();
            }
            let v15 = C::is_imm32(ctx, arg2);
            if let Some(v16) = v15 {
                let v5 = &C::gpr_to_gpr_mem(ctx, arg1);
                let v17 = &constructor_x64_cmpl_mi(ctx, v5, v16);
                // Rule at src/isa/x64/inst.isle line 2107.
                return v17.clone();
            }
            let v21 = &C::is_gpr_mem(ctx, arg2);
            if let Some(v22) = v21 {
                let v25 = &constructor_x64_cmpl_rm(ctx, arg1, v22);
                // Rule at src/isa/x64/inst.isle line 2113.
                return v25.clone();
            }
        }
        I64 => {
            let v3 = C::is_simm8(ctx, arg2);
            if let Some(v4) = v3 {
                let v5 = &C::gpr_to_gpr_mem(ctx, arg1);
                let v8 = &constructor_x64_cmpq_mi_sxb(ctx, v5, v4);
                // Rule at src/isa/x64/inst.isle line 2102.
                return v8.clone();
            }
            let v18 = C::is_simm32(ctx, arg2);
            if let Some(v19) = v18 {
                let v5 = &C::gpr_to_gpr_mem(ctx, arg1);
                let v20 = &constructor_x64_cmpq_mi(ctx, v5, v19);
                // Rule at src/isa/x64/inst.isle line 2108.
                return v20.clone();
            }
            let v21 = &C::is_gpr_mem(ctx, arg2);
            if let Some(v22) = v21 {
                let v26 = &constructor_x64_cmpq_rm(ctx, arg1, v22);
                // Rule at src/isa/x64/inst.isle line 2114.
                return v26.clone();
            }
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_cmp", "src/isa/x64/inst.isle line 2097")
}

// Generated as internal constructor for term x64_ucomis.
pub fn constructor_x64_ucomis<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Xmm,
    arg2: &XmmMem,
) -> ProducesFlags {
    match arg0 {
        F32 => {
            let v3 = &constructor_x64_ucomiss_a_or_avx(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 2118.
            return v3.clone();
        }
        F64 => {
            let v4 = &constructor_x64_ucomisd_a_or_avx(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 2119.
            return v4.clone();
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_ucomis", "src/isa/x64/inst.isle line 2117")
}

// Generated as internal constructor for term x64_test.
pub fn constructor_x64_test<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Gpr,
    arg2: &GprMemImm,
) -> ProducesFlags {
    match arg0 {
        I8 => {
            let v3 = C::is_imm8(ctx, arg2);
            if let Some(v4) = v3 {
                let v5 = &C::gpr_to_gpr_mem(ctx, arg1);
                let v6 = &constructor_x64_testb_mi(ctx, v5, v4);
                // Rule at src/isa/x64/inst.isle line 2124.
                return v6.clone();
            }
            let v16 = &C::is_gpr_mem(ctx, arg2);
            if let Some(v17) = v16 {
                let v18 = &constructor_x64_testb_mr(ctx, v17, arg1);
                // Rule at src/isa/x64/inst.isle line 2129.
                return v18.clone();
            }
        }
        I16 => {
            let v7 = C::is_imm16(ctx, arg2);
            if let Some(v8) = v7 {
                let v5 = &C::gpr_to_gpr_mem(ctx, arg1);
                let v9 = &constructor_x64_testw_mi(ctx, v5, v8);
                // Rule at src/isa/x64/inst.isle line 2125.
                return v9.clone();
            }
            let v16 = &C::is_gpr_mem(ctx, arg2);
            if let Some(v17) = v16 {
                let v19 = &constructor_x64_testw_mr(ctx, v17, arg1);
                // Rule at src/isa/x64/inst.isle line 2130.
                return v19.clone();
            }
        }
        I32 => {
            let v10 = C::is_imm32(ctx, arg2);
            if let Some(v11) = v10 {
                let v5 = &C::gpr_to_gpr_mem(ctx, arg1);
                let v12 = &constructor_x64_testl_mi(ctx, v5, v11);
                // Rule at src/isa/x64/inst.isle line 2126.
                return v12.clone();
            }
            let v16 = &C::is_gpr_mem(ctx, arg2);
            if let Some(v17) = v16 {
                let v20 = &constructor_x64_testl_mr(ctx, v17, arg1);
                // Rule at src/isa/x64/inst.isle line 2131.
                return v20.clone();
            }
        }
        I64 => {
            let v13 = C::is_simm32(ctx, arg2);
            if let Some(v14) = v13 {
                let v5 = &C::gpr_to_gpr_mem(ctx, arg1);
                let v15 = &constructor_x64_testq_mi(ctx, v5, v14);
                // Rule at src/isa/x64/inst.isle line 2127.
                return v15.clone();
            }
            let v16 = &C::is_gpr_mem(ctx, arg2);
            if let Some(v17) = v16 {
                let v21 = &constructor_x64_testq_mr(ctx, v17, arg1);
                // Rule at src/isa/x64/inst.isle line 2132.
                return v21.clone();
            }
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_test", "src/isa/x64/inst.isle line 2122")
}

// Generated as internal constructor for term x64_ptest.
pub fn constructor_x64_ptest<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> ProducesFlags {
    let v2 = &constructor_x64_ptest_rm_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2136.
    return v2.clone();
}

// Generated as internal constructor for term cmove.
pub fn constructor_cmove<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: &CC,
    arg2: &GprMem,
    arg3: Gpr,
) -> ConsumesFlags {
    match arg1 {
        &CC::O => {
            if arg0 == I64 {
                let v22 = &constructor_x64_cmovoq_rm(ctx, arg3, arg2);
                // Rule at src/isa/x64/inst.isle line 2168.
                return v22.clone();
            }
            let v1 = C::fits_in_32(ctx, arg0);
            if let Some(v2) = v1 {
                let v6 = &constructor_x64_cmovol_rm(ctx, arg3, arg2);
                // Rule at src/isa/x64/inst.isle line 2152.
                return v6.clone();
            }
        }
        &CC::NO => {
            if arg0 == I64 {
                let v23 = &constructor_x64_cmovnoq_rm(ctx, arg3, arg2);
                // Rule at src/isa/x64/inst.isle line 2169.
                return v23.clone();
            }
            let v1 = C::fits_in_32(ctx, arg0);
            if let Some(v2) = v1 {
                let v7 = &constructor_x64_cmovnol_rm(ctx, arg3, arg2);
                // Rule at src/isa/x64/inst.isle line 2153.
                return v7.clone();
            }
        }
        &CC::B => {
            if arg0 == I64 {
                let v24 = &constructor_x64_cmovbq_rm(ctx, arg3, arg2);
                // Rule at src/isa/x64/inst.isle line 2170.
                return v24.clone();
            }
            let v1 = C::fits_in_32(ctx, arg0);
            if let Some(v2) = v1 {
                let v8 = &constructor_x64_cmovbl_rm(ctx, arg3, arg2);
                // Rule at src/isa/x64/inst.isle line 2154.
                return v8.clone();
            }
        }
        &CC::NB => {
            if arg0 == I64 {
                let v25 = &constructor_x64_cmovaeq_rm(ctx, arg3, arg2);
                // Rule at src/isa/x64/inst.isle line 2171.
                return v25.clone();
            }
            let v1 = C::fits_in_32(ctx, arg0);
            if let Some(v2) = v1 {
                let v9 = &constructor_x64_cmovael_rm(ctx, arg3, arg2);
                // Rule at src/isa/x64/inst.isle line 2155.
                return v9.clone();
            }
        }
        &CC::Z => {
            if arg0 == I64 {
                let v26 = &constructor_x64_cmoveq_rm(ctx, arg3, arg2);
                // Rule at src/isa/x64/inst.isle line 2172.
                return v26.clone();
            }
            let v1 = C::fits_in_32(ctx, arg0);
            if let Some(v2) = v1 {
                let v10 = &constructor_x64_cmovel_rm(ctx, arg3, arg2);
                // Rule at src/isa/x64/inst.isle line 2156.
                return v10.clone();
            }
        }
        &CC::NZ => {
            if arg0 == I64 {
                let v27 = &constructor_x64_cmovneq_rm(ctx, arg3, arg2);
                // Rule at src/isa/x64/inst.isle line 2173.
                return v27.clone();
            }
            let v1 = C::fits_in_32(ctx, arg0);
            if let Some(v2) = v1 {
                let v11 = &constructor_x64_cmovnel_rm(ctx, arg3, arg2);
                // Rule at src/isa/x64/inst.isle line 2157.
                return v11.clone();
            }
        }
        &CC::BE => {
            if arg0 == I64 {
                let v28 = &constructor_x64_cmovbeq_rm(ctx, arg3, arg2);
                // Rule at src/isa/x64/inst.isle line 2174.
                return v28.clone();
            }
            let v1 = C::fits_in_32(ctx, arg0);
            if let Some(v2) = v1 {
                let v12 = &constructor_x64_cmovbel_rm(ctx, arg3, arg2);
                // Rule at src/isa/x64/inst.isle line 2158.
                return v12.clone();
            }
        }
        &CC::NBE => {
            if arg0 == I64 {
                let v29 = &constructor_x64_cmovaq_rm(ctx, arg3, arg2);
                // Rule at src/isa/x64/inst.isle line 2175.
                return v29.clone();
            }
            let v1 = C::fits_in_32(ctx, arg0);
            if let Some(v2) = v1 {
                let v13 = &constructor_x64_cmoval_rm(ctx, arg3, arg2);
                // Rule at src/isa/x64/inst.isle line 2159.
                return v13.clone();
            }
        }
        &CC::S => {
            if arg0 == I64 {
                let v30 = &constructor_x64_cmovsq_rm(ctx, arg3, arg2);
                // Rule at src/isa/x64/inst.isle line 2176.
                return v30.clone();
            }
            let v1 = C::fits_in_32(ctx, arg0);
            if let Some(v2) = v1 {
                let v14 = &constructor_x64_cmovsl_rm(ctx, arg3, arg2);
                // Rule at src/isa/x64/inst.isle line 2160.
                return v14.clone();
            }
        }
        &CC::NS => {
            if arg0 == I64 {
                let v31 = &constructor_x64_cmovnsq_rm(ctx, arg3, arg2);
                // Rule at src/isa/x64/inst.isle line 2177.
                return v31.clone();
            }
            let v1 = C::fits_in_32(ctx, arg0);
            if let Some(v2) = v1 {
                let v15 = &constructor_x64_cmovnsl_rm(ctx, arg3, arg2);
                // Rule at src/isa/x64/inst.isle line 2161.
                return v15.clone();
            }
        }
        &CC::L => {
            if arg0 == I64 {
                let v32 = &constructor_x64_cmovlq_rm(ctx, arg3, arg2);
                // Rule at src/isa/x64/inst.isle line 2178.
                return v32.clone();
            }
            let v1 = C::fits_in_32(ctx, arg0);
            if let Some(v2) = v1 {
                let v16 = &constructor_x64_cmovll_rm(ctx, arg3, arg2);
                // Rule at src/isa/x64/inst.isle line 2162.
                return v16.clone();
            }
        }
        &CC::NL => {
            if arg0 == I64 {
                let v33 = &constructor_x64_cmovgeq_rm(ctx, arg3, arg2);
                // Rule at src/isa/x64/inst.isle line 2179.
                return v33.clone();
            }
            let v1 = C::fits_in_32(ctx, arg0);
            if let Some(v2) = v1 {
                let v17 = &constructor_x64_cmovgel_rm(ctx, arg3, arg2);
                // Rule at src/isa/x64/inst.isle line 2163.
                return v17.clone();
            }
        }
        &CC::LE => {
            if arg0 == I64 {
                let v34 = &constructor_x64_cmovleq_rm(ctx, arg3, arg2);
                // Rule at src/isa/x64/inst.isle line 2180.
                return v34.clone();
            }
            let v1 = C::fits_in_32(ctx, arg0);
            if let Some(v2) = v1 {
                let v18 = &constructor_x64_cmovlel_rm(ctx, arg3, arg2);
                // Rule at src/isa/x64/inst.isle line 2164.
                return v18.clone();
            }
        }
        &CC::NLE => {
            if arg0 == I64 {
                let v35 = &constructor_x64_cmovgq_rm(ctx, arg3, arg2);
                // Rule at src/isa/x64/inst.isle line 2181.
                return v35.clone();
            }
            let v1 = C::fits_in_32(ctx, arg0);
            if let Some(v2) = v1 {
                let v19 = &constructor_x64_cmovgl_rm(ctx, arg3, arg2);
                // Rule at src/isa/x64/inst.isle line 2165.
                return v19.clone();
            }
        }
        &CC::P => {
            if arg0 == I64 {
                let v36 = &constructor_x64_cmovpq_rm(ctx, arg3, arg2);
                // Rule at src/isa/x64/inst.isle line 2182.
                return v36.clone();
            }
            let v1 = C::fits_in_32(ctx, arg0);
            if let Some(v2) = v1 {
                let v20 = &constructor_x64_cmovpl_rm(ctx, arg3, arg2);
                // Rule at src/isa/x64/inst.isle line 2166.
                return v20.clone();
            }
        }
        &CC::NP => {
            if arg0 == I64 {
                let v37 = &constructor_x64_cmovnpq_rm(ctx, arg3, arg2);
                // Rule at src/isa/x64/inst.isle line 2183.
                return v37.clone();
            }
            let v1 = C::fits_in_32(ctx, arg0);
            if let Some(v2) = v1 {
                let v21 = &constructor_x64_cmovnpl_rm(ctx, arg3, arg2);
                // Rule at src/isa/x64/inst.isle line 2167.
                return v21.clone();
            }
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "cmove", "src/isa/x64/inst.isle line 2151")
}

// Generated as internal constructor for term cmove_xmm.
pub fn constructor_cmove_xmm<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: &CC,
    arg2: Xmm,
    arg3: Xmm,
) -> ConsumesFlags {
    let v4 = C::temp_writable_xmm(ctx);
    let v6 = constructor_writable_xmm_to_r_reg(ctx, v4);
    let v5 = MInst::XmmCmove {
        ty: arg0,
        cc: arg1.clone(),
        consequent: arg2,
        alternative: arg3,
        dst: v4,
    };
    let v7 = ConsumesFlags::ConsumesFlagsReturnsReg {
        inst: v5,
        result: v6,
    };
    // Rule at src/isa/x64/inst.isle line 2186.
    return v7;
}

// Generated as internal constructor for term x64_setcc.
pub fn constructor_x64_setcc<C: Context>(
    ctx: &mut C,
    arg0: &CC,
) -> ConsumesFlags {
    match arg0 {
        &CC::O => {
            let v1 = &constructor_x64_seto_m(ctx);
            // Rule at src/isa/x64/inst.isle line 2199.
            return v1.clone();
        }
        &CC::NO => {
            let v2 = &constructor_x64_setno_m(ctx);
            // Rule at src/isa/x64/inst.isle line 2200.
            return v2.clone();
        }
        &CC::B => {
            let v3 = &constructor_x64_setb_m(ctx);
            // Rule at src/isa/x64/inst.isle line 2201.
            return v3.clone();
        }
        &CC::NB => {
            let v4 = &constructor_x64_setae_m(ctx);
            // Rule at src/isa/x64/inst.isle line 2202.
            return v4.clone();
        }
        &CC::Z => {
            let v5 = &constructor_x64_sete_m(ctx);
            // Rule at src/isa/x64/inst.isle line 2203.
            return v5.clone();
        }
        &CC::NZ => {
            let v6 = &constructor_x64_setne_m(ctx);
            // Rule at src/isa/x64/inst.isle line 2204.
            return v6.clone();
        }
        &CC::BE => {
            let v7 = &constructor_x64_setbe_m(ctx);
            // Rule at src/isa/x64/inst.isle line 2205.
            return v7.clone();
        }
        &CC::NBE => {
            let v8 = &constructor_x64_seta_m(ctx);
            // Rule at src/isa/x64/inst.isle line 2206.
            return v8.clone();
        }
        &CC::S => {
            let v9 = &constructor_x64_sets_m(ctx);
            // Rule at src/isa/x64/inst.isle line 2207.
            return v9.clone();
        }
        &CC::NS => {
            let v10 = &constructor_x64_setns_m(ctx);
            // Rule at src/isa/x64/inst.isle line 2208.
            return v10.clone();
        }
        &CC::L => {
            let v11 = &constructor_x64_setl_m(ctx);
            // Rule at src/isa/x64/inst.isle line 2209.
            return v11.clone();
        }
        &CC::NL => {
            let v12 = &constructor_x64_setge_m(ctx);
            // Rule at src/isa/x64/inst.isle line 2210.
            return v12.clone();
        }
        &CC::LE => {
            let v13 = &constructor_x64_setle_m(ctx);
            // Rule at src/isa/x64/inst.isle line 2211.
            return v13.clone();
        }
        &CC::NLE => {
            let v14 = &constructor_x64_setg_m(ctx);
            // Rule at src/isa/x64/inst.isle line 2212.
            return v14.clone();
        }
        &CC::P => {
            let v15 = &constructor_x64_setp_m(ctx);
            // Rule at src/isa/x64/inst.isle line 2213.
            return v15.clone();
        }
        &CC::NP => {
            let v16 = &constructor_x64_setnp_m(ctx);
            // Rule at src/isa/x64/inst.isle line 2214.
            return v16.clone();
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_setcc", "src/isa/x64/inst.isle line 2198")
}

// Generated as internal constructor for term x64_setcc_paired.
pub fn constructor_x64_setcc_paired<C: Context>(
    ctx: &mut C,
    arg0: &CC,
) -> ConsumesFlags {
    let v1 = &constructor_x64_setcc(ctx, arg0);
    let v2 = &constructor_consumes_flags_with_producer(ctx, v1);
    // Rule at src/isa/x64/inst.isle line 2219.
    return v2.clone();
}

// Generated as internal constructor for term consumes_flags_with_producer.
pub fn constructor_consumes_flags_with_producer<C: Context>(
    ctx: &mut C,
    arg0: &ConsumesFlags,
) -> ConsumesFlags {
    if let &ConsumesFlags::ConsumesFlagsReturnsReg {
        inst: ref v1,
        result: v2,
    } = arg0 {
        let v3 = ConsumesFlags::ConsumesFlagsReturnsResultWithProducer {
            inst: v1.clone(),
            result: v2,
        };
        // Rule at src/isa/x64/inst.isle line 2222.
        return v3;
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "consumes_flags_with_producer", "src/isa/x64/inst.isle line 2221")
}

// Generated as internal constructor for term x64_addss.
pub fn constructor_x64_addss<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = constructor_x64_addss_a_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2228.
    return v2;
}

// Generated as internal constructor for term x64_addsd.
pub fn constructor_x64_addsd<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = constructor_x64_addsd_a_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2231.
    return v2;
}

// Generated as internal constructor for term x64_addps.
pub fn constructor_x64_addps<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = constructor_x64_addps_a_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2234.
    return v2;
}

// Generated as internal constructor for term x64_addpd.
pub fn constructor_x64_addpd<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = constructor_x64_addpd_a_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2237.
    return v2;
}

// Generated as internal constructor for term x64_paddb.
pub fn constructor_x64_paddb<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = constructor_x64_paddb_a_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2240.
    return v2;
}

// Generated as internal constructor for term x64_paddw.
pub fn constructor_x64_paddw<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = constructor_x64_paddw_a_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2243.
    return v2;
}

// Generated as internal constructor for term x64_paddd.
pub fn constructor_x64_paddd<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = constructor_x64_paddd_a_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2246.
    return v2;
}

// Generated as internal constructor for term x64_paddq.
pub fn constructor_x64_paddq<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = constructor_x64_paddq_a_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2249.
    return v2;
}

// Generated as internal constructor for term x64_paddsb.
pub fn constructor_x64_paddsb<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = constructor_x64_paddsb_a_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2252.
    return v2;
}

// Generated as internal constructor for term x64_paddsw.
pub fn constructor_x64_paddsw<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = constructor_x64_paddsw_a_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2255.
    return v2;
}

// Generated as internal constructor for term x64_phaddw.
pub fn constructor_x64_phaddw<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = constructor_x64_phaddw_a_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2258.
    return v2;
}

// Generated as internal constructor for term x64_phaddd.
pub fn constructor_x64_phaddd<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = constructor_x64_phaddd_a_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2261.
    return v2;
}

// Generated as internal constructor for term x64_paddusb.
pub fn constructor_x64_paddusb<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = constructor_x64_paddusb_a_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2264.
    return v2;
}

// Generated as internal constructor for term x64_paddusw.
pub fn constructor_x64_paddusw<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = constructor_x64_paddusw_a_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2267.
    return v2;
}

// Generated as internal constructor for term x64_subss.
pub fn constructor_x64_subss<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = constructor_x64_subss_a_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2271.
    return v2;
}

// Generated as internal constructor for term x64_subsd.
pub fn constructor_x64_subsd<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = constructor_x64_subsd_a_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2274.
    return v2;
}

// Generated as internal constructor for term x64_subps.
pub fn constructor_x64_subps<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = constructor_x64_subps_a_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2277.
    return v2;
}

// Generated as internal constructor for term x64_subpd.
pub fn constructor_x64_subpd<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = constructor_x64_subpd_a_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2280.
    return v2;
}

// Generated as internal constructor for term x64_psubb.
pub fn constructor_x64_psubb<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = constructor_x64_psubb_a_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2283.
    return v2;
}

// Generated as internal constructor for term x64_psubw.
pub fn constructor_x64_psubw<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = constructor_x64_psubw_a_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2286.
    return v2;
}

// Generated as internal constructor for term x64_psubd.
pub fn constructor_x64_psubd<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = constructor_x64_psubd_a_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2289.
    return v2;
}

// Generated as internal constructor for term x64_psubq.
pub fn constructor_x64_psubq<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = constructor_x64_psubq_a_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2292.
    return v2;
}

// Generated as internal constructor for term x64_psubsb.
pub fn constructor_x64_psubsb<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = constructor_x64_psubsb_a_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2295.
    return v2;
}

// Generated as internal constructor for term x64_psubsw.
pub fn constructor_x64_psubsw<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = constructor_x64_psubsw_a_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2298.
    return v2;
}

// Generated as internal constructor for term x64_psubusb.
pub fn constructor_x64_psubusb<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = constructor_x64_psubusb_a_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2301.
    return v2;
}

// Generated as internal constructor for term x64_psubusw.
pub fn constructor_x64_psubusw<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = constructor_x64_psubusw_a_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2304.
    return v2;
}

// Generated as internal constructor for term x64_pavgb.
pub fn constructor_x64_pavgb<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = constructor_x64_pavgb_a_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2308.
    return v2;
}

// Generated as internal constructor for term x64_pavgw.
pub fn constructor_x64_pavgw<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = constructor_x64_pavgw_a_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2311.
    return v2;
}

// Generated as internal constructor for term x64_pand.
pub fn constructor_x64_pand<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = constructor_x64_pand_a_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2315.
    return v2;
}

// Generated as internal constructor for term x64_andps.
pub fn constructor_x64_andps<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = constructor_x64_andps_a_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2318.
    return v2;
}

// Generated as internal constructor for term x64_andpd.
pub fn constructor_x64_andpd<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = constructor_x64_andpd_a_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2321.
    return v2;
}

// Generated as internal constructor for term x64_por.
pub fn constructor_x64_por<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = constructor_x64_por_a_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2325.
    return v2;
}

// Generated as internal constructor for term x64_orps.
pub fn constructor_x64_orps<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = constructor_x64_orps_a_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2328.
    return v2;
}

// Generated as internal constructor for term x64_orpd.
pub fn constructor_x64_orpd<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = constructor_x64_orpd_a_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2331.
    return v2;
}

// Generated as internal constructor for term x64_pxor.
pub fn constructor_x64_pxor<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = constructor_x64_pxor_a_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2335.
    return v2;
}

// Generated as internal constructor for term x64_xorps.
pub fn constructor_x64_xorps<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = constructor_x64_xorps_a_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2338.
    return v2;
}

// Generated as internal constructor for term x64_xorpd.
pub fn constructor_x64_xorpd<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = constructor_x64_xorpd_a_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2341.
    return v2;
}

// Generated as internal constructor for term x64_andnps.
pub fn constructor_x64_andnps<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = constructor_x64_andnps_a_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2345.
    return v2;
}

// Generated as internal constructor for term x64_andnpd.
pub fn constructor_x64_andnpd<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = constructor_x64_andnpd_a_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2348.
    return v2;
}

// Generated as internal constructor for term x64_pandn.
pub fn constructor_x64_pandn<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = constructor_x64_pandn_a_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2351.
    return v2;
}

// Generated as internal constructor for term x64_mulss.
pub fn constructor_x64_mulss<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = constructor_x64_mulss_a_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2355.
    return v2;
}

// Generated as internal constructor for term x64_mulsd.
pub fn constructor_x64_mulsd<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = constructor_x64_mulsd_a_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2358.
    return v2;
}

// Generated as internal constructor for term x64_mulps.
pub fn constructor_x64_mulps<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = constructor_x64_mulps_a_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2361.
    return v2;
}

// Generated as internal constructor for term x64_mulpd.
pub fn constructor_x64_mulpd<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = constructor_x64_mulpd_a_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2364.
    return v2;
}

// Generated as internal constructor for term x64_pmullw.
pub fn constructor_x64_pmullw<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = constructor_x64_pmullw_a_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2367.
    return v2;
}

// Generated as internal constructor for term x64_pmulld.
pub fn constructor_x64_pmulld<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = constructor_x64_pmulld_a_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2370.
    return v2;
}

// Generated as internal constructor for term x64_pmulhw.
pub fn constructor_x64_pmulhw<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = constructor_x64_pmulhw_a_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2373.
    return v2;
}

// Generated as internal constructor for term x64_pmulhrsw.
pub fn constructor_x64_pmulhrsw<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = constructor_x64_pmulhrsw_a_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2376.
    return v2;
}

// Generated as internal constructor for term x64_pmulhuw.
pub fn constructor_x64_pmulhuw<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = constructor_x64_pmulhuw_a_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2379.
    return v2;
}

// Generated as internal constructor for term x64_pmuldq.
pub fn constructor_x64_pmuldq<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = constructor_x64_pmuldq_a_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2382.
    return v2;
}

// Generated as internal constructor for term x64_pmuludq.
pub fn constructor_x64_pmuludq<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = constructor_x64_pmuludq_a_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2385.
    return v2;
}

// Generated as internal constructor for term x64_divss.
pub fn constructor_x64_divss<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = constructor_x64_divss_a_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2389.
    return v2;
}

// Generated as internal constructor for term x64_divsd.
pub fn constructor_x64_divsd<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = constructor_x64_divsd_a_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2392.
    return v2;
}

// Generated as internal constructor for term x64_divps.
pub fn constructor_x64_divps<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = constructor_x64_divps_a_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2395.
    return v2;
}

// Generated as internal constructor for term x64_divpd.
pub fn constructor_x64_divpd<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = constructor_x64_divpd_a_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2398.
    return v2;
}

// Generated as internal constructor for term x64_punpckhwd.
pub fn constructor_x64_punpckhwd<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = constructor_x64_punpckhwd_a_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2402.
    return v2;
}

// Generated as internal constructor for term x64_punpcklwd.
pub fn constructor_x64_punpcklwd<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = constructor_x64_punpcklwd_a_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2405.
    return v2;
}

// Generated as internal constructor for term x64_punpckldq.
pub fn constructor_x64_punpckldq<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = constructor_x64_punpckldq_a_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2408.
    return v2;
}

// Generated as internal constructor for term x64_punpckhdq.
pub fn constructor_x64_punpckhdq<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = constructor_x64_punpckhdq_a_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2411.
    return v2;
}

// Generated as internal constructor for term x64_punpcklqdq.
pub fn constructor_x64_punpcklqdq<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = constructor_x64_punpcklqdq_a_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2414.
    return v2;
}

// Generated as internal constructor for term x64_punpckhqdq.
pub fn constructor_x64_punpckhqdq<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = constructor_x64_punpckhqdq_a_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2417.
    return v2;
}

// Generated as internal constructor for term x64_unpcklps.
pub fn constructor_x64_unpcklps<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = constructor_x64_unpcklps_a_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2420.
    return v2;
}

// Generated as internal constructor for term x64_unpcklpd.
pub fn constructor_x64_unpcklpd<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = constructor_x64_unpcklpd_a_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2423.
    return v2;
}

// Generated as internal constructor for term x64_unpckhps.
pub fn constructor_x64_unpckhps<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = constructor_x64_unpckhps_a_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2426.
    return v2;
}

// Generated as internal constructor for term x64_punpcklbw.
pub fn constructor_x64_punpcklbw<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = constructor_x64_punpcklbw_a_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2429.
    return v2;
}

// Generated as internal constructor for term x64_punpckhbw.
pub fn constructor_x64_punpckhbw<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = constructor_x64_punpckhbw_a_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2432.
    return v2;
}

// Generated as internal constructor for term x64_blendvpd.
pub fn constructor_x64_blendvpd<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
    arg2: Xmm,
) -> Xmm {
    let v5 = C::has_avx(ctx);
    if v5 == true {
        let v6 = constructor_x64_vblendvpd_rvmr(ctx, arg0, arg1, arg2);
        // Rule at src/isa/x64/inst.isle line 2437.
        return v6;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v4 = constructor_x64_blendvpd_rm0(ctx, arg0, v3, arg2);
    // Rule at src/isa/x64/inst.isle line 2436.
    return v4;
}

// Generated as internal constructor for term x64_blendvps.
pub fn constructor_x64_blendvps<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
    arg2: Xmm,
) -> Xmm {
    let v5 = C::has_avx(ctx);
    if v5 == true {
        let v6 = constructor_x64_vblendvps_rvmr(ctx, arg0, arg1, arg2);
        // Rule at src/isa/x64/inst.isle line 2444.
        return v6;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v4 = constructor_x64_blendvps_rm0(ctx, arg0, v3, arg2);
    // Rule at src/isa/x64/inst.isle line 2443.
    return v4;
}

// Generated as internal constructor for term x64_pblendvb.
pub fn constructor_x64_pblendvb<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
    arg2: Xmm,
) -> Xmm {
    let v5 = C::has_avx(ctx);
    if v5 == true {
        let v6 = constructor_x64_vpblendvb_rvmr(ctx, arg0, arg1, arg2);
        // Rule at src/isa/x64/inst.isle line 2451.
        return v6;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v4 = constructor_x64_pblendvb_rm(ctx, arg0, v3, arg2);
    // Rule at src/isa/x64/inst.isle line 2450.
    return v4;
}

// Generated as internal constructor for term x64_pblendw.
pub fn constructor_x64_pblendw<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
    arg2: u8,
) -> Xmm {
    let v3 = constructor_x64_pblendw_rmi_or_avx(ctx, arg0, arg1, arg2);
    // Rule at src/isa/x64/inst.isle line 2457.
    return v3;
}

// Generated as internal constructor for term x64_movsd_regmove.
pub fn constructor_x64_movsd_regmove<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: Xmm,
) -> Xmm {
    let v2 = constructor_x64_movsd_a_r_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2468.
    return v2;
}

// Generated as internal constructor for term x64_movss_regmove.
pub fn constructor_x64_movss_regmove<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: Xmm,
) -> Xmm {
    let v2 = constructor_x64_movss_a_r_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2471.
    return v2;
}

// Generated as internal constructor for term x64_movlhps.
pub fn constructor_x64_movlhps<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: Xmm,
) -> Xmm {
    let v2 = constructor_x64_movlhps_rm_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2475.
    return v2;
}

// Generated as internal constructor for term x64_pmaxs.
pub fn constructor_x64_pmaxs<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Xmm,
    arg2: &XmmMem,
) -> Xmm {
    match arg0 {
        I8X16 => {
            let v3 = constructor_x64_pmaxsb_a_or_avx(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 2479.
            return v3;
        }
        I16X8 => {
            let v4 = constructor_x64_pmaxsw_a_or_avx(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 2480.
            return v4;
        }
        I32X4 => {
            let v5 = constructor_x64_pmaxsd_a_or_avx(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 2481.
            return v5;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_pmaxs", "src/isa/x64/inst.isle line 2478")
}

// Generated as internal constructor for term x64_pmins.
pub fn constructor_x64_pmins<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Xmm,
    arg2: &XmmMem,
) -> Xmm {
    match arg0 {
        I8X16 => {
            let v3 = constructor_x64_pminsb_a_or_avx(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 2486.
            return v3;
        }
        I16X8 => {
            let v4 = constructor_x64_pminsw_a_or_avx(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 2487.
            return v4;
        }
        I32X4 => {
            let v5 = constructor_x64_pminsd_a_or_avx(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 2488.
            return v5;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_pmins", "src/isa/x64/inst.isle line 2485")
}

// Generated as internal constructor for term x64_pmaxu.
pub fn constructor_x64_pmaxu<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Xmm,
    arg2: &XmmMem,
) -> Xmm {
    match arg0 {
        I8X16 => {
            let v3 = constructor_x64_pmaxub_a_or_avx(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 2493.
            return v3;
        }
        I16X8 => {
            let v4 = constructor_x64_pmaxuw_a_or_avx(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 2494.
            return v4;
        }
        I32X4 => {
            let v5 = constructor_x64_pmaxud_a_or_avx(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 2495.
            return v5;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_pmaxu", "src/isa/x64/inst.isle line 2492")
}

// Generated as internal constructor for term x64_pminu.
pub fn constructor_x64_pminu<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Xmm,
    arg2: &XmmMem,
) -> Xmm {
    match arg0 {
        I8X16 => {
            let v3 = constructor_x64_pminub_a_or_avx(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 2500.
            return v3;
        }
        I16X8 => {
            let v4 = constructor_x64_pminuw_a_or_avx(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 2501.
            return v4;
        }
        I32X4 => {
            let v5 = constructor_x64_pminud_a_or_avx(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 2502.
            return v5;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_pminu", "src/isa/x64/inst.isle line 2499")
}

// Generated as internal constructor for term x64_packsswb.
pub fn constructor_x64_packsswb<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = constructor_x64_packsswb_a_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2507.
    return v2;
}

// Generated as internal constructor for term x64_packssdw.
pub fn constructor_x64_packssdw<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = constructor_x64_packssdw_a_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2511.
    return v2;
}

// Generated as internal constructor for term x64_packuswb.
pub fn constructor_x64_packuswb<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = constructor_x64_packuswb_a_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2515.
    return v2;
}

// Generated as internal constructor for term x64_packusdw.
pub fn constructor_x64_packusdw<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = constructor_x64_packusdw_a_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2519.
    return v2;
}

// Generated as internal constructor for term x64_palignr.
pub fn constructor_x64_palignr<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
    arg2: u8,
) -> Xmm {
    let v3 = constructor_x64_palignr_a_or_avx(ctx, arg0, arg1, arg2);
    // Rule at src/isa/x64/inst.isle line 2523.
    return v3;
}

// Generated as internal constructor for term x64_cmpp.
pub fn constructor_x64_cmpp<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Xmm,
    arg2: &XmmMem,
    arg3: &FcmpImm,
) -> Xmm {
    match arg0 {
        F32X4 => {
            let v4 = constructor_x64_cmpps(ctx, arg1, arg2, arg3);
            // Rule at src/isa/x64/inst.isle line 2527.
            return v4;
        }
        F64X2 => {
            let v5 = constructor_x64_cmppd(ctx, arg1, arg2, arg3);
            // Rule at src/isa/x64/inst.isle line 2528.
            return v5;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_cmpp", "src/isa/x64/inst.isle line 2526")
}

// Generated as internal constructor for term x64_cmpps.
pub fn constructor_x64_cmpps<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
    arg2: &FcmpImm,
) -> Xmm {
    let v3 = C::has_avx(ctx);
    if v3 == true {
        let v4 = C::encode_fcmp_imm(ctx, arg2);
        let v5 = constructor_x64_vcmpps_b(ctx, arg0, arg1, v4);
        // Rule at src/isa/x64/inst.isle line 2531.
        return v5;
    }
    let v4 = C::encode_fcmp_imm(ctx, arg2);
    let v6 = constructor_x64_cmpps_a(ctx, arg0, arg1, v4);
    // Rule at src/isa/x64/inst.isle line 2534.
    return v6;
}

// Generated as internal constructor for term x64_cmppd.
pub fn constructor_x64_cmppd<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
    arg2: &FcmpImm,
) -> Xmm {
    let v3 = C::has_avx(ctx);
    if v3 == true {
        let v4 = C::encode_fcmp_imm(ctx, arg2);
        let v5 = constructor_x64_vcmppd_b(ctx, arg0, arg1, v4);
        // Rule at src/isa/x64/inst.isle line 2540.
        return v5;
    }
    let v4 = C::encode_fcmp_imm(ctx, arg2);
    let v6 = constructor_x64_cmppd_a(ctx, arg0, arg1, v4);
    // Rule at src/isa/x64/inst.isle line 2543.
    return v6;
}

// Generated as internal constructor for term x64_pinsrb.
pub fn constructor_x64_pinsrb<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &GprMem,
    arg2: u8,
) -> Xmm {
    let v3 = C::has_avx(ctx);
    if v3 == true {
        let v4 = constructor_x64_vpinsrb_b(ctx, arg0, arg1, arg2);
        // Rule at src/isa/x64/inst.isle line 2547.
        return v4;
    }
    let v5 = constructor_x64_pinsrb_a(ctx, arg0, arg1, arg2);
    // Rule at src/isa/x64/inst.isle line 2550.
    return v5;
}

// Generated as internal constructor for term x64_pinsrw.
pub fn constructor_x64_pinsrw<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &GprMem,
    arg2: u8,
) -> Xmm {
    let v3 = C::has_avx(ctx);
    if v3 == true {
        let v4 = constructor_x64_vpinsrw_b(ctx, arg0, arg1, arg2);
        // Rule at src/isa/x64/inst.isle line 2554.
        return v4;
    }
    let v5 = constructor_x64_pinsrw_a(ctx, arg0, arg1, arg2);
    // Rule at src/isa/x64/inst.isle line 2557.
    return v5;
}

// Generated as internal constructor for term x64_pinsrd.
pub fn constructor_x64_pinsrd<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &GprMem,
    arg2: u8,
) -> Xmm {
    let v3 = C::has_avx(ctx);
    if v3 == true {
        let v4 = constructor_x64_vpinsrd_b(ctx, arg0, arg1, arg2);
        // Rule at src/isa/x64/inst.isle line 2561.
        return v4;
    }
    let v5 = constructor_x64_pinsrd_a(ctx, arg0, arg1, arg2);
    // Rule at src/isa/x64/inst.isle line 2564.
    return v5;
}

// Generated as internal constructor for term x64_pinsrq.
pub fn constructor_x64_pinsrq<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &GprMem,
    arg2: u8,
) -> Xmm {
    let v3 = C::has_avx(ctx);
    if v3 == true {
        let v4 = constructor_x64_vpinsrq_b(ctx, arg0, arg1, arg2);
        // Rule at src/isa/x64/inst.isle line 2568.
        return v4;
    }
    let v5 = constructor_x64_pinsrq_a(ctx, arg0, arg1, arg2);
    // Rule at src/isa/x64/inst.isle line 2571.
    return v5;
}

// Generated as internal constructor for term x64_roundss.
pub fn constructor_x64_roundss<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
    arg1: &RoundImm,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v4 = constructor_xmm_zero(ctx, F32X4);
        let v5 = C::encode_round_imm(ctx, arg1);
        let v6 = constructor_x64_vroundss_rvmi(ctx, v4, arg0, v5);
        // Rule at src/isa/x64/inst.isle line 2575.
        return v6;
    }
    let v7 = C::encode_round_imm(ctx, arg1);
    let v8 = constructor_x64_roundss_rmi(ctx, arg0, v7);
    // Rule at src/isa/x64/inst.isle line 2578.
    return v8;
}

// Generated as internal constructor for term x64_roundsd.
pub fn constructor_x64_roundsd<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
    arg1: &RoundImm,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v4 = constructor_xmm_zero(ctx, F64X2);
        let v5 = C::encode_round_imm(ctx, arg1);
        let v6 = constructor_x64_vroundsd_rvmi(ctx, v4, arg0, v5);
        // Rule at src/isa/x64/inst.isle line 2583.
        return v6;
    }
    let v7 = C::encode_round_imm(ctx, arg1);
    let v8 = constructor_x64_roundsd_rmi(ctx, arg0, v7);
    // Rule at src/isa/x64/inst.isle line 2586.
    return v8;
}

// Generated as internal constructor for term x64_roundps.
pub fn constructor_x64_roundps<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
    arg1: &RoundImm,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = C::encode_round_imm(ctx, arg1);
        let v4 = constructor_x64_vroundps_rmi(ctx, arg0, v3);
        // Rule at src/isa/x64/inst.isle line 2591.
        return v4;
    }
    let v5 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg0);
    let v6 = C::encode_round_imm(ctx, arg1);
    let v7 = constructor_x64_roundps_rmi(ctx, v5, v6);
    // Rule at src/isa/x64/inst.isle line 2594.
    return v7;
}

// Generated as internal constructor for term x64_roundpd.
pub fn constructor_x64_roundpd<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
    arg1: &RoundImm,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = C::encode_round_imm(ctx, arg1);
        let v4 = constructor_x64_vroundpd_rmi(ctx, arg0, v3);
        // Rule at src/isa/x64/inst.isle line 2599.
        return v4;
    }
    let v5 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg0);
    let v6 = C::encode_round_imm(ctx, arg1);
    let v7 = constructor_x64_roundpd_rmi(ctx, v5, v6);
    // Rule at src/isa/x64/inst.isle line 2602.
    return v7;
}

// Generated as internal constructor for term x64_pmaddwd.
pub fn constructor_x64_pmaddwd<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = constructor_x64_pmaddwd_a_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2607.
    return v2;
}

// Generated as internal constructor for term x64_pmaddubsw.
pub fn constructor_x64_pmaddubsw<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = constructor_x64_pmaddubsw_a_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2610.
    return v2;
}

// Generated as internal constructor for term x64_insertps.
pub fn constructor_x64_insertps<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
    arg2: u8,
) -> Xmm {
    let v3 = constructor_x64_insertps_a_or_avx(ctx, arg0, arg1, arg2);
    // Rule at src/isa/x64/inst.isle line 2614.
    return v3;
}

// Generated as internal constructor for term x64_pshufd.
pub fn constructor_x64_pshufd<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
    arg1: u8,
) -> Xmm {
    let v4 = C::has_avx(ctx);
    if v4 == true {
        let v5 = constructor_x64_vpshufd_a(ctx, arg0, arg1);
        // Rule at src/isa/x64/inst.isle line 2619.
        return v5;
    }
    let v2 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg0);
    let v3 = constructor_x64_pshufd_a(ctx, v2, arg1);
    // Rule at src/isa/x64/inst.isle line 2618.
    return v3;
}

// Generated as internal constructor for term x64_pshufb.
pub fn constructor_x64_pshufb<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = constructor_x64_pshufb_a_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2625.
    return v2;
}

// Generated as internal constructor for term x64_shufpd.
pub fn constructor_x64_shufpd<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
    arg2: u8,
) -> Xmm {
    let v3 = constructor_x64_shufpd_a_or_avx(ctx, arg0, arg1, arg2);
    // Rule at src/isa/x64/inst.isle line 2629.
    return v3;
}

// Generated as internal constructor for term x64_shufps.
pub fn constructor_x64_shufps<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
    arg2: u8,
) -> Xmm {
    let v3 = constructor_x64_shufps_a_or_avx(ctx, arg0, arg1, arg2);
    // Rule at src/isa/x64/inst.isle line 2633.
    return v3;
}

// Generated as internal constructor for term x64_pshuflw.
pub fn constructor_x64_pshuflw<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
    arg1: u8,
) -> Xmm {
    let v4 = C::has_avx(ctx);
    if v4 == true {
        let v5 = constructor_x64_vpshuflw_a(ctx, arg0, arg1);
        // Rule at src/isa/x64/inst.isle line 2638.
        return v5;
    }
    let v2 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg0);
    let v3 = constructor_x64_pshuflw_a(ctx, v2, arg1);
    // Rule at src/isa/x64/inst.isle line 2637.
    return v3;
}

// Generated as internal constructor for term x64_pshufhw.
pub fn constructor_x64_pshufhw<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
    arg1: u8,
) -> Xmm {
    let v4 = C::has_avx(ctx);
    if v4 == true {
        let v5 = constructor_x64_vpshufhw_a(ctx, arg0, arg1);
        // Rule at src/isa/x64/inst.isle line 2645.
        return v5;
    }
    let v2 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg0);
    let v3 = constructor_x64_pshufhw_a(ctx, v2, arg1);
    // Rule at src/isa/x64/inst.isle line 2644.
    return v3;
}

// Generated as internal constructor for term x64_vcvtudq2ps.
pub fn constructor_x64_vcvtudq2ps<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = constructor_x64_vcvtudq2ps_a(ctx, arg0);
    // Rule at src/isa/x64/inst.isle line 2653.
    return v1;
}

// Generated as internal constructor for term x64_vpabsq.
pub fn constructor_x64_vpabsq<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = constructor_x64_vpabsq_c(ctx, arg0);
    // Rule at src/isa/x64/inst.isle line 2657.
    return v1;
}

// Generated as internal constructor for term x64_vpopcntb.
pub fn constructor_x64_vpopcntb<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = constructor_x64_vpopcntb_a(ctx, arg0);
    // Rule at src/isa/x64/inst.isle line 2661.
    return v1;
}

// Generated as internal constructor for term x64_vpmullq.
pub fn constructor_x64_vpmullq<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = constructor_x64_vpmullq_c(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2667.
    return v2;
}

// Generated as internal constructor for term x64_vpermi2b.
pub fn constructor_x64_vpermi2b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: Xmm,
    arg2: &XmmMem,
) -> Xmm {
    let v3 = constructor_x64_vpermi2b_a(ctx, arg0, arg1, arg2);
    // Rule at src/isa/x64/inst.isle line 2673.
    return v3;
}

// Generated as internal constructor for term x64_psllw.
pub fn constructor_x64_psllw<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemImm,
) -> Xmm {
    let v2 = &C::is_xmm_mem(ctx, arg1);
    if let Some(v3) = v2 {
        let v4 = constructor_x64_psllw_a_or_avx(ctx, arg0, v3);
        // Rule at src/isa/x64/inst.isle line 2677.
        return v4;
    }
    let v5 = C::is_imm8_xmm(ctx, arg1);
    if let Some(v6) = v5 {
        let v7 = constructor_x64_psllw_b_or_avx(ctx, arg0, v6);
        // Rule at src/isa/x64/inst.isle line 2678.
        return v7;
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_psllw", "src/isa/x64/inst.isle line 2676")
}

// Generated as internal constructor for term x64_pslld.
pub fn constructor_x64_pslld<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemImm,
) -> Xmm {
    let v2 = &C::is_xmm_mem(ctx, arg1);
    if let Some(v3) = v2 {
        let v4 = constructor_x64_pslld_a_or_avx(ctx, arg0, v3);
        // Rule at src/isa/x64/inst.isle line 2681.
        return v4;
    }
    let v5 = C::is_imm8_xmm(ctx, arg1);
    if let Some(v6) = v5 {
        let v7 = constructor_x64_pslld_b_or_avx(ctx, arg0, v6);
        // Rule at src/isa/x64/inst.isle line 2682.
        return v7;
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_pslld", "src/isa/x64/inst.isle line 2680")
}

// Generated as internal constructor for term x64_psllq.
pub fn constructor_x64_psllq<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemImm,
) -> Xmm {
    let v2 = &C::is_xmm_mem(ctx, arg1);
    if let Some(v3) = v2 {
        let v4 = constructor_x64_psllq_a_or_avx(ctx, arg0, v3);
        // Rule at src/isa/x64/inst.isle line 2685.
        return v4;
    }
    let v5 = C::is_imm8_xmm(ctx, arg1);
    if let Some(v6) = v5 {
        let v7 = constructor_x64_psllq_b_or_avx(ctx, arg0, v6);
        // Rule at src/isa/x64/inst.isle line 2686.
        return v7;
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_psllq", "src/isa/x64/inst.isle line 2684")
}

// Generated as internal constructor for term x64_psrlw.
pub fn constructor_x64_psrlw<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemImm,
) -> Xmm {
    let v2 = &C::is_xmm_mem(ctx, arg1);
    if let Some(v3) = v2 {
        let v4 = constructor_x64_psrlw_a_or_avx(ctx, arg0, v3);
        // Rule at src/isa/x64/inst.isle line 2689.
        return v4;
    }
    let v5 = C::is_imm8_xmm(ctx, arg1);
    if let Some(v6) = v5 {
        let v7 = constructor_x64_psrlw_b_or_avx(ctx, arg0, v6);
        // Rule at src/isa/x64/inst.isle line 2690.
        return v7;
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_psrlw", "src/isa/x64/inst.isle line 2688")
}

// Generated as internal constructor for term x64_psrld.
pub fn constructor_x64_psrld<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemImm,
) -> Xmm {
    let v2 = &C::is_xmm_mem(ctx, arg1);
    if let Some(v3) = v2 {
        let v4 = constructor_x64_psrld_a_or_avx(ctx, arg0, v3);
        // Rule at src/isa/x64/inst.isle line 2693.
        return v4;
    }
    let v5 = C::is_imm8_xmm(ctx, arg1);
    if let Some(v6) = v5 {
        let v7 = constructor_x64_psrld_b_or_avx(ctx, arg0, v6);
        // Rule at src/isa/x64/inst.isle line 2694.
        return v7;
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_psrld", "src/isa/x64/inst.isle line 2692")
}

// Generated as internal constructor for term x64_psrlq.
pub fn constructor_x64_psrlq<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemImm,
) -> Xmm {
    let v2 = &C::is_xmm_mem(ctx, arg1);
    if let Some(v3) = v2 {
        let v4 = constructor_x64_psrlq_a_or_avx(ctx, arg0, v3);
        // Rule at src/isa/x64/inst.isle line 2697.
        return v4;
    }
    let v5 = C::is_imm8_xmm(ctx, arg1);
    if let Some(v6) = v5 {
        let v7 = constructor_x64_psrlq_b_or_avx(ctx, arg0, v6);
        // Rule at src/isa/x64/inst.isle line 2698.
        return v7;
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_psrlq", "src/isa/x64/inst.isle line 2696")
}

// Generated as internal constructor for term x64_psraw.
pub fn constructor_x64_psraw<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemImm,
) -> Xmm {
    let v2 = &C::is_xmm_mem(ctx, arg1);
    if let Some(v3) = v2 {
        let v4 = constructor_x64_psraw_a_or_avx(ctx, arg0, v3);
        // Rule at src/isa/x64/inst.isle line 2701.
        return v4;
    }
    let v5 = C::is_imm8_xmm(ctx, arg1);
    if let Some(v6) = v5 {
        let v7 = constructor_x64_psraw_b_or_avx(ctx, arg0, v6);
        // Rule at src/isa/x64/inst.isle line 2702.
        return v7;
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_psraw", "src/isa/x64/inst.isle line 2700")
}

// Generated as internal constructor for term x64_psrad.
pub fn constructor_x64_psrad<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemImm,
) -> Xmm {
    let v2 = &C::is_xmm_mem(ctx, arg1);
    if let Some(v3) = v2 {
        let v4 = constructor_x64_psrad_a_or_avx(ctx, arg0, v3);
        // Rule at src/isa/x64/inst.isle line 2705.
        return v4;
    }
    let v5 = C::is_imm8_xmm(ctx, arg1);
    if let Some(v6) = v5 {
        let v7 = constructor_x64_psrad_b_or_avx(ctx, arg0, v6);
        // Rule at src/isa/x64/inst.isle line 2706.
        return v7;
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_psrad", "src/isa/x64/inst.isle line 2704")
}

// Generated as internal constructor for term x64_vpsraq.
pub fn constructor_x64_vpsraq<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = constructor_x64_vpsraq_g(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2710.
    return v2;
}

// Generated as internal constructor for term x64_vpsraq_imm.
pub fn constructor_x64_vpsraq_imm<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
    arg1: u8,
) -> Xmm {
    let v2 = constructor_x64_vpsraq_f(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2714.
    return v2;
}

// Generated as internal constructor for term x64_pextrb.
pub fn constructor_x64_pextrb<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: u8,
) -> Gpr {
    let v2 = constructor_x64_pextrb_a_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2718.
    return v2;
}

// Generated as internal constructor for term x64_pextrb_store.
pub fn constructor_x64_pextrb_store<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Xmm,
    arg2: u8,
) -> SideEffectNoResult {
    let v3 = &constructor_x64_pextrb_a_mem_or_avx(ctx, arg0, arg1, arg2);
    // Rule at src/isa/x64/inst.isle line 2721.
    return v3.clone();
}

// Generated as internal constructor for term x64_pextrw.
pub fn constructor_x64_pextrw<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: u8,
) -> Gpr {
    let v2 = constructor_x64_pextrw_a_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2724.
    return v2;
}

// Generated as internal constructor for term x64_pextrw_store.
pub fn constructor_x64_pextrw_store<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Xmm,
    arg2: u8,
) -> SideEffectNoResult {
    let v3 = &constructor_x64_pextrw_b_mem_or_avx(ctx, arg0, arg1, arg2);
    // Rule at src/isa/x64/inst.isle line 2727.
    return v3.clone();
}

// Generated as internal constructor for term x64_pextrd.
pub fn constructor_x64_pextrd<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: u8,
) -> Gpr {
    let v2 = constructor_x64_pextrd_a_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2730.
    return v2;
}

// Generated as internal constructor for term x64_pextrd_store.
pub fn constructor_x64_pextrd_store<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Xmm,
    arg2: u8,
) -> SideEffectNoResult {
    let v3 = &constructor_x64_pextrd_a_mem_or_avx(ctx, arg0, arg1, arg2);
    // Rule at src/isa/x64/inst.isle line 2733.
    return v3.clone();
}

// Generated as internal constructor for term x64_pextrq.
pub fn constructor_x64_pextrq<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: u8,
) -> Gpr {
    let v2 = constructor_x64_pextrq_a_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2736.
    return v2;
}

// Generated as internal constructor for term x64_pextrq_store.
pub fn constructor_x64_pextrq_store<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Xmm,
    arg2: u8,
) -> SideEffectNoResult {
    let v3 = &constructor_x64_pextrq_a_mem_or_avx(ctx, arg0, arg1, arg2);
    // Rule at src/isa/x64/inst.isle line 2739.
    return v3.clone();
}

// Generated as internal constructor for term x64_pmovmskb.
pub fn constructor_x64_pmovmskb<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
) -> Gpr {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vpmovmskb_rm(ctx, arg0);
        // Rule at src/isa/x64/inst.isle line 2744.
        return v3;
    }
    let v1 = constructor_x64_pmovmskb_rm(ctx, arg0);
    // Rule at src/isa/x64/inst.isle line 2743.
    return v1;
}

// Generated as internal constructor for term x64_movmskps.
pub fn constructor_x64_movmskps<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
) -> Gpr {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vmovmskps_rm(ctx, arg0);
        // Rule at src/isa/x64/inst.isle line 2751.
        return v3;
    }
    let v1 = constructor_x64_movmskps_rm(ctx, arg0);
    // Rule at src/isa/x64/inst.isle line 2750.
    return v1;
}

// Generated as internal constructor for term x64_movmskpd.
pub fn constructor_x64_movmskpd<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
) -> Gpr {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vmovmskpd_rm(ctx, arg0);
        // Rule at src/isa/x64/inst.isle line 2758.
        return v3;
    }
    let v1 = constructor_x64_movmskpd_rm(ctx, arg0);
    // Rule at src/isa/x64/inst.isle line 2757.
    return v1;
}

// Generated as internal constructor for term x64_not.
pub fn constructor_x64_not<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Gpr,
) -> Gpr {
    match arg0 {
        I8 => {
            let v2 = constructor_x64_notb_m(ctx, arg1);
            // Rule at src/isa/x64/inst.isle line 2764.
            return v2;
        }
        I16 => {
            let v3 = constructor_x64_notw_m(ctx, arg1);
            // Rule at src/isa/x64/inst.isle line 2765.
            return v3;
        }
        I32 => {
            let v4 = constructor_x64_notl_m(ctx, arg1);
            // Rule at src/isa/x64/inst.isle line 2766.
            return v4;
        }
        I64 => {
            let v5 = constructor_x64_notq_m(ctx, arg1);
            // Rule at src/isa/x64/inst.isle line 2767.
            return v5;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_not", "src/isa/x64/inst.isle line 2763")
}

// Generated as internal constructor for term x64_neg_raw.
pub fn constructor_x64_neg_raw<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Gpr,
) -> AssemblerOutputs {
    match arg0 {
        I8 => {
            let v2 = &C::gpr_to_gpr_mem(ctx, arg1);
            let v3 = &C::x64_negb_m_raw(ctx, v2);
            // Rule at src/isa/x64/inst.isle line 2771.
            return v3.clone();
        }
        I16 => {
            let v2 = &C::gpr_to_gpr_mem(ctx, arg1);
            let v4 = &C::x64_negw_m_raw(ctx, v2);
            // Rule at src/isa/x64/inst.isle line 2772.
            return v4.clone();
        }
        I32 => {
            let v2 = &C::gpr_to_gpr_mem(ctx, arg1);
            let v5 = &C::x64_negl_m_raw(ctx, v2);
            // Rule at src/isa/x64/inst.isle line 2773.
            return v5.clone();
        }
        I64 => {
            let v2 = &C::gpr_to_gpr_mem(ctx, arg1);
            let v6 = &C::x64_negq_m_raw(ctx, v2);
            // Rule at src/isa/x64/inst.isle line 2774.
            return v6.clone();
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_neg_raw", "src/isa/x64/inst.isle line 2770")
}

// Generated as internal constructor for term x64_neg.
pub fn constructor_x64_neg<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Gpr,
) -> Gpr {
    let v2 = &constructor_x64_neg_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at src/isa/x64/inst.isle line 2777.
    return v3;
}

// Generated as internal constructor for term x64_neg_paired.
pub fn constructor_x64_neg_paired<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Gpr,
) -> ProducesFlags {
    let v2 = &constructor_x64_neg_raw(ctx, arg0, arg1);
    let v3 = &constructor_asm_produce_flags(ctx, v2);
    // Rule at src/isa/x64/inst.isle line 2781.
    return v3.clone();
}

// Generated as internal constructor for term x64_lea.
pub fn constructor_x64_lea<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: &SyntheticAmode,
) -> Gpr {
    match arg0 {
        I16 => {
            let v2 = constructor_x64_leaw_rm(ctx, arg1);
            // Rule at src/isa/x64/inst.isle line 2788.
            return v2;
        }
        I32 => {
            let v3 = constructor_x64_leal_rm(ctx, arg1);
            // Rule at src/isa/x64/inst.isle line 2789.
            return v3;
        }
        I64 => {
            let v4 = constructor_x64_leaq_rm(ctx, arg1);
            // Rule at src/isa/x64/inst.isle line 2790.
            return v4;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_lea", "src/isa/x64/inst.isle line 2787")
}

// Generated as internal constructor for term x64_lzcnt.
pub fn constructor_x64_lzcnt<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: &GprMem,
) -> Gpr {
    match arg0 {
        I16 => {
            let v2 = constructor_x64_lzcntw_rm(ctx, arg1);
            // Rule at src/isa/x64/inst.isle line 2794.
            return v2;
        }
        I32 => {
            let v3 = constructor_x64_lzcntl_rm(ctx, arg1);
            // Rule at src/isa/x64/inst.isle line 2795.
            return v3;
        }
        I64 => {
            let v4 = constructor_x64_lzcntq_rm(ctx, arg1);
            // Rule at src/isa/x64/inst.isle line 2796.
            return v4;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_lzcnt", "src/isa/x64/inst.isle line 2793")
}

// Generated as internal constructor for term x64_tzcnt.
pub fn constructor_x64_tzcnt<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: &GprMem,
) -> Gpr {
    match arg0 {
        I16 => {
            let v2 = constructor_x64_tzcntw_a(ctx, arg1);
            // Rule at src/isa/x64/inst.isle line 2800.
            return v2;
        }
        I32 => {
            let v3 = constructor_x64_tzcntl_a(ctx, arg1);
            // Rule at src/isa/x64/inst.isle line 2801.
            return v3;
        }
        I64 => {
            let v4 = constructor_x64_tzcntq_a(ctx, arg1);
            // Rule at src/isa/x64/inst.isle line 2802.
            return v4;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_tzcnt", "src/isa/x64/inst.isle line 2799")
}

// Generated as internal constructor for term x64_bsr.
pub fn constructor_x64_bsr<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: &GprMem,
) -> ProducesFlags {
    match arg0 {
        I16 => {
            let v2 = &C::x64_bsrw_rm_raw(ctx, arg1);
            let v3 = &constructor_asm_produce_flags(ctx, v2);
            // Rule at src/isa/x64/inst.isle line 2806.
            return v3.clone();
        }
        I32 => {
            let v4 = &C::x64_bsrl_rm_raw(ctx, arg1);
            let v5 = &constructor_asm_produce_flags(ctx, v4);
            // Rule at src/isa/x64/inst.isle line 2807.
            return v5.clone();
        }
        I64 => {
            let v6 = &C::x64_bsrq_rm_raw(ctx, arg1);
            let v7 = &constructor_asm_produce_flags(ctx, v6);
            // Rule at src/isa/x64/inst.isle line 2808.
            return v7.clone();
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_bsr", "src/isa/x64/inst.isle line 2805")
}

// Generated as internal constructor for term bsr_or_else.
pub fn constructor_bsr_or_else<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Gpr,
    arg2: Gpr,
) -> Gpr {
    let v3 = &C::gpr_to_gpr_mem(ctx, arg1);
    let v4 = &constructor_x64_bsr(ctx, arg0, v3);
    let v5 = constructor_produces_flags_get_reg(ctx, v4);
    let v6 = C::gpr_new(ctx, v5);
    let v8 = &C::gpr_to_gpr_mem(ctx, arg2);
    let v9 = &constructor_cmove(ctx, arg0, &CC::Z, v8, v6);
    let v10 = &constructor_produces_flags_ignore(ctx, v4);
    let v11 = constructor_with_flags_reg(ctx, v10, v9);
    let v12 = C::gpr_new(ctx, v11);
    // Rule at src/isa/x64/inst.isle line 2813.
    return v12;
}

// Generated as internal constructor for term x64_bsf.
pub fn constructor_x64_bsf<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: &GprMem,
) -> ProducesFlags {
    match arg0 {
        I16 => {
            let v2 = &C::x64_bsfw_rm_raw(ctx, arg1);
            let v3 = &constructor_asm_produce_flags(ctx, v2);
            // Rule at src/isa/x64/inst.isle line 2824.
            return v3.clone();
        }
        I32 => {
            let v4 = &C::x64_bsfl_rm_raw(ctx, arg1);
            let v5 = &constructor_asm_produce_flags(ctx, v4);
            // Rule at src/isa/x64/inst.isle line 2825.
            return v5.clone();
        }
        I64 => {
            let v6 = &C::x64_bsfq_rm_raw(ctx, arg1);
            let v7 = &constructor_asm_produce_flags(ctx, v6);
            // Rule at src/isa/x64/inst.isle line 2826.
            return v7.clone();
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_bsf", "src/isa/x64/inst.isle line 2823")
}

// Generated as internal constructor for term bsf_or_else.
pub fn constructor_bsf_or_else<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Gpr,
    arg2: Gpr,
) -> Gpr {
    let v3 = &C::gpr_to_gpr_mem(ctx, arg1);
    let v4 = &constructor_x64_bsf(ctx, arg0, v3);
    let v5 = constructor_produces_flags_get_reg(ctx, v4);
    let v6 = C::gpr_new(ctx, v5);
    let v8 = &C::gpr_to_gpr_mem(ctx, arg2);
    let v9 = &constructor_cmove(ctx, arg0, &CC::Z, v8, v6);
    let v10 = &constructor_produces_flags_ignore(ctx, v4);
    let v11 = constructor_with_flags_reg(ctx, v10, v9);
    let v12 = C::gpr_new(ctx, v11);
    // Rule at src/isa/x64/inst.isle line 2831.
    return v12;
}

// Generated as internal constructor for term x64_blsi.
pub fn constructor_x64_blsi<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: &GprMem,
) -> Gpr {
    match arg0 {
        I32 => {
            let v2 = constructor_x64_blsil_vm(ctx, arg1);
            // Rule at src/isa/x64/inst.isle line 2842.
            return v2;
        }
        I64 => {
            let v3 = constructor_x64_blsiq_vm(ctx, arg1);
            // Rule at src/isa/x64/inst.isle line 2843.
            return v3;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_blsi", "src/isa/x64/inst.isle line 2841")
}

// Generated as internal constructor for term x64_blsmsk.
pub fn constructor_x64_blsmsk<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: &GprMem,
) -> Gpr {
    match arg0 {
        I32 => {
            let v2 = constructor_x64_blsmskl_vm(ctx, arg1);
            // Rule at src/isa/x64/inst.isle line 2847.
            return v2;
        }
        I64 => {
            let v3 = constructor_x64_blsmskq_vm(ctx, arg1);
            // Rule at src/isa/x64/inst.isle line 2848.
            return v3;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_blsmsk", "src/isa/x64/inst.isle line 2846")
}

// Generated as internal constructor for term x64_blsr.
pub fn constructor_x64_blsr<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: &GprMem,
) -> Gpr {
    match arg0 {
        I32 => {
            let v2 = constructor_x64_blsrl_vm(ctx, arg1);
            // Rule at src/isa/x64/inst.isle line 2852.
            return v2;
        }
        I64 => {
            let v3 = constructor_x64_blsrq_vm(ctx, arg1);
            // Rule at src/isa/x64/inst.isle line 2853.
            return v3;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_blsr", "src/isa/x64/inst.isle line 2851")
}

// Generated as internal constructor for term x64_bt.
pub fn constructor_x64_bt<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: &GprMem,
    arg2: Gpr,
) -> ProducesFlags {
    match arg0 {
        I16 => {
            let v3 = &constructor_x64_btw_mr(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 2857.
            return v3.clone();
        }
        I32 => {
            let v4 = &constructor_x64_btl_mr(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 2858.
            return v4.clone();
        }
        I64 => {
            let v5 = &constructor_x64_btq_mr(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 2859.
            return v5.clone();
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_bt", "src/isa/x64/inst.isle line 2856")
}

// Generated as internal constructor for term x64_bt_imm.
pub fn constructor_x64_bt_imm<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: &GprMem,
    arg2: u8,
) -> ProducesFlags {
    match arg0 {
        I16 => {
            let v3 = &constructor_x64_btw_mi(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 2863.
            return v3.clone();
        }
        I32 => {
            let v4 = &constructor_x64_btl_mi(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 2864.
            return v4.clone();
        }
        I64 => {
            let v5 = &constructor_x64_btq_mi(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 2865.
            return v5.clone();
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_bt_imm", "src/isa/x64/inst.isle line 2862")
}

// Generated as internal constructor for term x64_sarx.
pub fn constructor_x64_sarx<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: &GprMem,
    arg2: Gpr,
) -> Gpr {
    match arg0 {
        I32 => {
            let v3 = constructor_x64_sarxl_rmv(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 2869.
            return v3;
        }
        I64 => {
            let v4 = constructor_x64_sarxq_rmv(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 2870.
            return v4;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_sarx", "src/isa/x64/inst.isle line 2868")
}

// Generated as internal constructor for term x64_shrx.
pub fn constructor_x64_shrx<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: &GprMem,
    arg2: Gpr,
) -> Gpr {
    match arg0 {
        I32 => {
            let v3 = constructor_x64_shrxl_rmv(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 2874.
            return v3;
        }
        I64 => {
            let v4 = constructor_x64_shrxq_rmv(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 2875.
            return v4;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_shrx", "src/isa/x64/inst.isle line 2873")
}

// Generated as internal constructor for term x64_shlx.
pub fn constructor_x64_shlx<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: &GprMem,
    arg2: Gpr,
) -> Gpr {
    match arg0 {
        I32 => {
            let v3 = constructor_x64_shlxl_rmv(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 2879.
            return v3;
        }
        I64 => {
            let v4 = constructor_x64_shlxq_rmv(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 2880.
            return v4;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_shlx", "src/isa/x64/inst.isle line 2878")
}

// Generated as internal constructor for term x64_rorx.
pub fn constructor_x64_rorx<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: &GprMem,
    arg2: u8,
) -> Gpr {
    match arg0 {
        I32 => {
            let v3 = constructor_x64_rorxl_rmi(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 2884.
            return v3;
        }
        I64 => {
            let v4 = constructor_x64_rorxq_rmi(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 2885.
            return v4;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_rorx", "src/isa/x64/inst.isle line 2883")
}

// Generated as internal constructor for term x64_popcnt.
pub fn constructor_x64_popcnt<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: &GprMem,
) -> Gpr {
    match arg0 {
        I16 => {
            let v2 = constructor_x64_popcntw_rm(ctx, arg1);
            // Rule at src/isa/x64/inst.isle line 2889.
            return v2;
        }
        I32 => {
            let v3 = constructor_x64_popcntl_rm(ctx, arg1);
            // Rule at src/isa/x64/inst.isle line 2890.
            return v3;
        }
        I64 => {
            let v4 = constructor_x64_popcntq_rm(ctx, arg1);
            // Rule at src/isa/x64/inst.isle line 2891.
            return v4;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_popcnt", "src/isa/x64/inst.isle line 2888")
}

// Generated as internal constructor for term x64_minss.
pub fn constructor_x64_minss<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = constructor_x64_minss_a_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2895.
    return v2;
}

// Generated as internal constructor for term x64_minsd.
pub fn constructor_x64_minsd<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = constructor_x64_minsd_a_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2898.
    return v2;
}

// Generated as internal constructor for term x64_minps.
pub fn constructor_x64_minps<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = constructor_x64_minps_a_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2901.
    return v2;
}

// Generated as internal constructor for term x64_minpd.
pub fn constructor_x64_minpd<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = constructor_x64_minpd_a_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2904.
    return v2;
}

// Generated as internal constructor for term x64_maxss.
pub fn constructor_x64_maxss<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = constructor_x64_maxss_a_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2907.
    return v2;
}

// Generated as internal constructor for term x64_maxsd.
pub fn constructor_x64_maxsd<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = constructor_x64_maxsd_a_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2910.
    return v2;
}

// Generated as internal constructor for term x64_maxps.
pub fn constructor_x64_maxps<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = constructor_x64_maxps_a_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2913.
    return v2;
}

// Generated as internal constructor for term x64_maxpd.
pub fn constructor_x64_maxpd<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = constructor_x64_maxpd_a_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2916.
    return v2;
}

// Generated as internal constructor for term x64_vfmadd213.
pub fn constructor_x64_vfmadd213<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Xmm,
    arg2: Xmm,
    arg3: &XmmMem,
) -> Xmm {
    match arg0 {
        F32 => {
            let v4 = constructor_x64_vfmadd213ss_a(ctx, arg1, arg2, arg3);
            // Rule at src/isa/x64/inst.isle line 2920.
            return v4;
        }
        F64 => {
            let v5 = constructor_x64_vfmadd213sd_a(ctx, arg1, arg2, arg3);
            // Rule at src/isa/x64/inst.isle line 2921.
            return v5;
        }
        F32X4 => {
            let v6 = constructor_x64_vfmadd213ps_a(ctx, arg1, arg2, arg3);
            // Rule at src/isa/x64/inst.isle line 2922.
            return v6;
        }
        F64X2 => {
            let v7 = constructor_x64_vfmadd213pd_a(ctx, arg1, arg2, arg3);
            // Rule at src/isa/x64/inst.isle line 2923.
            return v7;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_vfmadd213", "src/isa/x64/inst.isle line 2919")
}

// Generated as internal constructor for term x64_vfmadd132.
pub fn constructor_x64_vfmadd132<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Xmm,
    arg2: Xmm,
    arg3: &XmmMem,
) -> Xmm {
    match arg0 {
        F32 => {
            let v4 = constructor_x64_vfmadd132ss_a(ctx, arg1, arg2, arg3);
            // Rule at src/isa/x64/inst.isle line 2927.
            return v4;
        }
        F64 => {
            let v5 = constructor_x64_vfmadd132sd_a(ctx, arg1, arg2, arg3);
            // Rule at src/isa/x64/inst.isle line 2928.
            return v5;
        }
        F32X4 => {
            let v6 = constructor_x64_vfmadd132ps_a(ctx, arg1, arg2, arg3);
            // Rule at src/isa/x64/inst.isle line 2929.
            return v6;
        }
        F64X2 => {
            let v7 = constructor_x64_vfmadd132pd_a(ctx, arg1, arg2, arg3);
            // Rule at src/isa/x64/inst.isle line 2930.
            return v7;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_vfmadd132", "src/isa/x64/inst.isle line 2926")
}

// Generated as internal constructor for term x64_vfnmadd213.
pub fn constructor_x64_vfnmadd213<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Xmm,
    arg2: Xmm,
    arg3: &XmmMem,
) -> Xmm {
    match arg0 {
        F32 => {
            let v4 = constructor_x64_vfnmadd213ss_a(ctx, arg1, arg2, arg3);
            // Rule at src/isa/x64/inst.isle line 2934.
            return v4;
        }
        F64 => {
            let v5 = constructor_x64_vfnmadd213sd_a(ctx, arg1, arg2, arg3);
            // Rule at src/isa/x64/inst.isle line 2935.
            return v5;
        }
        F32X4 => {
            let v6 = constructor_x64_vfnmadd213ps_a(ctx, arg1, arg2, arg3);
            // Rule at src/isa/x64/inst.isle line 2936.
            return v6;
        }
        F64X2 => {
            let v7 = constructor_x64_vfnmadd213pd_a(ctx, arg1, arg2, arg3);
            // Rule at src/isa/x64/inst.isle line 2937.
            return v7;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_vfnmadd213", "src/isa/x64/inst.isle line 2933")
}

// Generated as internal constructor for term x64_vfnmadd132.
pub fn constructor_x64_vfnmadd132<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Xmm,
    arg2: Xmm,
    arg3: &XmmMem,
) -> Xmm {
    match arg0 {
        F32 => {
            let v4 = constructor_x64_vfnmadd132ss_a(ctx, arg1, arg2, arg3);
            // Rule at src/isa/x64/inst.isle line 2941.
            return v4;
        }
        F64 => {
            let v5 = constructor_x64_vfnmadd132sd_a(ctx, arg1, arg2, arg3);
            // Rule at src/isa/x64/inst.isle line 2942.
            return v5;
        }
        F32X4 => {
            let v6 = constructor_x64_vfnmadd132ps_a(ctx, arg1, arg2, arg3);
            // Rule at src/isa/x64/inst.isle line 2943.
            return v6;
        }
        F64X2 => {
            let v7 = constructor_x64_vfnmadd132pd_a(ctx, arg1, arg2, arg3);
            // Rule at src/isa/x64/inst.isle line 2944.
            return v7;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_vfnmadd132", "src/isa/x64/inst.isle line 2940")
}

// Generated as internal constructor for term x64_vfmsub213.
pub fn constructor_x64_vfmsub213<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Xmm,
    arg2: Xmm,
    arg3: &XmmMem,
) -> Xmm {
    match arg0 {
        F32 => {
            let v4 = constructor_x64_vfmsub213ss_a(ctx, arg1, arg2, arg3);
            // Rule at src/isa/x64/inst.isle line 2948.
            return v4;
        }
        F64 => {
            let v5 = constructor_x64_vfmsub213sd_a(ctx, arg1, arg2, arg3);
            // Rule at src/isa/x64/inst.isle line 2949.
            return v5;
        }
        F32X4 => {
            let v6 = constructor_x64_vfmsub213ps_a(ctx, arg1, arg2, arg3);
            // Rule at src/isa/x64/inst.isle line 2950.
            return v6;
        }
        F64X2 => {
            let v7 = constructor_x64_vfmsub213pd_a(ctx, arg1, arg2, arg3);
            // Rule at src/isa/x64/inst.isle line 2951.
            return v7;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_vfmsub213", "src/isa/x64/inst.isle line 2947")
}

// Generated as internal constructor for term x64_vfmsub132.
pub fn constructor_x64_vfmsub132<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Xmm,
    arg2: Xmm,
    arg3: &XmmMem,
) -> Xmm {
    match arg0 {
        F32 => {
            let v4 = constructor_x64_vfmsub132ss_a(ctx, arg1, arg2, arg3);
            // Rule at src/isa/x64/inst.isle line 2955.
            return v4;
        }
        F64 => {
            let v5 = constructor_x64_vfmsub132sd_a(ctx, arg1, arg2, arg3);
            // Rule at src/isa/x64/inst.isle line 2956.
            return v5;
        }
        F32X4 => {
            let v6 = constructor_x64_vfmsub132ps_a(ctx, arg1, arg2, arg3);
            // Rule at src/isa/x64/inst.isle line 2957.
            return v6;
        }
        F64X2 => {
            let v7 = constructor_x64_vfmsub132pd_a(ctx, arg1, arg2, arg3);
            // Rule at src/isa/x64/inst.isle line 2958.
            return v7;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_vfmsub132", "src/isa/x64/inst.isle line 2954")
}

// Generated as internal constructor for term x64_vfnmsub213.
pub fn constructor_x64_vfnmsub213<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Xmm,
    arg2: Xmm,
    arg3: &XmmMem,
) -> Xmm {
    match arg0 {
        F32 => {
            let v4 = constructor_x64_vfnmsub213ss_a(ctx, arg1, arg2, arg3);
            // Rule at src/isa/x64/inst.isle line 2962.
            return v4;
        }
        F64 => {
            let v5 = constructor_x64_vfnmsub213sd_a(ctx, arg1, arg2, arg3);
            // Rule at src/isa/x64/inst.isle line 2963.
            return v5;
        }
        F32X4 => {
            let v6 = constructor_x64_vfnmsub213ps_a(ctx, arg1, arg2, arg3);
            // Rule at src/isa/x64/inst.isle line 2964.
            return v6;
        }
        F64X2 => {
            let v7 = constructor_x64_vfnmsub213pd_a(ctx, arg1, arg2, arg3);
            // Rule at src/isa/x64/inst.isle line 2965.
            return v7;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_vfnmsub213", "src/isa/x64/inst.isle line 2961")
}

// Generated as internal constructor for term x64_vfnmsub132.
pub fn constructor_x64_vfnmsub132<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Xmm,
    arg2: Xmm,
    arg3: &XmmMem,
) -> Xmm {
    match arg0 {
        F32 => {
            let v4 = constructor_x64_vfnmsub132ss_a(ctx, arg1, arg2, arg3);
            // Rule at src/isa/x64/inst.isle line 2969.
            return v4;
        }
        F64 => {
            let v5 = constructor_x64_vfnmsub132sd_a(ctx, arg1, arg2, arg3);
            // Rule at src/isa/x64/inst.isle line 2970.
            return v5;
        }
        F32X4 => {
            let v6 = constructor_x64_vfnmsub132ps_a(ctx, arg1, arg2, arg3);
            // Rule at src/isa/x64/inst.isle line 2971.
            return v6;
        }
        F64X2 => {
            let v7 = constructor_x64_vfnmsub132pd_a(ctx, arg1, arg2, arg3);
            // Rule at src/isa/x64/inst.isle line 2972.
            return v7;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_vfnmsub132", "src/isa/x64/inst.isle line 2968")
}

// Generated as internal constructor for term x64_sqrtss.
pub fn constructor_x64_sqrtss<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = constructor_x64_sqrtss_a_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2987.
    return v2;
}

// Generated as internal constructor for term x64_sqrtsd.
pub fn constructor_x64_sqrtsd<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = constructor_x64_sqrtsd_a_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2993.
    return v2;
}

// Generated as internal constructor for term x64_sqrtps.
pub fn constructor_x64_sqrtps<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = constructor_x64_sqrtps_a_or_avx(ctx, arg0);
    // Rule at src/isa/x64/inst.isle line 2997.
    return v1;
}

// Generated as internal constructor for term x64_sqrtpd.
pub fn constructor_x64_sqrtpd<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = constructor_x64_sqrtpd_a_or_avx(ctx, arg0);
    // Rule at src/isa/x64/inst.isle line 3001.
    return v1;
}

// Generated as internal constructor for term x64_rcpps.
pub fn constructor_x64_rcpps<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = constructor_x64_rcpps_rm_or_avx(ctx, arg0);
    // Rule at src/isa/x64/inst.isle line 3007.
    return v1;
}

// Generated as internal constructor for term x64_rcpss.
pub fn constructor_x64_rcpss<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = constructor_x64_rcpss_rm(ctx, arg0);
    // Rule at src/isa/x64/inst.isle line 3011.
    return v1;
}

// Generated as internal constructor for term x64_vrcpss.
pub fn constructor_x64_vrcpss<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = constructor_x64_vrcpss_rvm(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 3015.
    return v2;
}

// Generated as internal constructor for term x64_rsqrtps.
pub fn constructor_x64_rsqrtps<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = constructor_x64_rsqrtps_rm_or_avx(ctx, arg0);
    // Rule at src/isa/x64/inst.isle line 3019.
    return v1;
}

// Generated as internal constructor for term x64_rsqrtss.
pub fn constructor_x64_rsqrtss<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = constructor_x64_rsqrtss_rm(ctx, arg0);
    // Rule at src/isa/x64/inst.isle line 3023.
    return v1;
}

// Generated as internal constructor for term x64_vrsqrtss.
pub fn constructor_x64_vrsqrtss<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = constructor_x64_vrsqrtss_rvm(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 3027.
    return v2;
}

// Generated as internal constructor for term x64_cvtss2sd.
pub fn constructor_x64_cvtss2sd<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vcvtss2sd_b(ctx, arg0, arg1);
        // Rule at src/isa/x64/inst.isle line 3034.
        return v3;
    }
    let v4 = constructor_x64_cvtss2sd_a(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 3037.
    return v4;
}

// Generated as internal constructor for term x64_cvtsd2ss.
pub fn constructor_x64_cvtsd2ss<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vcvtsd2ss_b(ctx, arg0, arg1);
        // Rule at src/isa/x64/inst.isle line 3043.
        return v3;
    }
    let v4 = constructor_x64_cvtsd2ss_a(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 3046.
    return v4;
}

// Generated as internal constructor for term x64_cvtdq2ps.
pub fn constructor_x64_cvtdq2ps<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = C::has_avx(ctx);
    if v1 == true {
        let v2 = constructor_x64_vcvtdq2ps_a(ctx, arg0);
        // Rule at src/isa/x64/inst.isle line 3050.
        return v2;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg0);
    let v4 = constructor_x64_cvtdq2ps_a(ctx, v3);
    // Rule at src/isa/x64/inst.isle line 3053.
    return v4;
}

// Generated as internal constructor for term x64_cvtps2pd.
pub fn constructor_x64_cvtps2pd<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = C::has_avx(ctx);
    if v1 == true {
        let v2 = constructor_x64_vcvtps2pd_a(ctx, arg0);
        // Rule at src/isa/x64/inst.isle line 3057.
        return v2;
    }
    let v3 = constructor_x64_cvtps2pd_a(ctx, arg0);
    // Rule at src/isa/x64/inst.isle line 3060.
    return v3;
}

// Generated as internal constructor for term x64_cvtpd2ps.
pub fn constructor_x64_cvtpd2ps<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = C::has_avx(ctx);
    if v1 == true {
        let v2 = constructor_x64_vcvtpd2ps_a(ctx, arg0);
        // Rule at src/isa/x64/inst.isle line 3064.
        return v2;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg0);
    let v4 = constructor_x64_cvtpd2ps_a(ctx, v3);
    // Rule at src/isa/x64/inst.isle line 3067.
    return v4;
}

// Generated as internal constructor for term x64_cvtdq2pd.
pub fn constructor_x64_cvtdq2pd<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = C::has_avx(ctx);
    if v1 == true {
        let v2 = constructor_x64_vcvtdq2pd_a(ctx, arg0);
        // Rule at src/isa/x64/inst.isle line 3071.
        return v2;
    }
    let v3 = constructor_x64_cvtdq2pd_a(ctx, arg0);
    // Rule at src/isa/x64/inst.isle line 3074.
    return v3;
}

// Generated as internal constructor for term x64_cvtsi2ss.
pub fn constructor_x64_cvtsi2ss<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Xmm,
    arg2: &GprMem,
) -> Xmm {
    match arg0 {
        I32 => {
            let v3 = C::has_avx(ctx);
            if v3 == true {
                let v4 = constructor_x64_vcvtsi2ssl_b(ctx, arg1, arg2);
                // Rule at src/isa/x64/inst.isle line 3078.
                return v4;
            }
            let v6 = constructor_x64_cvtsi2ssl_a(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 3084.
            return v6;
        }
        I64 => {
            let v3 = C::has_avx(ctx);
            if v3 == true {
                let v5 = constructor_x64_vcvtsi2ssq_b(ctx, arg1, arg2);
                // Rule at src/isa/x64/inst.isle line 3081.
                return v5;
            }
            let v7 = constructor_x64_cvtsi2ssq_a(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 3085.
            return v7;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_cvtsi2ss", "src/isa/x64/inst.isle line 3077")
}

// Generated as internal constructor for term x64_cvtsi2sd.
pub fn constructor_x64_cvtsi2sd<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Xmm,
    arg2: &GprMem,
) -> Xmm {
    match arg0 {
        I32 => {
            let v3 = C::has_avx(ctx);
            if v3 == true {
                let v4 = constructor_x64_vcvtsi2sdl_b(ctx, arg1, arg2);
                // Rule at src/isa/x64/inst.isle line 3089.
                return v4;
            }
            let v6 = constructor_x64_cvtsi2sdl_a(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 3095.
            return v6;
        }
        I64 => {
            let v3 = C::has_avx(ctx);
            if v3 == true {
                let v5 = constructor_x64_vcvtsi2sdq_b(ctx, arg1, arg2);
                // Rule at src/isa/x64/inst.isle line 3092.
                return v5;
            }
            let v7 = constructor_x64_cvtsi2sdq_a(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 3096.
            return v7;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_cvtsi2sd", "src/isa/x64/inst.isle line 3088")
}

// Generated as internal constructor for term x64_cvttps2dq.
pub fn constructor_x64_cvttps2dq<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = C::has_avx(ctx);
    if v1 == true {
        let v2 = constructor_x64_vcvttps2dq_a(ctx, arg0);
        // Rule at src/isa/x64/inst.isle line 3100.
        return v2;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg0);
    let v4 = constructor_x64_cvttps2dq_a(ctx, v3);
    // Rule at src/isa/x64/inst.isle line 3103.
    return v4;
}

// Generated as internal constructor for term x64_cvttpd2dq.
pub fn constructor_x64_cvttpd2dq<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = C::has_avx(ctx);
    if v1 == true {
        let v2 = constructor_x64_vcvttpd2dq_a(ctx, arg0);
        // Rule at src/isa/x64/inst.isle line 3107.
        return v2;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg0);
    let v4 = constructor_x64_cvttpd2dq_a(ctx, v3);
    // Rule at src/isa/x64/inst.isle line 3110.
    return v4;
}

// Generated as internal constructor for term x64_pcmpeq.
pub fn constructor_x64_pcmpeq<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Xmm,
    arg2: &XmmMem,
) -> Xmm {
    match arg0 {
        I8X16 => {
            let v3 = constructor_x64_pcmpeqb(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 3114.
            return v3;
        }
        I16X8 => {
            let v4 = constructor_x64_pcmpeqw(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 3115.
            return v4;
        }
        I32X4 => {
            let v5 = constructor_x64_pcmpeqd(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 3116.
            return v5;
        }
        I64X2 => {
            let v6 = C::has_sse41(ctx);
            if v6 == true {
                let v7 = constructor_x64_pcmpeqq(ctx, arg1, arg2);
                // Rule at src/isa/x64/inst.isle line 3117.
                return v7;
            }
            let v5 = constructor_x64_pcmpeqd(ctx, arg1, arg2);
            let v8 = &C::xmm_to_xmm_mem(ctx, v5);
            let v10 = constructor_x64_pshufd(ctx, v8, 0xb1_u8);
            let v11 = &C::xmm_to_xmm_mem(ctx, v10);
            let v12 = constructor_x64_pand(ctx, v5, v11);
            // Rule at src/isa/x64/inst.isle line 3126.
            return v12;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_pcmpeq", "src/isa/x64/inst.isle line 3113")
}

// Generated as internal constructor for term x64_pcmpeqb.
pub fn constructor_x64_pcmpeqb<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = constructor_x64_pcmpeqb_a_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 3133.
    return v2;
}

// Generated as internal constructor for term x64_pcmpeqw.
pub fn constructor_x64_pcmpeqw<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = constructor_x64_pcmpeqw_a_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 3136.
    return v2;
}

// Generated as internal constructor for term x64_pcmpeqd.
pub fn constructor_x64_pcmpeqd<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = constructor_x64_pcmpeqd_a_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 3139.
    return v2;
}

// Generated as internal constructor for term x64_pcmpeqq.
pub fn constructor_x64_pcmpeqq<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = constructor_x64_pcmpeqq_a_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 3142.
    return v2;
}

// Generated as internal constructor for term x64_pcmpgt.
pub fn constructor_x64_pcmpgt<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Xmm,
    arg2: &XmmMem,
) -> Xmm {
    match arg0 {
        I8X16 => {
            let v3 = constructor_x64_pcmpgtb_a_or_avx(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 3146.
            return v3;
        }
        I16X8 => {
            let v4 = constructor_x64_pcmpgtw_a_or_avx(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 3147.
            return v4;
        }
        I32X4 => {
            let v5 = constructor_x64_pcmpgtd_a_or_avx(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 3148.
            return v5;
        }
        I64X2 => {
            let v6 = C::has_avx(ctx);
            if v6 == true {
                let v7 = constructor_x64_vpcmpgtq_b(ctx, arg1, arg2);
                // Rule at src/isa/x64/inst.isle line 3152.
                return v7;
            }
            let v8 = C::use_sse42(ctx);
            if v8 == true {
                let v9 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg2);
                let v10 = constructor_x64_pcmpgtq_a(ctx, arg1, v9);
                // Rule at src/isa/x64/inst.isle line 3157.
                return v10;
            }
            let v12 = C::emit_u128_le_const(ctx, 0x800000000000000080000000_u128);
            let v13 = &constructor_const_to_xmm_mem(ctx, v12);
            let v14 = constructor_x64_movdqu_load(ctx, v13);
            let v15 = &C::xmm_to_xmm_mem(ctx, arg1);
            let v16 = constructor_x64_pxor(ctx, v14, v15);
            let v17 = constructor_x64_pxor(ctx, v14, arg2);
            let v18 = &constructor_xmm_to_xmm_mem_aligned(ctx, v17);
            let v19 = constructor_x64_pcmpgtd_a(ctx, v16, v18);
            let v20 = &C::xmm_to_xmm_mem(ctx, v19);
            let v22 = constructor_x64_pshufd(ctx, v20, 0xa0_u8);
            let v23 = &C::xmm_to_xmm_mem(ctx, v19);
            let v25 = constructor_x64_pshufd(ctx, v23, 0xf5_u8);
            let v26 = &C::xmm_to_xmm_mem(ctx, v17);
            let v27 = constructor_x64_pcmpeqd(ctx, v16, v26);
            let v28 = &C::xmm_to_xmm_mem(ctx, v27);
            let v29 = constructor_x64_pshufd(ctx, v28, 0xf5_u8);
            let v30 = &C::xmm_to_xmm_mem(ctx, v29);
            let v31 = constructor_x64_pand(ctx, v22, v30);
            let v32 = &C::xmm_to_xmm_mem(ctx, v25);
            let v33 = constructor_x64_por(ctx, v31, v32);
            // Rule at src/isa/x64/inst.isle line 3186.
            return v33;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_pcmpgt", "src/isa/x64/inst.isle line 3145")
}

// Generated as internal constructor for term x64_add_mem.
pub fn constructor_x64_add_mem<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: &SyntheticAmode,
    arg2: Value,
) -> SideEffectNoResult {
    match arg0 {
        I8 => {
            let v8 = C::def_inst(ctx, arg2);
            if let Some(v9) = v8 {
                let v10 = &C::inst_data_value(ctx, v9);
                if let &InstructionData::UnaryImm {
                    opcode: ref v11,
                    imm: v12,
                } = v10 {
                    if let &Opcode::Iconst = v11 {
                        let v13 = C::u64_from_imm64(ctx, v12);
                        let v14 = C::u64_from_u8(ctx, v13);
                        if let Some(v15) = v14 {
                            let v16 = &constructor_x64_addb_mi_mem(ctx, arg1, v15);
                            // Rule at src/isa/x64/inst.isle line 3219.
                            return v16.clone();
                        }
                    }
                }
            }
            let v3 = constructor_put_in_gpr(ctx, arg2);
            let v4 = &constructor_x64_addb_mr_mem(ctx, arg1, v3);
            // Rule at src/isa/x64/inst.isle line 3213.
            return v4.clone();
        }
        I16 => {
            let v8 = C::def_inst(ctx, arg2);
            if let Some(v9) = v8 {
                let v10 = &C::inst_data_value(ctx, v9);
                if let &InstructionData::UnaryImm {
                    opcode: ref v11,
                    imm: v12,
                } = v10 {
                    if let &Opcode::Iconst = v11 {
                        let v13 = C::u64_from_imm64(ctx, v12);
                        let v17 = C::u64_from_u16(ctx, v13);
                        if let Some(v18) = v17 {
                            let v19 = &constructor_x64_addw_mi_mem(ctx, arg1, v18);
                            // Rule at src/isa/x64/inst.isle line 3220.
                            return v19.clone();
                        }
                    }
                }
            }
            let v3 = constructor_put_in_gpr(ctx, arg2);
            let v5 = &constructor_x64_addw_mr_mem(ctx, arg1, v3);
            // Rule at src/isa/x64/inst.isle line 3214.
            return v5.clone();
        }
        I32 => {
            let v23 = C::i64_from_iconst(ctx, arg2);
            if let Some(v24) = v23 {
                let v28 = C::i64_from_i8(ctx, v24);
                if let Some(v29) = v28 {
                    let v30 = &constructor_x64_addl_mi_sxb_mem(ctx, arg1, v29);
                    // Rule at src/isa/x64/inst.isle line 3223.
                    return v30.clone();
                }
            }
            let v8 = C::def_inst(ctx, arg2);
            if let Some(v9) = v8 {
                let v10 = &C::inst_data_value(ctx, v9);
                if let &InstructionData::UnaryImm {
                    opcode: ref v11,
                    imm: v12,
                } = v10 {
                    if let &Opcode::Iconst = v11 {
                        let v13 = C::u64_from_imm64(ctx, v12);
                        let v20 = C::u64_from_u32(ctx, v13);
                        if let Some(v21) = v20 {
                            let v22 = &constructor_x64_addl_mi_mem(ctx, arg1, v21);
                            // Rule at src/isa/x64/inst.isle line 3221.
                            return v22.clone();
                        }
                    }
                }
            }
            let v3 = constructor_put_in_gpr(ctx, arg2);
            let v6 = &constructor_x64_addl_mr_mem(ctx, arg1, v3);
            // Rule at src/isa/x64/inst.isle line 3215.
            return v6.clone();
        }
        I64 => {
            let v23 = C::i64_from_iconst(ctx, arg2);
            if let Some(v24) = v23 {
                let v28 = C::i64_from_i8(ctx, v24);
                if let Some(v29) = v28 {
                    let v31 = &constructor_x64_addq_mi_sxb_mem(ctx, arg1, v29);
                    // Rule at src/isa/x64/inst.isle line 3224.
                    return v31.clone();
                }
                let v25 = C::i64_from_i32(ctx, v24);
                if let Some(v26) = v25 {
                    let v27 = &constructor_x64_addq_mi_sxl_mem(ctx, arg1, v26);
                    // Rule at src/isa/x64/inst.isle line 3222.
                    return v27.clone();
                }
            }
            let v3 = constructor_put_in_gpr(ctx, arg2);
            let v7 = &constructor_x64_addq_mr_mem(ctx, arg1, v3);
            // Rule at src/isa/x64/inst.isle line 3216.
            return v7.clone();
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_add_mem", "src/isa/x64/inst.isle line 3200")
}

// Generated as internal constructor for term x64_sub_mem.
pub fn constructor_x64_sub_mem<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: &SyntheticAmode,
    arg2: Value,
) -> SideEffectNoResult {
    match arg0 {
        I8 => {
            let v8 = C::def_inst(ctx, arg2);
            if let Some(v9) = v8 {
                let v10 = &C::inst_data_value(ctx, v9);
                if let &InstructionData::UnaryImm {
                    opcode: ref v11,
                    imm: v12,
                } = v10 {
                    if let &Opcode::Iconst = v11 {
                        let v13 = C::u64_from_imm64(ctx, v12);
                        let v14 = C::u64_from_u8(ctx, v13);
                        if let Some(v15) = v14 {
                            let v16 = &constructor_x64_subb_mi_mem(ctx, arg1, v15);
                            // Rule at src/isa/x64/inst.isle line 3235.
                            return v16.clone();
                        }
                    }
                }
            }
            let v3 = constructor_put_in_gpr(ctx, arg2);
            let v4 = &constructor_x64_subb_mr_mem(ctx, arg1, v3);
            // Rule at src/isa/x64/inst.isle line 3229.
            return v4.clone();
        }
        I16 => {
            let v8 = C::def_inst(ctx, arg2);
            if let Some(v9) = v8 {
                let v10 = &C::inst_data_value(ctx, v9);
                if let &InstructionData::UnaryImm {
                    opcode: ref v11,
                    imm: v12,
                } = v10 {
                    if let &Opcode::Iconst = v11 {
                        let v13 = C::u64_from_imm64(ctx, v12);
                        let v17 = C::u64_from_u16(ctx, v13);
                        if let Some(v18) = v17 {
                            let v19 = &constructor_x64_subw_mi_mem(ctx, arg1, v18);
                            // Rule at src/isa/x64/inst.isle line 3236.
                            return v19.clone();
                        }
                    }
                }
            }
            let v3 = constructor_put_in_gpr(ctx, arg2);
            let v5 = &constructor_x64_subw_mr_mem(ctx, arg1, v3);
            // Rule at src/isa/x64/inst.isle line 3230.
            return v5.clone();
        }
        I32 => {
            let v23 = C::i64_from_iconst(ctx, arg2);
            if let Some(v24) = v23 {
                let v28 = C::i64_from_i8(ctx, v24);
                if let Some(v29) = v28 {
                    let v30 = &constructor_x64_subl_mi_sxb_mem(ctx, arg1, v29);
                    // Rule at src/isa/x64/inst.isle line 3239.
                    return v30.clone();
                }
            }
            let v8 = C::def_inst(ctx, arg2);
            if let Some(v9) = v8 {
                let v10 = &C::inst_data_value(ctx, v9);
                if let &InstructionData::UnaryImm {
                    opcode: ref v11,
                    imm: v12,
                } = v10 {
                    if let &Opcode::Iconst = v11 {
                        let v13 = C::u64_from_imm64(ctx, v12);
                        let v20 = C::u64_from_u32(ctx, v13);
                        if let Some(v21) = v20 {
                            let v22 = &constructor_x64_subl_mi_mem(ctx, arg1, v21);
                            // Rule at src/isa/x64/inst.isle line 3237.
                            return v22.clone();
                        }
                    }
                }
            }
            let v3 = constructor_put_in_gpr(ctx, arg2);
            let v6 = &constructor_x64_subl_mr_mem(ctx, arg1, v3);
            // Rule at src/isa/x64/inst.isle line 3231.
            return v6.clone();
        }
        I64 => {
            let v23 = C::i64_from_iconst(ctx, arg2);
            if let Some(v24) = v23 {
                let v28 = C::i64_from_i8(ctx, v24);
                if let Some(v29) = v28 {
                    let v31 = &constructor_x64_subq_mi_sxb_mem(ctx, arg1, v29);
                    // Rule at src/isa/x64/inst.isle line 3240.
                    return v31.clone();
                }
                let v25 = C::i64_from_i32(ctx, v24);
                if let Some(v26) = v25 {
                    let v27 = &constructor_x64_subq_mi_sxl_mem(ctx, arg1, v26);
                    // Rule at src/isa/x64/inst.isle line 3238.
                    return v27.clone();
                }
            }
            let v3 = constructor_put_in_gpr(ctx, arg2);
            let v7 = &constructor_x64_subq_mr_mem(ctx, arg1, v3);
            // Rule at src/isa/x64/inst.isle line 3232.
            return v7.clone();
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_sub_mem", "src/isa/x64/inst.isle line 3226")
}

// Generated as internal constructor for term x64_and_mem.
pub fn constructor_x64_and_mem<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: &SyntheticAmode,
    arg2: Value,
) -> SideEffectNoResult {
    match arg0 {
        I8 => {
            let v8 = C::def_inst(ctx, arg2);
            if let Some(v9) = v8 {
                let v10 = &C::inst_data_value(ctx, v9);
                if let &InstructionData::UnaryImm {
                    opcode: ref v11,
                    imm: v12,
                } = v10 {
                    if let &Opcode::Iconst = v11 {
                        let v13 = C::u64_from_imm64(ctx, v12);
                        let v14 = C::u64_from_u8(ctx, v13);
                        if let Some(v15) = v14 {
                            let v16 = &constructor_x64_andb_mi_mem(ctx, arg1, v15);
                            // Rule at src/isa/x64/inst.isle line 3253.
                            return v16.clone();
                        }
                    }
                }
            }
            let v3 = constructor_put_in_gpr(ctx, arg2);
            let v4 = &constructor_x64_andb_mr_mem(ctx, arg1, v3);
            // Rule at src/isa/x64/inst.isle line 3245.
            return v4.clone();
        }
        I16 => {
            let v8 = C::def_inst(ctx, arg2);
            if let Some(v9) = v8 {
                let v10 = &C::inst_data_value(ctx, v9);
                if let &InstructionData::UnaryImm {
                    opcode: ref v11,
                    imm: v12,
                } = v10 {
                    if let &Opcode::Iconst = v11 {
                        let v13 = C::u64_from_imm64(ctx, v12);
                        let v17 = C::u64_from_u16(ctx, v13);
                        if let Some(v18) = v17 {
                            let v19 = &constructor_x64_andw_mi_mem(ctx, arg1, v18);
                            // Rule at src/isa/x64/inst.isle line 3254.
                            return v19.clone();
                        }
                    }
                }
            }
            let v3 = constructor_put_in_gpr(ctx, arg2);
            let v5 = &constructor_x64_andw_mr_mem(ctx, arg1, v3);
            // Rule at src/isa/x64/inst.isle line 3246.
            return v5.clone();
        }
        I32 => {
            let v23 = C::i64_from_iconst(ctx, arg2);
            if let Some(v24) = v23 {
                let v28 = C::i64_from_i8(ctx, v24);
                if let Some(v29) = v28 {
                    let v30 = &constructor_x64_andl_mi_sxb_mem(ctx, arg1, v29);
                    // Rule at src/isa/x64/inst.isle line 3257.
                    return v30.clone();
                }
            }
            let v8 = C::def_inst(ctx, arg2);
            if let Some(v9) = v8 {
                let v10 = &C::inst_data_value(ctx, v9);
                if let &InstructionData::UnaryImm {
                    opcode: ref v11,
                    imm: v12,
                } = v10 {
                    if let &Opcode::Iconst = v11 {
                        let v13 = C::u64_from_imm64(ctx, v12);
                        let v20 = C::u64_from_u32(ctx, v13);
                        if let Some(v21) = v20 {
                            let v22 = &constructor_x64_andl_mi_mem(ctx, arg1, v21);
                            // Rule at src/isa/x64/inst.isle line 3255.
                            return v22.clone();
                        }
                    }
                }
            }
            let v3 = constructor_put_in_gpr(ctx, arg2);
            let v6 = &constructor_x64_andl_mr_mem(ctx, arg1, v3);
            // Rule at src/isa/x64/inst.isle line 3247.
            return v6.clone();
        }
        I64 => {
            let v23 = C::i64_from_iconst(ctx, arg2);
            if let Some(v24) = v23 {
                let v28 = C::i64_from_i8(ctx, v24);
                if let Some(v29) = v28 {
                    let v31 = &constructor_x64_andq_mi_sxb_mem(ctx, arg1, v29);
                    // Rule at src/isa/x64/inst.isle line 3258.
                    return v31.clone();
                }
                let v25 = C::i64_from_i32(ctx, v24);
                if let Some(v26) = v25 {
                    let v27 = &constructor_x64_andq_mi_sxl_mem(ctx, arg1, v26);
                    // Rule at src/isa/x64/inst.isle line 3256.
                    return v27.clone();
                }
            }
            let v3 = constructor_put_in_gpr(ctx, arg2);
            let v7 = &constructor_x64_andq_mr_mem(ctx, arg1, v3);
            // Rule at src/isa/x64/inst.isle line 3249.
            return v7.clone();
        }
        F32 => {
            let v3 = constructor_put_in_gpr(ctx, arg2);
            let v6 = &constructor_x64_andl_mr_mem(ctx, arg1, v3);
            // Rule at src/isa/x64/inst.isle line 3248.
            return v6.clone();
        }
        F64 => {
            let v3 = constructor_put_in_gpr(ctx, arg2);
            let v7 = &constructor_x64_andq_mr_mem(ctx, arg1, v3);
            // Rule at src/isa/x64/inst.isle line 3250.
            return v7.clone();
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_and_mem", "src/isa/x64/inst.isle line 3242")
}

// Generated as internal constructor for term x64_or_mem.
pub fn constructor_x64_or_mem<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: &SyntheticAmode,
    arg2: Value,
) -> SideEffectNoResult {
    match arg0 {
        I8 => {
            let v8 = C::def_inst(ctx, arg2);
            if let Some(v9) = v8 {
                let v10 = &C::inst_data_value(ctx, v9);
                if let &InstructionData::UnaryImm {
                    opcode: ref v11,
                    imm: v12,
                } = v10 {
                    if let &Opcode::Iconst = v11 {
                        let v13 = C::u64_from_imm64(ctx, v12);
                        let v14 = C::u64_from_u8(ctx, v13);
                        if let Some(v15) = v14 {
                            let v16 = &constructor_x64_orb_mi_mem(ctx, arg1, v15);
                            // Rule at src/isa/x64/inst.isle line 3271.
                            return v16.clone();
                        }
                    }
                }
            }
            let v3 = constructor_put_in_gpr(ctx, arg2);
            let v4 = &constructor_x64_orb_mr_mem(ctx, arg1, v3);
            // Rule at src/isa/x64/inst.isle line 3263.
            return v4.clone();
        }
        I16 => {
            let v8 = C::def_inst(ctx, arg2);
            if let Some(v9) = v8 {
                let v10 = &C::inst_data_value(ctx, v9);
                if let &InstructionData::UnaryImm {
                    opcode: ref v11,
                    imm: v12,
                } = v10 {
                    if let &Opcode::Iconst = v11 {
                        let v13 = C::u64_from_imm64(ctx, v12);
                        let v17 = C::u64_from_u16(ctx, v13);
                        if let Some(v18) = v17 {
                            let v19 = &constructor_x64_orw_mi_mem(ctx, arg1, v18);
                            // Rule at src/isa/x64/inst.isle line 3272.
                            return v19.clone();
                        }
                    }
                }
            }
            let v3 = constructor_put_in_gpr(ctx, arg2);
            let v5 = &constructor_x64_orw_mr_mem(ctx, arg1, v3);
            // Rule at src/isa/x64/inst.isle line 3264.
            return v5.clone();
        }
        I32 => {
            let v23 = C::i64_from_iconst(ctx, arg2);
            if let Some(v24) = v23 {
                let v28 = C::i64_from_i8(ctx, v24);
                if let Some(v29) = v28 {
                    let v30 = &constructor_x64_orl_mi_sxb_mem(ctx, arg1, v29);
                    // Rule at src/isa/x64/inst.isle line 3275.
                    return v30.clone();
                }
            }
            let v8 = C::def_inst(ctx, arg2);
            if let Some(v9) = v8 {
                let v10 = &C::inst_data_value(ctx, v9);
                if let &InstructionData::UnaryImm {
                    opcode: ref v11,
                    imm: v12,
                } = v10 {
                    if let &Opcode::Iconst = v11 {
                        let v13 = C::u64_from_imm64(ctx, v12);
                        let v20 = C::u64_from_u32(ctx, v13);
                        if let Some(v21) = v20 {
                            let v22 = &constructor_x64_orl_mi_mem(ctx, arg1, v21);
                            // Rule at src/isa/x64/inst.isle line 3273.
                            return v22.clone();
                        }
                    }
                }
            }
            let v3 = constructor_put_in_gpr(ctx, arg2);
            let v6 = &constructor_x64_orl_mr_mem(ctx, arg1, v3);
            // Rule at src/isa/x64/inst.isle line 3265.
            return v6.clone();
        }
        I64 => {
            let v23 = C::i64_from_iconst(ctx, arg2);
            if let Some(v24) = v23 {
                let v28 = C::i64_from_i8(ctx, v24);
                if let Some(v29) = v28 {
                    let v31 = &constructor_x64_orq_mi_sxb_mem(ctx, arg1, v29);
                    // Rule at src/isa/x64/inst.isle line 3276.
                    return v31.clone();
                }
                let v25 = C::i64_from_i32(ctx, v24);
                if let Some(v26) = v25 {
                    let v27 = &constructor_x64_orq_mi_sxl_mem(ctx, arg1, v26);
                    // Rule at src/isa/x64/inst.isle line 3274.
                    return v27.clone();
                }
            }
            let v3 = constructor_put_in_gpr(ctx, arg2);
            let v7 = &constructor_x64_orq_mr_mem(ctx, arg1, v3);
            // Rule at src/isa/x64/inst.isle line 3267.
            return v7.clone();
        }
        F32 => {
            let v3 = constructor_put_in_gpr(ctx, arg2);
            let v6 = &constructor_x64_orl_mr_mem(ctx, arg1, v3);
            // Rule at src/isa/x64/inst.isle line 3266.
            return v6.clone();
        }
        F64 => {
            let v3 = constructor_put_in_gpr(ctx, arg2);
            let v7 = &constructor_x64_orq_mr_mem(ctx, arg1, v3);
            // Rule at src/isa/x64/inst.isle line 3268.
            return v7.clone();
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_or_mem", "src/isa/x64/inst.isle line 3260")
}

// Generated as internal constructor for term x64_xor_mem.
pub fn constructor_x64_xor_mem<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: &SyntheticAmode,
    arg2: Value,
) -> SideEffectNoResult {
    match arg0 {
        I8 => {
            let v8 = C::def_inst(ctx, arg2);
            if let Some(v9) = v8 {
                let v10 = &C::inst_data_value(ctx, v9);
                if let &InstructionData::UnaryImm {
                    opcode: ref v11,
                    imm: v12,
                } = v10 {
                    if let &Opcode::Iconst = v11 {
                        let v13 = C::u64_from_imm64(ctx, v12);
                        let v14 = C::u64_from_u8(ctx, v13);
                        if let Some(v15) = v14 {
                            let v16 = &constructor_x64_xorb_mi_mem(ctx, arg1, v15);
                            // Rule at src/isa/x64/inst.isle line 3289.
                            return v16.clone();
                        }
                    }
                }
            }
            let v3 = constructor_put_in_gpr(ctx, arg2);
            let v4 = &constructor_x64_xorb_mr_mem(ctx, arg1, v3);
            // Rule at src/isa/x64/inst.isle line 3281.
            return v4.clone();
        }
        I16 => {
            let v8 = C::def_inst(ctx, arg2);
            if let Some(v9) = v8 {
                let v10 = &C::inst_data_value(ctx, v9);
                if let &InstructionData::UnaryImm {
                    opcode: ref v11,
                    imm: v12,
                } = v10 {
                    if let &Opcode::Iconst = v11 {
                        let v13 = C::u64_from_imm64(ctx, v12);
                        let v17 = C::u64_from_u16(ctx, v13);
                        if let Some(v18) = v17 {
                            let v19 = &constructor_x64_xorw_mi_mem(ctx, arg1, v18);
                            // Rule at src/isa/x64/inst.isle line 3290.
                            return v19.clone();
                        }
                    }
                }
            }
            let v3 = constructor_put_in_gpr(ctx, arg2);
            let v5 = &constructor_x64_xorw_mr_mem(ctx, arg1, v3);
            // Rule at src/isa/x64/inst.isle line 3282.
            return v5.clone();
        }
        I32 => {
            let v23 = C::i64_from_iconst(ctx, arg2);
            if let Some(v24) = v23 {
                let v28 = C::i64_from_i8(ctx, v24);
                if let Some(v29) = v28 {
                    let v30 = &constructor_x64_xorl_mi_sxb_mem(ctx, arg1, v29);
                    // Rule at src/isa/x64/inst.isle line 3293.
                    return v30.clone();
                }
            }
            let v8 = C::def_inst(ctx, arg2);
            if let Some(v9) = v8 {
                let v10 = &C::inst_data_value(ctx, v9);
                if let &InstructionData::UnaryImm {
                    opcode: ref v11,
                    imm: v12,
                } = v10 {
                    if let &Opcode::Iconst = v11 {
                        let v13 = C::u64_from_imm64(ctx, v12);
                        let v20 = C::u64_from_u32(ctx, v13);
                        if let Some(v21) = v20 {
                            let v22 = &constructor_x64_xorl_mi_mem(ctx, arg1, v21);
                            // Rule at src/isa/x64/inst.isle line 3291.
                            return v22.clone();
                        }
                    }
                }
            }
            let v3 = constructor_put_in_gpr(ctx, arg2);
            let v6 = &constructor_x64_xorl_mr_mem(ctx, arg1, v3);
            // Rule at src/isa/x64/inst.isle line 3283.
            return v6.clone();
        }
        I64 => {
            let v23 = C::i64_from_iconst(ctx, arg2);
            if let Some(v24) = v23 {
                let v28 = C::i64_from_i8(ctx, v24);
                if let Some(v29) = v28 {
                    let v31 = &constructor_x64_xorq_mi_sxb_mem(ctx, arg1, v29);
                    // Rule at src/isa/x64/inst.isle line 3294.
                    return v31.clone();
                }
                let v25 = C::i64_from_i32(ctx, v24);
                if let Some(v26) = v25 {
                    let v27 = &constructor_x64_xorq_mi_sxl_mem(ctx, arg1, v26);
                    // Rule at src/isa/x64/inst.isle line 3292.
                    return v27.clone();
                }
            }
            let v3 = constructor_put_in_gpr(ctx, arg2);
            let v7 = &constructor_x64_xorq_mr_mem(ctx, arg1, v3);
            // Rule at src/isa/x64/inst.isle line 3285.
            return v7.clone();
        }
        F32 => {
            let v3 = constructor_put_in_gpr(ctx, arg2);
            let v6 = &constructor_x64_xorl_mr_mem(ctx, arg1, v3);
            // Rule at src/isa/x64/inst.isle line 3284.
            return v6.clone();
        }
        F64 => {
            let v3 = constructor_put_in_gpr(ctx, arg2);
            let v7 = &constructor_x64_xorq_mr_mem(ctx, arg1, v3);
            // Rule at src/isa/x64/inst.isle line 3286.
            return v7.clone();
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_xor_mem", "src/isa/x64/inst.isle line 3278")
}

// Generated as internal constructor for term trap_if.
pub fn constructor_trap_if<C: Context>(
    ctx: &mut C,
    arg0: &CC,
    arg1: &TrapCode,
) -> ConsumesFlags {
    let v2 = MInst::TrapIf {
        cc: arg0.clone(),
        trap_code: arg1.clone(),
    };
    let v3 = ConsumesFlags::ConsumesFlagsSideEffect {
        inst: v2,
    };
    // Rule at src/isa/x64/inst.isle line 3298.
    return v3;
}

// Generated as internal constructor for term trap_if_and.
pub fn constructor_trap_if_and<C: Context>(
    ctx: &mut C,
    arg0: &CC,
    arg1: &CC,
    arg2: &TrapCode,
) -> ConsumesFlags {
    let v3 = MInst::TrapIfAnd {
        cc1: arg0.clone(),
        cc2: arg1.clone(),
        trap_code: arg2.clone(),
    };
    let v4 = ConsumesFlags::ConsumesFlagsSideEffect {
        inst: v3,
    };
    // Rule at src/isa/x64/inst.isle line 3303.
    return v4;
}

// Generated as internal constructor for term trap_if_or.
pub fn constructor_trap_if_or<C: Context>(
    ctx: &mut C,
    arg0: &CC,
    arg1: &CC,
    arg2: &TrapCode,
) -> ConsumesFlags {
    let v3 = MInst::TrapIfOr {
        cc1: arg0.clone(),
        cc2: arg1.clone(),
        trap_code: arg2.clone(),
    };
    let v4 = ConsumesFlags::ConsumesFlagsSideEffect {
        inst: v3,
    };
    // Rule at src/isa/x64/inst.isle line 3308.
    return v4;
}

// Generated as internal constructor for term x64_movddup.
pub fn constructor_x64_movddup<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vmovddup_a(ctx, arg0);
        // Rule at src/isa/x64/inst.isle line 3314.
        return v3;
    }
    let v1 = constructor_x64_movddup_a(ctx, arg0);
    // Rule at src/isa/x64/inst.isle line 3313.
    return v1;
}

// Generated as internal constructor for term x64_vpbroadcastb.
pub fn constructor_x64_vpbroadcastb<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = constructor_x64_vpbroadcastb_a(ctx, arg0);
    // Rule at src/isa/x64/inst.isle line 3320.
    return v1;
}

// Generated as internal constructor for term x64_vpbroadcastw.
pub fn constructor_x64_vpbroadcastw<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = constructor_x64_vpbroadcastw_a(ctx, arg0);
    // Rule at src/isa/x64/inst.isle line 3323.
    return v1;
}

// Generated as internal constructor for term x64_vpbroadcastd.
pub fn constructor_x64_vpbroadcastd<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = constructor_x64_vpbroadcastd_a(ctx, arg0);
    // Rule at src/isa/x64/inst.isle line 3326.
    return v1;
}

// Generated as internal constructor for term x64_vbroadcastss.
pub fn constructor_x64_vbroadcastss<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = C::is_xmm(ctx, arg0);
    if let Some(v2) = v1 {
        let v3 = constructor_x64_vbroadcastss_a_r(ctx, v2);
        // Rule at src/isa/x64/inst.isle line 3329.
        return v3;
    }
    let v4 = &C::is_mem(ctx, arg0);
    if let Some(v5) = v4 {
        let v6 = constructor_x64_vbroadcastss_a_m(ctx, v5);
        // Rule at src/isa/x64/inst.isle line 3330.
        return v6;
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_vbroadcastss", "src/isa/x64/inst.isle line 3328")
}

// Generated as internal constructor for term jmp_known.
pub fn constructor_jmp_known<C: Context>(
    ctx: &mut C,
    arg0: MachLabel,
) -> SideEffectNoResult {
    let v1 = MInst::JmpKnown {
        dst: arg0,
    };
    let v2 = SideEffectNoResult::Inst {
        inst: v1,
    };
    // Rule at src/isa/x64/inst.isle line 3336.
    return v2;
}

// Generated as internal constructor for term jmp_cond.
pub fn constructor_jmp_cond<C: Context>(
    ctx: &mut C,
    arg0: &CC,
    arg1: MachLabel,
    arg2: MachLabel,
) -> ConsumesFlags {
    let v3 = MInst::JmpCond {
        cc: arg0.clone(),
        taken: arg1,
        not_taken: arg2,
    };
    let v4 = ConsumesFlags::ConsumesFlagsSideEffect {
        inst: v3,
    };
    // Rule at src/isa/x64/inst.isle line 3341.
    return v4;
}

// Generated as internal constructor for term jmp_cond_or.
pub fn constructor_jmp_cond_or<C: Context>(
    ctx: &mut C,
    arg0: &CC,
    arg1: &CC,
    arg2: MachLabel,
    arg3: MachLabel,
) -> ConsumesFlags {
    let v4 = MInst::JmpCondOr {
        cc1: arg0.clone(),
        cc2: arg1.clone(),
        taken: arg2,
        not_taken: arg3,
    };
    let v5 = ConsumesFlags::ConsumesFlagsSideEffect {
        inst: v4,
    };
    // Rule at src/isa/x64/inst.isle line 3346.
    return v5;
}

// Generated as internal constructor for term jmp_cond_result.
pub fn constructor_jmp_cond_result<C: Context>(
    ctx: &mut C,
    arg0: &CondResult,
    arg1: MachLabel,
    arg2: MachLabel,
) -> SideEffectNoResult {
    match arg0 {
        &CondResult::CC {
            producer: ref v1,
            cc: ref v2,
        } => {
            let v5 = &constructor_jmp_cond(ctx, v2, arg1, arg2);
            let v6 = &constructor_with_flags_side_effect(ctx, v1, v5);
            // Rule at src/isa/x64/inst.isle line 3353.
            return v6.clone();
        }
        &CondResult::And {
            producer: ref v7,
            cc1: ref v8,
            cc2: ref v9,
        } => {
            let v10 = &constructor_cond_invert(ctx, arg0);
            let v11 = &constructor_jmp_cond_result(ctx, v10, arg2, arg1);
            // Rule at src/isa/x64/inst.isle line 3355.
            return v11.clone();
        }
        &CondResult::Or {
            producer: ref v12,
            cc1: ref v13,
            cc2: ref v14,
        } => {
            let v15 = &constructor_jmp_cond_or(ctx, v13, v14, arg1, arg2);
            let v16 = &constructor_with_flags_side_effect(ctx, v12, v15);
            // Rule at src/isa/x64/inst.isle line 3357.
            return v16.clone();
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "jmp_cond_result", "src/isa/x64/inst.isle line 3352")
}

// Generated as internal constructor for term jmp_table_seq.
pub fn constructor_jmp_table_seq<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Gpr,
    arg2: MachLabel,
    arg3: &BoxVecMachLabel,
) -> SideEffectNoResult {
    let v4 = C::temp_writable_gpr(ctx);
    let v5 = C::temp_writable_gpr(ctx);
    let v6 = C::gpr_to_reg(ctx, arg1);
    let v7 = C::writable_gpr_to_reg(ctx, v4);
    let v8 = C::writable_gpr_to_reg(ctx, v5);
    let v9 = MInst::JmpTableSeq {
        idx: v6,
        tmp1: v7,
        tmp2: v8,
        default_target: arg2,
        targets: arg3.clone(),
    };
    let v10 = SideEffectNoResult::Inst {
        inst: v9,
    };
    // Rule at src/isa/x64/inst.isle line 3375.
    return v10;
}

// Generated as internal constructor for term cond_invert.
pub fn constructor_cond_invert<C: Context>(
    ctx: &mut C,
    arg0: &CondResult,
) -> CondResult {
    match arg0 {
        &CondResult::CC {
            producer: ref v1,
            cc: ref v2,
        } => {
            let v3 = &C::cc_invert(ctx, v2);
            let v4 = CondResult::CC {
                producer: v1.clone(),
                cc: v3.clone(),
            };
            // Rule at src/isa/x64/inst.isle line 3418.
            return v4;
        }
        &CondResult::And {
            producer: ref v11,
            cc1: ref v12,
            cc2: ref v13,
        } => {
            let v14 = &C::cc_invert(ctx, v12);
            let v15 = &C::cc_invert(ctx, v13);
            let v16 = CondResult::Or {
                producer: v11.clone(),
                cc1: v14.clone(),
                cc2: v15.clone(),
            };
            // Rule at src/isa/x64/inst.isle line 3420.
            return v16;
        }
        &CondResult::Or {
            producer: ref v5,
            cc1: ref v6,
            cc2: ref v7,
        } => {
            let v8 = &C::cc_invert(ctx, v6);
            let v9 = &C::cc_invert(ctx, v7);
            let v10 = CondResult::And {
                producer: v5.clone(),
                cc1: v8.clone(),
                cc2: v9.clone(),
            };
            // Rule at src/isa/x64/inst.isle line 3419.
            return v10;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "cond_invert", "src/isa/x64/inst.isle line 3417")
}

// Generated as internal constructor for term is_nonzero.
pub fn constructor_is_nonzero<C: Context>(
    ctx: &mut C,
    arg0: Value,
) -> CondResult {
    let v21 = C::def_inst(ctx, arg0);
    if let Some(v22) = v21 {
        let v23 = &C::inst_data_value(ctx, v22);
        match v23 {
            &InstructionData::Binary {
                opcode: ref v35,
                args: ref v36,
            } => {
                if let &Opcode::Band = v35 {
                    let v37 = C::unpack_value_array_2(ctx, v36);
                    let v40 = C::value_type(ctx, v37.0);
                    let v41 = C::ty_int(ctx, v40);
                    if let Some(v42) = v41 {
                        let v43 = C::fits_in_64(ctx, v42);
                        if let Some(v44) = v43 {
                            let v45 = &constructor_is_nonzero_band(ctx, v44, v37.0, v37.1);
                            // Rule at src/isa/x64/inst.isle line 3448.
                            return v45.clone();
                        }
                    }
                }
            }
            &InstructionData::Unary {
                opcode: ref v24,
                arg: v25,
            } => {
                match v24 {
                    &Opcode::VanyTrue => {
                        let v27 = &constructor_is_vany_true(ctx, v25);
                        // Rule at src/isa/x64/inst.isle line 3445.
                        return v27.clone();
                    }
                    &Opcode::VallTrue => {
                        let v26 = &constructor_is_vall_true(ctx, v25);
                        // Rule at src/isa/x64/inst.isle line 3444.
                        return v26.clone();
                    }
                    &Opcode::Uextend => {
                        let v28 = C::def_inst(ctx, v25);
                        if let Some(v29) = v28 {
                            let v30 = &C::inst_data_value(ctx, v29);
                            if let &InstructionData::Unary {
                                opcode: ref v31,
                                arg: v32,
                            } = v30 {
                                match v31 {
                                    &Opcode::VanyTrue => {
                                        let v34 = &constructor_is_vany_true(ctx, v32);
                                        // Rule at src/isa/x64/inst.isle line 3447.
                                        return v34.clone();
                                    }
                                    &Opcode::VallTrue => {
                                        let v33 = &constructor_is_vall_true(ctx, v32);
                                        // Rule at src/isa/x64/inst.isle line 3446.
                                        return v33.clone();
                                    }
                                    _ => {}
                                }
                            }
                        }
                    }
                    _ => {}
                }
            }
            _ => {}
        }
    }
    let v1 = C::value_type(ctx, arg0);
    if v1 == I128 {
        let v10 = C::put_in_regs(ctx, arg0);
        let v12 = constructor_value_regs_get_gpr(ctx, v10, 0x0_usize);
        let v13 = C::put_in_regs(ctx, arg0);
        let v15 = constructor_value_regs_get_gpr(ctx, v13, 0x1_usize);
        let v18 = &C::gpr_to_gpr_mem_imm(ctx, v15);
        let v19 = &constructor_x64_produce_flags_side_effect(ctx, &ProduceFlagsSideEffectOp::Or, I64, v12, v18);
        let v20 = CondResult::CC {
            producer: v19.clone(),
            cc: CC::NZ,
        };
        // Rule at src/isa/x64/inst.isle line 3435.
        return v20;
    }
    let v2 = &C::type_register_class(ctx, v1);
    if let Some(v3) = v2 {
        if let &RegisterClass::Gpr {
            single_register: v4,
        } = v3 {
            if v4 == true {
                let v5 = constructor_put_in_gpr(ctx, arg0);
                let v6 = &C::gpr_to_gpr_mem_imm(ctx, v5);
                let v7 = &constructor_x64_test(ctx, v1, v5, v6);
                let v9 = CondResult::CC {
                    producer: v7.clone(),
                    cc: CC::NZ,
                };
                // Rule at src/isa/x64/inst.isle line 3431.
                return v9;
            }
        }
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "is_nonzero", "src/isa/x64/inst.isle line 3428")
}

// Generated as internal constructor for term is_nonzero_cmp.
pub fn constructor_is_nonzero_cmp<C: Context>(
    ctx: &mut C,
    arg0: Value,
) -> CondResult {
    let v1 = C::def_inst(ctx, arg0);
    if let Some(v2) = v1 {
        let v3 = &C::inst_data_value(ctx, v2);
        match v3 {
            &InstructionData::FloatCompare {
                opcode: ref v4,
                args: ref v5,
                cond: ref v6,
            } => {
                if let &Opcode::Fcmp = v4 {
                    let v7 = C::unpack_value_array_2(ctx, v5);
                    let v10 = &constructor_emit_fcmp(ctx, v6, v7.0, v7.1);
                    // Rule at src/isa/x64/inst.isle line 3457.
                    return v10.clone();
                }
            }
            &InstructionData::IntCompare {
                opcode: ref v11,
                args: ref v12,
                cond: ref v13,
            } => {
                if let &Opcode::Icmp = v11 {
                    let v14 = C::unpack_value_array_2(ctx, v12);
                    let v17 = &constructor_emit_cmp(ctx, v13, v14.0, v14.1);
                    // Rule at src/isa/x64/inst.isle line 3458.
                    return v17.clone();
                }
            }
            &InstructionData::Unary {
                opcode: ref v18,
                arg: v19,
            } => {
                if let &Opcode::Uextend = v18 {
                    let v20 = C::def_inst(ctx, v19);
                    if let Some(v21) = v20 {
                        let v22 = &C::inst_data_value(ctx, v21);
                        match v22 {
                            &InstructionData::FloatCompare {
                                opcode: ref v23,
                                args: ref v24,
                                cond: ref v25,
                            } => {
                                if let &Opcode::Fcmp = v23 {
                                    let v26 = C::unpack_value_array_2(ctx, v24);
                                    let v29 = &constructor_emit_fcmp(ctx, v25, v26.0, v26.1);
                                    // Rule at src/isa/x64/inst.isle line 3459.
                                    return v29.clone();
                                }
                            }
                            &InstructionData::IntCompare {
                                opcode: ref v30,
                                args: ref v31,
                                cond: ref v32,
                            } => {
                                if let &Opcode::Icmp = v30 {
                                    let v33 = C::unpack_value_array_2(ctx, v31);
                                    let v36 = &constructor_emit_cmp(ctx, v32, v33.0, v33.1);
                                    // Rule at src/isa/x64/inst.isle line 3460.
                                    return v36.clone();
                                }
                            }
                            _ => {}
                        }
                    }
                }
            }
            _ => {}
        }
    }
    let v37 = &constructor_is_nonzero(ctx, arg0);
    // Rule at src/isa/x64/inst.isle line 3461.
    return v37.clone();
}

// Generated as internal constructor for term is_nonzero_band.
pub fn constructor_is_nonzero_band<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
) -> CondResult {
    let v38 = C::i64_from_iconst(ctx, arg2);
    if let Some(v39) = v38 {
        let v40 = C::i64_from_i32(ctx, v39);
        if let Some(v41) = v40 {
            let v3 = constructor_put_in_gpr(ctx, arg1);
            let v4 = &constructor_put_in_gpr_mem_imm(ctx, arg2);
            let v5 = &constructor_x64_test(ctx, arg0, v3, v4);
            let v7 = CondResult::CC {
                producer: v5.clone(),
                cc: CC::NZ,
            };
            // Rule at src/isa/x64/inst.isle line 3487.
            return v7;
        }
    }
    let v10 = C::def_inst(ctx, arg2);
    if let Some(v11) = v10 {
        let v12 = &C::inst_data_value(ctx, v11);
        match v12 {
            &InstructionData::Binary {
                opcode: ref v13,
                args: ref v14,
            } => {
                if let &Opcode::Ishl = v13 {
                    let v8 = C::ty_32_or_64(ctx, arg0);
                    if let Some(v9) = v8 {
                        let v15 = C::unpack_value_array_2(ctx, v14);
                        let v18 = C::def_inst(ctx, v15.0);
                        if let Some(v19) = v18 {
                            let v20 = &C::inst_data_value(ctx, v19);
                            if let &InstructionData::UnaryImm {
                                opcode: ref v21,
                                imm: v22,
                            } = v20 {
                                if let &Opcode::Iconst = v21 {
                                    let v23 = C::u64_from_imm64(ctx, v22);
                                    if v23 == 0x1_u64 {
                                        let v3 = constructor_put_in_gpr(ctx, arg1);
                                        let v24 = &C::gpr_to_gpr_mem(ctx, v3);
                                        let v25 = constructor_put_in_gpr(ctx, v15.1);
                                        let v26 = &constructor_x64_bt(ctx, v9, v24, v25);
                                        let v28 = CondResult::CC {
                                            producer: v26.clone(),
                                            cc: CC::B,
                                        };
                                        // Rule at src/isa/x64/inst.isle line 3471.
                                        return v28;
                                    }
                                }
                            }
                        }
                    }
                }
            }
            &InstructionData::UnaryImm {
                opcode: ref v29,
                imm: v30,
            } => {
                if let &Opcode::Iconst = v29 {
                    if arg0 == I64 {
                        let v31 = C::u64_from_imm64(ctx, v30);
                        let v32 = C::bt_imm(ctx, v31);
                        if let Some(v33) = v32 {
                            let v35 = &constructor_put_in_gpr_mem(ctx, arg1);
                            let v36 = &constructor_x64_bt_imm(ctx, I64, v35, v33);
                            let v37 = CondResult::CC {
                                producer: v36.clone(),
                                cc: CC::B,
                            };
                            // Rule at src/isa/x64/inst.isle line 3476.
                            return v37;
                        }
                    }
                }
            }
            _ => {}
        }
    }
    let v3 = constructor_put_in_gpr(ctx, arg1);
    let v4 = &constructor_put_in_gpr_mem_imm(ctx, arg2);
    let v5 = &constructor_x64_test(ctx, arg0, v3, v4);
    let v7 = CondResult::CC {
        producer: v5.clone(),
        cc: CC::NZ,
    };
    // Rule at src/isa/x64/inst.isle line 3464.
    return v7;
}

// Generated as internal constructor for term lower_cond_bool.
pub fn constructor_lower_cond_bool<C: Context>(
    ctx: &mut C,
    arg0: &CondResult,
) -> Gpr {
    match arg0 {
        &CondResult::CC {
            producer: ref v1,
            cc: ref v2,
        } => {
            let v3 = &constructor_x64_setcc(ctx, v2);
            let v4 = constructor_with_flags(ctx, v1, v3);
            let v6 = constructor_value_regs_get_gpr(ctx, v4, 0x0_usize);
            // Rule at src/isa/x64/inst.isle line 3498.
            return v6;
        }
        &CondResult::And {
            producer: ref v7,
            cc1: ref v8,
            cc2: ref v9,
        } => {
            let v10 = &constructor_x64_setcc(ctx, v8);
            let v11 = &constructor_x64_setcc(ctx, v9);
            let v12 = &constructor_consumes_flags_concat(ctx, v10, v11);
            let v13 = constructor_with_flags(ctx, v7, v12);
            let v14 = constructor_value_regs_get_gpr(ctx, v13, 0x0_usize);
            let v16 = constructor_value_regs_get_gpr(ctx, v13, 0x1_usize);
            let v18 = &C::gpr_to_gpr_mem_imm(ctx, v16);
            let v19 = constructor_x64_and(ctx, I8, v14, v18);
            // Rule at src/isa/x64/inst.isle line 3500.
            return v19;
        }
        &CondResult::Or {
            producer: ref v20,
            cc1: ref v21,
            cc2: ref v22,
        } => {
            let v23 = &constructor_x64_setcc(ctx, v21);
            let v24 = &constructor_x64_setcc(ctx, v22);
            let v25 = &constructor_consumes_flags_concat(ctx, v23, v24);
            let v26 = constructor_with_flags(ctx, v20, v25);
            let v27 = constructor_value_regs_get_gpr(ctx, v26, 0x0_usize);
            let v28 = constructor_value_regs_get_gpr(ctx, v26, 0x1_usize);
            let v29 = &C::gpr_to_gpr_mem_imm(ctx, v28);
            let v30 = constructor_x64_or(ctx, I8, v27, v29);
            // Rule at src/isa/x64/inst.isle line 3508.
            return v30;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "lower_cond_bool", "src/isa/x64/inst.isle line 3497")
}

// Generated as internal constructor for term emit_cmp.
pub fn constructor_emit_cmp<C: Context>(
    ctx: &mut C,
    arg0: &IntCC,
    arg1: Value,
    arg2: Value,
) -> CondResult {
    match arg0 {
        &IntCC::Equal => {
            let v28 = C::def_inst(ctx, arg1);
            if let Some(v29) = v28 {
                let v30 = &C::inst_data_value(ctx, v29);
                if let &InstructionData::UnaryImm {
                    opcode: ref v31,
                    imm: v32,
                } = v30 {
                    if let &Opcode::Iconst = v31 {
                        let v33 = C::u64_from_imm64(ctx, v32);
                        if v33 == 0x0_u64 {
                            let v56 = &constructor_is_nonzero(ctx, arg2);
                            let v57 = &constructor_cond_invert(ctx, v56);
                            // Rule at src/isa/x64/inst.isle line 3551.
                            return v57.clone();
                        }
                    }
                }
            }
            let v16 = C::def_inst(ctx, arg2);
            if let Some(v17) = v16 {
                let v18 = &C::inst_data_value(ctx, v17);
                if let &InstructionData::UnaryImm {
                    opcode: ref v19,
                    imm: v20,
                } = v18 {
                    if let &Opcode::Iconst = v19 {
                        let v21 = C::u64_from_imm64(ctx, v20);
                        if v21 == 0x0_u64 {
                            let v54 = &constructor_is_nonzero(ctx, arg1);
                            let v55 = &constructor_cond_invert(ctx, v54);
                            // Rule at src/isa/x64/inst.isle line 3550.
                            return v55.clone();
                        }
                    }
                }
            }
        }
        &IntCC::NotEqual => {
            let v28 = C::def_inst(ctx, arg1);
            if let Some(v29) = v28 {
                let v30 = &C::inst_data_value(ctx, v29);
                if let &InstructionData::UnaryImm {
                    opcode: ref v31,
                    imm: v32,
                } = v30 {
                    if let &Opcode::Iconst = v31 {
                        let v33 = C::u64_from_imm64(ctx, v32);
                        if v33 == 0x0_u64 {
                            let v56 = &constructor_is_nonzero(ctx, arg2);
                            // Rule at src/isa/x64/inst.isle line 3553.
                            return v56.clone();
                        }
                    }
                }
            }
            let v16 = C::def_inst(ctx, arg2);
            if let Some(v17) = v16 {
                let v18 = &C::inst_data_value(ctx, v17);
                if let &InstructionData::UnaryImm {
                    opcode: ref v19,
                    imm: v20,
                } = v18 {
                    if let &Opcode::Iconst = v19 {
                        let v21 = C::u64_from_imm64(ctx, v20);
                        if v21 == 0x0_u64 {
                            let v54 = &constructor_is_nonzero(ctx, arg1);
                            // Rule at src/isa/x64/inst.isle line 3552.
                            return v54.clone();
                        }
                    }
                }
            }
        }
        _ => {}
    }
    let v2 = C::value_type(ctx, arg1);
    if v2 == I128 {
        let v42 = C::put_in_regs(ctx, arg1);
        let v44 = constructor_value_regs_get_gpr(ctx, v42, 0x0_usize);
        let v45 = C::put_in_regs(ctx, arg1);
        let v47 = constructor_value_regs_get_gpr(ctx, v45, 0x1_usize);
        let v48 = C::put_in_regs(ctx, arg2);
        let v49 = constructor_value_regs_get_gpr(ctx, v48, 0x0_usize);
        let v50 = C::put_in_regs(ctx, arg2);
        let v51 = constructor_value_regs_get_gpr(ctx, v50, 0x1_usize);
        let v52 = &C::intcc_to_cc(ctx, arg0);
        let v53 = &constructor_emit_cmp_i128(ctx, v52, v47, v44, v51, v49);
        // Rule at src/isa/x64/inst.isle line 3541.
        return v53.clone();
    }
    let v28 = C::def_inst(ctx, arg1);
    if let Some(v29) = v28 {
        let v30 = &C::inst_data_value(ctx, v29);
        if let &InstructionData::UnaryImm {
            opcode: ref v31,
            imm: v32,
        } = v30 {
            if let &Opcode::Iconst = v31 {
                let v33 = C::u64_from_imm64(ctx, v32);
                if v33 == 0x0_u64 {
                    let v35 = C::put_in_reg(ctx, arg2);
                    let v36 = C::gpr_new(ctx, v35);
                    let v37 = &C::gpr_to_gpr_mem_imm(ctx, v36);
                    let v34 = C::value_type(ctx, arg2);
                    let v38 = &constructor_x64_test(ctx, v34, v36, v37);
                    let v39 = &C::intcc_swap_args(ctx, arg0);
                    let v40 = &C::intcc_to_cc(ctx, v39);
                    let v41 = CondResult::CC {
                        producer: v38.clone(),
                        cc: v40.clone(),
                    };
                    // Rule at src/isa/x64/inst.isle line 3535.
                    return v41;
                }
            }
        }
    }
    let v16 = C::def_inst(ctx, arg2);
    if let Some(v17) = v16 {
        let v18 = &C::inst_data_value(ctx, v17);
        if let &InstructionData::UnaryImm {
            opcode: ref v19,
            imm: v20,
        } = v18 {
            if let &Opcode::Iconst = v19 {
                let v21 = C::u64_from_imm64(ctx, v20);
                if v21 == 0x0_u64 {
                    let v22 = C::put_in_reg(ctx, arg1);
                    let v23 = C::gpr_new(ctx, v22);
                    let v24 = &C::gpr_to_gpr_mem_imm(ctx, v23);
                    let v25 = &constructor_x64_test(ctx, v2, v23, v24);
                    let v26 = &C::intcc_to_cc(ctx, arg0);
                    let v27 = CondResult::CC {
                        producer: v25.clone(),
                        cc: v26.clone(),
                    };
                    // Rule at src/isa/x64/inst.isle line 3532.
                    return v27;
                }
            }
        }
    }
    let v9 = &C::simm32_from_value(ctx, arg1);
    if let Some(v10) = v9 {
        let v11 = constructor_put_in_gpr(ctx, arg2);
        let v12 = &constructor_x64_cmp(ctx, v2, v11, v10);
        let v13 = &C::intcc_swap_args(ctx, arg0);
        let v14 = &C::intcc_to_cc(ctx, v13);
        let v15 = CondResult::CC {
            producer: v12.clone(),
            cc: v14.clone(),
        };
        // Rule at src/isa/x64/inst.isle line 3528.
        return v15;
    }
    let v4 = constructor_put_in_gpr(ctx, arg1);
    let v5 = &constructor_put_in_gpr_mem_imm(ctx, arg2);
    let v6 = &constructor_x64_cmp(ctx, v2, v4, v5);
    let v7 = &C::intcc_to_cc(ctx, arg0);
    let v8 = CondResult::CC {
        producer: v6.clone(),
        cc: v7.clone(),
    };
    // Rule at src/isa/x64/inst.isle line 3523.
    return v8;
}

// Generated as internal constructor for term emit_cmp_i128.
pub fn constructor_emit_cmp_i128<C: Context>(
    ctx: &mut C,
    arg0: &CC,
    arg1: Gpr,
    arg2: Gpr,
    arg3: Gpr,
    arg4: Gpr,
) -> CondResult {
    match arg0 {
        &CC::BE => {
            let v12 = &constructor_emit_cmp_i128(ctx, &CC::NB, arg3, arg4, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 3564.
            return v12.clone();
        }
        &CC::NBE => {
            let v10 = &constructor_emit_cmp_i128(ctx, &CC::B, arg3, arg4, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 3562.
            return v10.clone();
        }
        &CC::LE => {
            let v8 = &constructor_emit_cmp_i128(ctx, &CC::NL, arg3, arg4, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 3560.
            return v8.clone();
        }
        &CC::NLE => {
            let v6 = &constructor_emit_cmp_i128(ctx, &CC::L, arg3, arg4, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 3558.
            return v6.clone();
        }
        _ => {}
    }
    let v13 = &C::cc_nz_or_z(ctx, arg0);
    if let Some(v14) = v13 {
        let v16 = &C::gpr_to_gpr_mem_imm(ctx, arg4);
        let v17 = constructor_x64_xor(ctx, I64, arg2, v16);
        let v18 = C::gpr_to_reg(ctx, v17);
        let v19 = &C::gpr_to_gpr_mem_imm(ctx, arg3);
        let v20 = constructor_x64_xor(ctx, I64, arg1, v19);
        let v21 = C::gpr_to_reg(ctx, v20);
        let v23 = C::gpr_new(ctx, v18);
        let v24 = &constructor_reg_to_gpr_mem_imm(ctx, v21);
        let v25 = &constructor_x64_produce_flags_side_effect(ctx, &ProduceFlagsSideEffectOp::Or, I64, v23, v24);
        let v26 = CondResult::CC {
            producer: v25.clone(),
            cc: v14.clone(),
        };
        // Rule at src/isa/x64/inst.isle line 3569.
        return v26;
    }
    let v27 = &C::gpr_to_gpr_mem(ctx, arg4);
    let v28 = &constructor_x64_cmpq_rm(ctx, arg2, v27);
    let v30 = &C::gpr_to_gpr_mem_imm(ctx, arg3);
    let v31 = &constructor_x64_produce_flags_side_effect(ctx, &ProduceFlagsSideEffectOp::Sbb, I64, arg1, v30);
    let v32 = &constructor_produces_flags_concat(ctx, v28, v31);
    let v33 = CondResult::CC {
        producer: v32.clone(),
        cc: arg0.clone(),
    };
    // Rule at src/isa/x64/inst.isle line 3579.
    return v33;
}

// Generated as internal constructor for term emit_fcmp.
pub fn constructor_emit_fcmp<C: Context>(
    ctx: &mut C,
    arg0: &FloatCC,
    arg1: Value,
    arg2: Value,
) -> CondResult {
    match arg0 {
        &FloatCC::Equal => {
            let v2 = C::value_type(ctx, arg1);
            let v3 = C::ty_scalar_float(ctx, v2);
            if let Some(v4) = v3 {
                let v6 = constructor_put_in_xmm(ctx, arg1);
                let v7 = &C::put_in_xmm_mem(ctx, arg2);
                let v8 = &constructor_x64_ucomis(ctx, v4, v6, v7);
                let v11 = CondResult::And {
                    producer: v8.clone(),
                    cc1: CC::NP,
                    cc2: CC::Z,
                };
                // Rule at src/isa/x64/inst.isle line 3602.
                return v11;
            }
        }
        &FloatCC::GreaterThan => {
            let v2 = C::value_type(ctx, arg1);
            let v3 = C::ty_scalar_float(ctx, v2);
            if let Some(v4) = v3 {
                let v6 = constructor_put_in_xmm(ctx, arg1);
                let v7 = &C::put_in_xmm_mem(ctx, arg2);
                let v8 = &constructor_x64_ucomis(ctx, v4, v6, v7);
                let v20 = CondResult::CC {
                    producer: v8.clone(),
                    cc: CC::NBE,
                };
                // Rule at src/isa/x64/inst.isle line 3618.
                return v20;
            }
        }
        &FloatCC::GreaterThanOrEqual => {
            let v2 = C::value_type(ctx, arg1);
            let v3 = C::ty_scalar_float(ctx, v2);
            if let Some(v4) = v3 {
                let v6 = constructor_put_in_xmm(ctx, arg1);
                let v7 = &C::put_in_xmm_mem(ctx, arg2);
                let v8 = &constructor_x64_ucomis(ctx, v4, v6, v7);
                let v22 = CondResult::CC {
                    producer: v8.clone(),
                    cc: CC::NB,
                };
                // Rule at src/isa/x64/inst.isle line 3620.
                return v22;
            }
        }
        &FloatCC::LessThan => {
            let v2 = C::value_type(ctx, arg1);
            let v3 = C::ty_scalar_float(ctx, v2);
            if let Some(v4) = v3 {
                let v27 = constructor_put_in_xmm(ctx, arg2);
                let v28 = &C::put_in_xmm_mem(ctx, arg1);
                let v29 = &constructor_x64_ucomis(ctx, v4, v27, v28);
                let v30 = CondResult::CC {
                    producer: v29.clone(),
                    cc: CC::NBE,
                };
                // Rule at src/isa/x64/inst.isle line 3630.
                return v30;
            }
        }
        &FloatCC::LessThanOrEqual => {
            let v2 = C::value_type(ctx, arg1);
            let v3 = C::ty_scalar_float(ctx, v2);
            if let Some(v4) = v3 {
                let v27 = constructor_put_in_xmm(ctx, arg2);
                let v28 = &C::put_in_xmm_mem(ctx, arg1);
                let v29 = &constructor_x64_ucomis(ctx, v4, v27, v28);
                let v31 = CondResult::CC {
                    producer: v29.clone(),
                    cc: CC::NB,
                };
                // Rule at src/isa/x64/inst.isle line 3633.
                return v31;
            }
        }
        &FloatCC::NotEqual => {
            let v2 = C::value_type(ctx, arg1);
            let v3 = C::ty_scalar_float(ctx, v2);
            if let Some(v4) = v3 {
                let v6 = constructor_put_in_xmm(ctx, arg1);
                let v7 = &C::put_in_xmm_mem(ctx, arg2);
                let v8 = &constructor_x64_ucomis(ctx, v4, v6, v7);
                let v14 = CondResult::Or {
                    producer: v8.clone(),
                    cc1: CC::P,
                    cc2: CC::NZ,
                };
                // Rule at src/isa/x64/inst.isle line 3605.
                return v14;
            }
        }
        &FloatCC::Ordered => {
            let v2 = C::value_type(ctx, arg1);
            let v3 = C::ty_scalar_float(ctx, v2);
            if let Some(v4) = v3 {
                let v6 = constructor_put_in_xmm(ctx, arg1);
                let v7 = &C::put_in_xmm_mem(ctx, arg2);
                let v8 = &constructor_x64_ucomis(ctx, v4, v6, v7);
                let v15 = CondResult::CC {
                    producer: v8.clone(),
                    cc: CC::NP,
                };
                // Rule at src/isa/x64/inst.isle line 3610.
                return v15;
            }
        }
        &FloatCC::OrderedNotEqual => {
            let v2 = C::value_type(ctx, arg1);
            let v3 = C::ty_scalar_float(ctx, v2);
            if let Some(v4) = v3 {
                let v6 = constructor_put_in_xmm(ctx, arg1);
                let v7 = &C::put_in_xmm_mem(ctx, arg2);
                let v8 = &constructor_x64_ucomis(ctx, v4, v6, v7);
                let v17 = CondResult::CC {
                    producer: v8.clone(),
                    cc: CC::NZ,
                };
                // Rule at src/isa/x64/inst.isle line 3614.
                return v17;
            }
        }
        &FloatCC::Unordered => {
            let v2 = C::value_type(ctx, arg1);
            let v3 = C::ty_scalar_float(ctx, v2);
            if let Some(v4) = v3 {
                let v6 = constructor_put_in_xmm(ctx, arg1);
                let v7 = &C::put_in_xmm_mem(ctx, arg2);
                let v8 = &constructor_x64_ucomis(ctx, v4, v6, v7);
                let v16 = CondResult::CC {
                    producer: v8.clone(),
                    cc: CC::P,
                };
                // Rule at src/isa/x64/inst.isle line 3612.
                return v16;
            }
        }
        &FloatCC::UnorderedOrEqual => {
            let v2 = C::value_type(ctx, arg1);
            let v3 = C::ty_scalar_float(ctx, v2);
            if let Some(v4) = v3 {
                let v6 = constructor_put_in_xmm(ctx, arg1);
                let v7 = &C::put_in_xmm_mem(ctx, arg2);
                let v8 = &constructor_x64_ucomis(ctx, v4, v6, v7);
                let v18 = CondResult::CC {
                    producer: v8.clone(),
                    cc: CC::Z,
                };
                // Rule at src/isa/x64/inst.isle line 3616.
                return v18;
            }
        }
        &FloatCC::UnorderedOrGreaterThan => {
            let v2 = C::value_type(ctx, arg1);
            let v3 = C::ty_scalar_float(ctx, v2);
            if let Some(v4) = v3 {
                let v27 = constructor_put_in_xmm(ctx, arg2);
                let v28 = &C::put_in_xmm_mem(ctx, arg1);
                let v29 = &constructor_x64_ucomis(ctx, v4, v27, v28);
                let v32 = CondResult::CC {
                    producer: v29.clone(),
                    cc: CC::B,
                };
                // Rule at src/isa/x64/inst.isle line 3636.
                return v32;
            }
        }
        &FloatCC::UnorderedOrGreaterThanOrEqual => {
            let v2 = C::value_type(ctx, arg1);
            let v3 = C::ty_scalar_float(ctx, v2);
            if let Some(v4) = v3 {
                let v27 = constructor_put_in_xmm(ctx, arg2);
                let v28 = &C::put_in_xmm_mem(ctx, arg1);
                let v29 = &constructor_x64_ucomis(ctx, v4, v27, v28);
                let v33 = CondResult::CC {
                    producer: v29.clone(),
                    cc: CC::BE,
                };
                // Rule at src/isa/x64/inst.isle line 3639.
                return v33;
            }
        }
        &FloatCC::UnorderedOrLessThan => {
            let v2 = C::value_type(ctx, arg1);
            let v3 = C::ty_scalar_float(ctx, v2);
            if let Some(v4) = v3 {
                let v6 = constructor_put_in_xmm(ctx, arg1);
                let v7 = &C::put_in_xmm_mem(ctx, arg2);
                let v8 = &constructor_x64_ucomis(ctx, v4, v6, v7);
                let v24 = CondResult::CC {
                    producer: v8.clone(),
                    cc: CC::B,
                };
                // Rule at src/isa/x64/inst.isle line 3622.
                return v24;
            }
        }
        &FloatCC::UnorderedOrLessThanOrEqual => {
            let v2 = C::value_type(ctx, arg1);
            let v3 = C::ty_scalar_float(ctx, v2);
            if let Some(v4) = v3 {
                let v6 = constructor_put_in_xmm(ctx, arg1);
                let v7 = &C::put_in_xmm_mem(ctx, arg2);
                let v8 = &constructor_x64_ucomis(ctx, v4, v6, v7);
                let v26 = CondResult::CC {
                    producer: v8.clone(),
                    cc: CC::BE,
                };
                // Rule at src/isa/x64/inst.isle line 3624.
                return v26;
            }
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "emit_fcmp", "src/isa/x64/inst.isle line 3600")
}

// Generated as internal constructor for term x64_cmpxchg.
pub fn constructor_x64_cmpxchg<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Gpr,
    arg2: Gpr,
    arg3: &SyntheticAmode,
) -> Gpr {
    match arg0 {
        I8 => {
            let v4 = constructor_x64_lock_cmpxchgb_mr(ctx, arg3, arg2, arg1);
            // Rule at src/isa/x64/inst.isle line 3652.
            return v4;
        }
        I16 => {
            let v5 = constructor_x64_lock_cmpxchgw_mr(ctx, arg3, arg2, arg1);
            // Rule at src/isa/x64/inst.isle line 3653.
            return v5;
        }
        I32 => {
            let v6 = constructor_x64_lock_cmpxchgl_mr(ctx, arg3, arg2, arg1);
            // Rule at src/isa/x64/inst.isle line 3654.
            return v6;
        }
        I64 => {
            let v7 = constructor_x64_lock_cmpxchgq_mr(ctx, arg3, arg2, arg1);
            // Rule at src/isa/x64/inst.isle line 3655.
            return v7;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_cmpxchg", "src/isa/x64/inst.isle line 3651")
}

// Generated as internal constructor for term x64_cmpxchg16b.
pub fn constructor_x64_cmpxchg16b<C: Context>(
    ctx: &mut C,
    arg0: ValueRegs,
    arg1: ValueRegs,
    arg2: &SyntheticAmode,
) -> ValueRegs {
    let v4 = constructor_value_regs_get_gpr(ctx, arg0, 0x0_usize);
    let v6 = constructor_value_regs_get_gpr(ctx, arg0, 0x1_usize);
    let v7 = constructor_value_regs_get_gpr(ctx, arg1, 0x0_usize);
    let v8 = constructor_value_regs_get_gpr(ctx, arg1, 0x1_usize);
    let v9 = constructor_x64_lock_cmpxchg16b_m(ctx, v4, v6, v7, v8, arg2);
    // Rule at src/isa/x64/inst.isle line 3658.
    return v9;
}

// Generated as internal constructor for term x64_xadd.
pub fn constructor_x64_xadd<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: &SyntheticAmode,
    arg2: Gpr,
) -> Gpr {
    match arg0 {
        I8 => {
            let v3 = constructor_x64_lock_xaddb_mr(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 3666.
            return v3;
        }
        I16 => {
            let v4 = constructor_x64_lock_xaddw_mr(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 3667.
            return v4;
        }
        I32 => {
            let v5 = constructor_x64_lock_xaddl_mr(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 3668.
            return v5;
        }
        I64 => {
            let v6 = constructor_x64_lock_xaddq_mr(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 3669.
            return v6;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_xadd", "src/isa/x64/inst.isle line 3665")
}

// Generated as internal constructor for term x64_xchg.
pub fn constructor_x64_xchg<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: &SyntheticAmode,
    arg2: Gpr,
) -> Gpr {
    match arg0 {
        I8 => {
            let v3 = constructor_x64_xchgb_rm(ctx, arg2, arg1);
            // Rule at src/isa/x64/inst.isle line 3672.
            return v3;
        }
        I16 => {
            let v4 = constructor_x64_xchgw_rm(ctx, arg2, arg1);
            // Rule at src/isa/x64/inst.isle line 3673.
            return v4;
        }
        I32 => {
            let v5 = constructor_x64_xchgl_rm(ctx, arg2, arg1);
            // Rule at src/isa/x64/inst.isle line 3674.
            return v5;
        }
        I64 => {
            let v6 = constructor_x64_xchgq_rm(ctx, arg2, arg1);
            // Rule at src/isa/x64/inst.isle line 3675.
            return v6;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_xchg", "src/isa/x64/inst.isle line 3671")
}

// Generated as internal constructor for term x64_lock_add.
pub fn constructor_x64_lock_add<C: Context>(
    ctx: &mut C,
    arg0: &OperandSize,
    arg1: &SyntheticAmode,
    arg2: Gpr,
) -> SideEffectNoResult {
    match arg0 {
        &OperandSize::Size8 => {
            let v3 = &constructor_x64_lock_addb_mr_mem(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 3678.
            return v3.clone();
        }
        &OperandSize::Size16 => {
            let v4 = &constructor_x64_lock_addw_mr_mem(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 3679.
            return v4.clone();
        }
        &OperandSize::Size32 => {
            let v5 = &constructor_x64_lock_addl_mr_mem(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 3680.
            return v5.clone();
        }
        &OperandSize::Size64 => {
            let v6 = &constructor_x64_lock_addq_mr_mem(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 3681.
            return v6.clone();
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_lock_add", "src/isa/x64/inst.isle line 3677")
}

// Generated as internal constructor for term x64_lock_sub.
pub fn constructor_x64_lock_sub<C: Context>(
    ctx: &mut C,
    arg0: &OperandSize,
    arg1: &SyntheticAmode,
    arg2: Gpr,
) -> SideEffectNoResult {
    match arg0 {
        &OperandSize::Size8 => {
            let v3 = &constructor_x64_lock_subb_mr_mem(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 3684.
            return v3.clone();
        }
        &OperandSize::Size16 => {
            let v4 = &constructor_x64_lock_subw_mr_mem(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 3685.
            return v4.clone();
        }
        &OperandSize::Size32 => {
            let v5 = &constructor_x64_lock_subl_mr_mem(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 3686.
            return v5.clone();
        }
        &OperandSize::Size64 => {
            let v6 = &constructor_x64_lock_subq_mr_mem(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 3687.
            return v6.clone();
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_lock_sub", "src/isa/x64/inst.isle line 3683")
}

// Generated as internal constructor for term x64_lock_and.
pub fn constructor_x64_lock_and<C: Context>(
    ctx: &mut C,
    arg0: &OperandSize,
    arg1: &SyntheticAmode,
    arg2: Gpr,
) -> SideEffectNoResult {
    match arg0 {
        &OperandSize::Size8 => {
            let v3 = &constructor_x64_lock_andb_mr_mem(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 3690.
            return v3.clone();
        }
        &OperandSize::Size16 => {
            let v4 = &constructor_x64_lock_andw_mr_mem(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 3691.
            return v4.clone();
        }
        &OperandSize::Size32 => {
            let v5 = &constructor_x64_lock_andl_mr_mem(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 3692.
            return v5.clone();
        }
        &OperandSize::Size64 => {
            let v6 = &constructor_x64_lock_andq_mr_mem(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 3693.
            return v6.clone();
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_lock_and", "src/isa/x64/inst.isle line 3689")
}

// Generated as internal constructor for term x64_lock_or.
pub fn constructor_x64_lock_or<C: Context>(
    ctx: &mut C,
    arg0: &OperandSize,
    arg1: &SyntheticAmode,
    arg2: Gpr,
) -> SideEffectNoResult {
    match arg0 {
        &OperandSize::Size8 => {
            let v3 = &constructor_x64_lock_orb_mr_mem(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 3696.
            return v3.clone();
        }
        &OperandSize::Size16 => {
            let v4 = &constructor_x64_lock_orw_mr_mem(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 3697.
            return v4.clone();
        }
        &OperandSize::Size32 => {
            let v5 = &constructor_x64_lock_orl_mr_mem(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 3698.
            return v5.clone();
        }
        &OperandSize::Size64 => {
            let v6 = &constructor_x64_lock_orq_mr_mem(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 3699.
            return v6.clone();
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_lock_or", "src/isa/x64/inst.isle line 3695")
}

// Generated as internal constructor for term x64_lock_xor.
pub fn constructor_x64_lock_xor<C: Context>(
    ctx: &mut C,
    arg0: &OperandSize,
    arg1: &SyntheticAmode,
    arg2: Gpr,
) -> SideEffectNoResult {
    match arg0 {
        &OperandSize::Size8 => {
            let v3 = &constructor_x64_lock_xorb_mr_mem(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 3702.
            return v3.clone();
        }
        &OperandSize::Size16 => {
            let v4 = &constructor_x64_lock_xorw_mr_mem(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 3703.
            return v4.clone();
        }
        &OperandSize::Size32 => {
            let v5 = &constructor_x64_lock_xorl_mr_mem(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 3704.
            return v5.clone();
        }
        &OperandSize::Size64 => {
            let v6 = &constructor_x64_lock_xorq_mr_mem(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 3705.
            return v6.clone();
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_lock_xor", "src/isa/x64/inst.isle line 3701")
}

// Generated as internal constructor for term x64_atomic_rmw_seq.
pub fn constructor_x64_atomic_rmw_seq<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: &AtomicRmwSeqOp,
    arg2: &SyntheticAmode,
    arg3: Gpr,
) -> Gpr {
    let v4 = C::temp_writable_gpr(ctx);
    let v5 = C::temp_writable_gpr(ctx);
    let v6 = MInst::AtomicRmwSeq {
        ty: arg0,
        op: arg1.clone(),
        mem: arg2.clone(),
        operand: arg3,
        temp: v5,
        dst_old: v4,
    };
    let v7 = C::emit(ctx, &v6);
    let v8 = C::writable_gpr_to_gpr(ctx, v4);
    // Rule at src/isa/x64/inst.isle line 3708.
    return v8;
}

// Generated as internal constructor for term x64_atomic_128_rmw_seq.
pub fn constructor_x64_atomic_128_rmw_seq<C: Context>(
    ctx: &mut C,
    arg0: &AtomicRmwOp,
    arg1: &SyntheticAmode,
    arg2: ValueRegs,
) -> ValueRegs {
    if let &AtomicRmwOp::Xchg = arg0 {
        let v3 = C::temp_writable_gpr(ctx);
        let v4 = C::temp_writable_gpr(ctx);
        let v18 = constructor_value_regs_get_gpr(ctx, arg2, 0x0_usize);
        let v19 = constructor_value_regs_get_gpr(ctx, arg2, 0x1_usize);
        let v20 = MInst::Atomic128XchgSeq {
            mem: arg1.clone(),
            operand_low: v18,
            operand_high: v19,
            dst_old_low: v3,
            dst_old_high: v4,
        };
        let v21 = C::emit(ctx, &v20);
        let v22 = constructor_writable_gpr_to_r_reg(ctx, v3);
        let v23 = constructor_writable_gpr_to_r_reg(ctx, v4);
        let v24 = C::value_regs(ctx, v22, v23);
        // Rule at src/isa/x64/inst.isle line 3725.
        return v24;
    }
    let v3 = C::temp_writable_gpr(ctx);
    let v4 = C::temp_writable_gpr(ctx);
    let v5 = C::temp_writable_gpr(ctx);
    let v6 = C::temp_writable_gpr(ctx);
    let v8 = constructor_value_regs_get_gpr(ctx, arg2, 0x0_usize);
    let v10 = constructor_value_regs_get_gpr(ctx, arg2, 0x1_usize);
    let v11 = &constructor_atomic_128_rmw_seq_op(ctx, arg0);
    let v12 = &C::box_synthetic_amode(ctx, arg1);
    let v13 = MInst::Atomic128RmwSeq {
        op: v11.clone(),
        mem: v12.clone(),
        operand_low: v8,
        operand_high: v10,
        temp_low: v5,
        temp_high: v6,
        dst_old_low: v3,
        dst_old_high: v4,
    };
    let v14 = C::emit(ctx, &v13);
    let v15 = constructor_writable_gpr_to_r_reg(ctx, v3);
    let v16 = constructor_writable_gpr_to_r_reg(ctx, v4);
    let v17 = C::value_regs(ctx, v15, v16);
    // Rule at src/isa/x64/inst.isle line 3715.
    return v17;
}

// Generated as internal constructor for term x64_atomic_128_store_seq.
pub fn constructor_x64_atomic_128_store_seq<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: ValueRegs,
) -> SideEffectNoResult {
    let v2 = C::temp_writable_gpr(ctx);
    let v3 = C::temp_writable_gpr(ctx);
    let v5 = constructor_value_regs_get_gpr(ctx, arg1, 0x0_usize);
    let v7 = constructor_value_regs_get_gpr(ctx, arg1, 0x1_usize);
    let v8 = MInst::Atomic128XchgSeq {
        mem: arg0.clone(),
        operand_low: v5,
        operand_high: v7,
        dst_old_low: v2,
        dst_old_high: v3,
    };
    let v9 = SideEffectNoResult::Inst {
        inst: v8,
    };
    // Rule at src/isa/x64/inst.isle line 3734.
    return v9;
}

// Generated as internal constructor for term atomic_rmw_seq_op.
pub fn constructor_atomic_rmw_seq_op<C: Context>(
    ctx: &mut C,
    arg0: &AtomicRmwOp,
) -> AtomicRmwSeqOp {
    match arg0 {
        &AtomicRmwOp::And => {
            // Rule at src/isa/x64/inst.isle line 3753.
            return AtomicRmwSeqOp::And;
        }
        &AtomicRmwOp::Nand => {
            // Rule at src/isa/x64/inst.isle line 3754.
            return AtomicRmwSeqOp::Nand;
        }
        &AtomicRmwOp::Or => {
            // Rule at src/isa/x64/inst.isle line 3755.
            return AtomicRmwSeqOp::Or;
        }
        &AtomicRmwOp::Smax => {
            // Rule at src/isa/x64/inst.isle line 3760.
            return AtomicRmwSeqOp::Smax;
        }
        &AtomicRmwOp::Smin => {
            // Rule at src/isa/x64/inst.isle line 3759.
            return AtomicRmwSeqOp::Smin;
        }
        &AtomicRmwOp::Umax => {
            // Rule at src/isa/x64/inst.isle line 3758.
            return AtomicRmwSeqOp::Umax;
        }
        &AtomicRmwOp::Umin => {
            // Rule at src/isa/x64/inst.isle line 3757.
            return AtomicRmwSeqOp::Umin;
        }
        &AtomicRmwOp::Xor => {
            // Rule at src/isa/x64/inst.isle line 3756.
            return AtomicRmwSeqOp::Xor;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "atomic_rmw_seq_op", "src/isa/x64/inst.isle line 3752")
}

// Generated as internal constructor for term atomic_128_rmw_seq_op.
pub fn constructor_atomic_128_rmw_seq_op<C: Context>(
    ctx: &mut C,
    arg0: &AtomicRmwOp,
) -> Atomic128RmwSeqOp {
    match arg0 {
        &AtomicRmwOp::Add => {
            // Rule at src/isa/x64/inst.isle line 3775.
            return Atomic128RmwSeqOp::Add;
        }
        &AtomicRmwOp::And => {
            // Rule at src/isa/x64/inst.isle line 3777.
            return Atomic128RmwSeqOp::And;
        }
        &AtomicRmwOp::Nand => {
            // Rule at src/isa/x64/inst.isle line 3778.
            return Atomic128RmwSeqOp::Nand;
        }
        &AtomicRmwOp::Or => {
            // Rule at src/isa/x64/inst.isle line 3779.
            return Atomic128RmwSeqOp::Or;
        }
        &AtomicRmwOp::Smax => {
            // Rule at src/isa/x64/inst.isle line 3784.
            return Atomic128RmwSeqOp::Smax;
        }
        &AtomicRmwOp::Smin => {
            // Rule at src/isa/x64/inst.isle line 3783.
            return Atomic128RmwSeqOp::Smin;
        }
        &AtomicRmwOp::Sub => {
            // Rule at src/isa/x64/inst.isle line 3776.
            return Atomic128RmwSeqOp::Sub;
        }
        &AtomicRmwOp::Umax => {
            // Rule at src/isa/x64/inst.isle line 3782.
            return Atomic128RmwSeqOp::Umax;
        }
        &AtomicRmwOp::Umin => {
            // Rule at src/isa/x64/inst.isle line 3781.
            return Atomic128RmwSeqOp::Umin;
        }
        &AtomicRmwOp::Xor => {
            // Rule at src/isa/x64/inst.isle line 3780.
            return Atomic128RmwSeqOp::Xor;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "atomic_128_rmw_seq_op", "src/isa/x64/inst.isle line 3774")
}

// Generated as internal constructor for term bitcast_xmm_to_gpr.
pub fn constructor_bitcast_xmm_to_gpr<C: Context>(
    ctx: &mut C,
    arg0: u8,
    arg1: Xmm,
) -> Gpr {
    match arg0 {
        0x10_u8 => {
            let v3 = constructor_x64_pextrw(ctx, arg1, 0x0_u8);
            // Rule at src/isa/x64/inst.isle line 3789.
            return v3;
        }
        0x20_u8 => {
            let v4 = constructor_x64_movd_to_gpr(ctx, arg1);
            // Rule at src/isa/x64/inst.isle line 3791.
            return v4;
        }
        0x40_u8 => {
            let v5 = constructor_x64_movq_to_gpr(ctx, arg1);
            // Rule at src/isa/x64/inst.isle line 3793.
            return v5;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "bitcast_xmm_to_gpr", "src/isa/x64/inst.isle line 3788")
}

// Generated as internal constructor for term bitcast_xmm_to_gprs.
pub fn constructor_bitcast_xmm_to_gprs<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
) -> ValueRegs {
    let v1 = constructor_x64_movq_to_gpr(ctx, arg0);
    let v2 = C::gpr_to_reg(ctx, v1);
    let v3 = &C::xmm_to_xmm_mem(ctx, arg0);
    let v5 = constructor_x64_pshufd(ctx, v3, 0xee_u8);
    let v6 = constructor_x64_movq_to_gpr(ctx, v5);
    let v7 = C::gpr_to_reg(ctx, v6);
    let v8 = C::value_regs(ctx, v2, v7);
    // Rule at src/isa/x64/inst.isle line 3797.
    return v8;
}

// Generated as internal constructor for term bitcast_gpr_to_xmm.
pub fn constructor_bitcast_gpr_to_xmm<C: Context>(
    ctx: &mut C,
    arg0: u8,
    arg1: Gpr,
) -> Xmm {
    match arg0 {
        0x10_u8 => {
            let v3 = constructor_xmm_zero(ctx, I16X8);
            let v4 = &C::gpr_to_gpr_mem(ctx, arg1);
            let v6 = constructor_x64_pinsrw(ctx, v3, v4, 0x0_u8);
            // Rule at src/isa/x64/inst.isle line 3803.
            return v6;
        }
        0x20_u8 => {
            let v7 = &C::gpr_to_gpr_mem(ctx, arg1);
            let v8 = constructor_x64_movd_to_xmm(ctx, v7);
            // Rule at src/isa/x64/inst.isle line 3805.
            return v8;
        }
        0x40_u8 => {
            let v7 = &C::gpr_to_gpr_mem(ctx, arg1);
            let v9 = constructor_x64_movq_to_xmm(ctx, v7);
            // Rule at src/isa/x64/inst.isle line 3807.
            return v9;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "bitcast_gpr_to_xmm", "src/isa/x64/inst.isle line 3802")
}

// Generated as internal constructor for term bitcast_gprs_to_xmm.
pub fn constructor_bitcast_gprs_to_xmm<C: Context>(
    ctx: &mut C,
    arg0: ValueRegs,
) -> Xmm {
    let v2 = constructor_value_regs_get_gpr(ctx, arg0, 0x0_usize);
    let v3 = &C::gpr_to_gpr_mem(ctx, v2);
    let v4 = constructor_x64_movq_to_xmm(ctx, v3);
    let v6 = constructor_value_regs_get_gpr(ctx, arg0, 0x1_usize);
    let v7 = &C::gpr_to_gpr_mem(ctx, v6);
    let v8 = constructor_x64_movq_to_xmm(ctx, v7);
    let v9 = &C::xmm_to_xmm_mem(ctx, v8);
    let v10 = constructor_x64_punpcklqdq(ctx, v4, v9);
    // Rule at src/isa/x64/inst.isle line 3811.
    return v10;
}

// Generated as internal constructor for term stack_addr_impl.
pub fn constructor_stack_addr_impl<C: Context>(
    ctx: &mut C,
    arg0: StackSlot,
    arg1: Offset32,
) -> Gpr {
    let v2 = C::temp_writable_gpr(ctx);
    let v3 = C::writable_gpr_to_reg(ctx, v2);
    let v4 = &C::abi_stackslot_addr(ctx, v3, arg0, arg1);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_gpr_to_gpr(ctx, v2);
    // Rule at src/isa/x64/inst.isle line 3817.
    return v6;
}

// Generated as internal constructor for term x64_checked_srem_seq.
pub fn constructor_x64_checked_srem_seq<C: Context>(
    ctx: &mut C,
    arg0: &OperandSize,
    arg1: Gpr,
    arg2: Gpr,
    arg3: Gpr,
) -> ValueRegs {
    let v4 = C::temp_writable_gpr(ctx);
    let v5 = C::temp_writable_gpr(ctx);
    let v6 = MInst::CheckedSRemSeq {
        size: arg0.clone(),
        dividend_lo: arg1,
        dividend_hi: arg2,
        divisor: arg3,
        dst_quotient: v4,
        dst_remainder: v5,
    };
    let v7 = C::emit(ctx, &v6);
    let v8 = constructor_writable_gpr_to_r_reg(ctx, v4);
    let v9 = constructor_writable_gpr_to_r_reg(ctx, v5);
    let v10 = C::value_regs(ctx, v8, v9);
    // Rule at src/isa/x64/inst.isle line 3826.
    return v10;
}

// Generated as internal constructor for term x64_checked_srem_seq8.
pub fn constructor_x64_checked_srem_seq8<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: Gpr,
) -> Gpr {
    let v2 = C::temp_writable_gpr(ctx);
    let v3 = MInst::CheckedSRemSeq8 {
        dividend: arg0,
        divisor: arg1,
        dst: v2,
    };
    let v4 = C::emit(ctx, &v3);
    let v5 = C::writable_gpr_to_gpr(ctx, v2);
    // Rule at src/isa/x64/inst.isle line 3833.
    return v5;
}

// Generated as internal constructor for term x64_div.
pub fn constructor_x64_div<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Gpr,
    arg2: Gpr,
    arg3: &GprMem,
    arg4: &TrapCode,
) -> ValueRegs {
    match arg0 {
        I16 => {
            let v5 = constructor_x64_divw_m(ctx, arg1, arg2, arg3, arg4);
            // Rule at src/isa/x64/inst.isle line 3843.
            return v5;
        }
        I32 => {
            let v6 = constructor_x64_divl_m(ctx, arg1, arg2, arg3, arg4);
            // Rule at src/isa/x64/inst.isle line 3844.
            return v6;
        }
        I64 => {
            let v7 = constructor_x64_divq_m(ctx, arg1, arg2, arg3, arg4);
            // Rule at src/isa/x64/inst.isle line 3845.
            return v7;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_div", "src/isa/x64/inst.isle line 3842")
}

// Generated as internal constructor for term x64_idiv.
pub fn constructor_x64_idiv<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Gpr,
    arg2: Gpr,
    arg3: &GprMem,
    arg4: &TrapCode,
) -> ValueRegs {
    match arg0 {
        I16 => {
            let v5 = constructor_x64_idivw_m(ctx, arg1, arg2, arg3, arg4);
            // Rule at src/isa/x64/inst.isle line 3848.
            return v5;
        }
        I32 => {
            let v6 = constructor_x64_idivl_m(ctx, arg1, arg2, arg3, arg4);
            // Rule at src/isa/x64/inst.isle line 3849.
            return v6;
        }
        I64 => {
            let v7 = constructor_x64_idivq_m(ctx, arg1, arg2, arg3, arg4);
            // Rule at src/isa/x64/inst.isle line 3850.
            return v7;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_idiv", "src/isa/x64/inst.isle line 3847")
}

// Generated as internal constructor for term read_pinned_gpr.
pub fn constructor_read_pinned_gpr<C: Context>(
    ctx: &mut C,
) -> Gpr {
    let v0 = C::preg_pinned(ctx);
    let v1 = constructor_mov_from_preg(ctx, v0);
    let v2 = C::gpr_new(ctx, v1);
    // Rule at src/isa/x64/inst.isle line 3855.
    return v2;
}

// Generated as internal constructor for term write_pinned_gpr.
pub fn constructor_write_pinned_gpr<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
) -> SideEffectNoResult {
    let v1 = C::preg_pinned(ctx);
    let v2 = &constructor_mov_to_preg(ctx, v1, arg0);
    // Rule at src/isa/x64/inst.isle line 3859.
    return v2.clone();
}

// Generated as internal constructor for term elf_tls_get_addr.
pub fn constructor_elf_tls_get_addr<C: Context>(
    ctx: &mut C,
    arg0: ExternalName,
) -> Gpr {
    let v1 = C::temp_writable_gpr(ctx);
    let v2 = MInst::ElfTlsGetAddr {
        symbol: arg0,
        dst: v1,
    };
    let v3 = C::emit(ctx, &v2);
    let v4 = C::writable_gpr_to_gpr(ctx, v1);
    // Rule at src/isa/x64/inst.isle line 3901.
    return v4;
}

// Generated as internal constructor for term macho_tls_get_addr.
pub fn constructor_macho_tls_get_addr<C: Context>(
    ctx: &mut C,
    arg0: ExternalName,
) -> Gpr {
    let v1 = C::temp_writable_gpr(ctx);
    let v2 = MInst::MachOTlsGetAddr {
        symbol: arg0,
        dst: v1,
    };
    let v3 = C::emit(ctx, &v2);
    let v4 = C::writable_gpr_to_gpr(ctx, v1);
    // Rule at src/isa/x64/inst.isle line 3908.
    return v4;
}

// Generated as internal constructor for term coff_tls_get_addr.
pub fn constructor_coff_tls_get_addr<C: Context>(
    ctx: &mut C,
    arg0: ExternalName,
) -> Gpr {
    let v1 = C::temp_writable_gpr(ctx);
    let v2 = C::temp_writable_gpr(ctx);
    let v3 = MInst::CoffTlsGetAddr {
        symbol: arg0,
        dst: v1,
        tmp: v2,
    };
    let v4 = C::emit(ctx, &v3);
    let v5 = C::writable_gpr_to_gpr(ctx, v1);
    // Rule at src/isa/x64/inst.isle line 3915.
    return v5;
}

// Generated as internal constructor for term x64_label_address.
pub fn constructor_x64_label_address<C: Context>(
    ctx: &mut C,
    arg0: MachLabel,
) -> Gpr {
    let v1 = C::temp_writable_gpr(ctx);
    let v2 = MInst::LabelAddress {
        dst: v1,
        label: arg0,
    };
    let v3 = C::emit(ctx, &v2);
    let v4 = C::writable_gpr_to_gpr(ctx, v1);
    // Rule at src/isa/x64/inst.isle line 3924.
    return v4;
}

// Generated as internal constructor for term reg_to_xmm_mem.
pub fn constructor_reg_to_xmm_mem<C: Context>(
    ctx: &mut C,
    arg0: Reg,
) -> XmmMem {
    let v1 = C::xmm_new(ctx, arg0);
    let v2 = &C::xmm_to_xmm_mem(ctx, v1);
    // Rule at src/isa/x64/inst.isle line 4010.
    return v2.clone();
}

// Generated as internal constructor for term xmm_to_reg_mem.
pub fn constructor_xmm_to_reg_mem<C: Context>(
    ctx: &mut C,
    arg0: Reg,
) -> XmmMem {
    let v1 = C::xmm_new(ctx, arg0);
    let v2 = C::xmm_to_reg(ctx, v1);
    let v3 = RegMem::Reg {
        reg: v2,
    };
    let v4 = &C::reg_mem_to_xmm_mem(ctx, &v3);
    // Rule at src/isa/x64/inst.isle line 4013.
    return v4.clone();
}

// Generated as internal constructor for term writable_gpr_to_r_reg.
pub fn constructor_writable_gpr_to_r_reg<C: Context>(
    ctx: &mut C,
    arg0: WritableGpr,
) -> Reg {
    let v1 = C::writable_gpr_to_reg(ctx, arg0);
    let v2 = C::writable_reg_to_reg(ctx, v1);
    // Rule at src/isa/x64/inst.isle line 4017.
    return v2;
}

// Generated as internal constructor for term writable_gpr_to_gpr_mem.
pub fn constructor_writable_gpr_to_gpr_mem<C: Context>(
    ctx: &mut C,
    arg0: WritableGpr,
) -> GprMem {
    let v1 = C::writable_gpr_to_gpr(ctx, arg0);
    let v2 = &C::gpr_to_gpr_mem(ctx, v1);
    // Rule at src/isa/x64/inst.isle line 4020.
    return v2.clone();
}

// Generated as internal constructor for term writable_gpr_to_gpr_mem_imm.
pub fn constructor_writable_gpr_to_gpr_mem_imm<C: Context>(
    ctx: &mut C,
    arg0: WritableGpr,
) -> GprMemImm {
    let v1 = C::writable_gpr_to_gpr(ctx, arg0);
    let v2 = &C::gpr_to_gpr_mem_imm(ctx, v1);
    // Rule at src/isa/x64/inst.isle line 4023.
    return v2.clone();
}

// Generated as internal constructor for term writable_gpr_to_value_regs.
pub fn constructor_writable_gpr_to_value_regs<C: Context>(
    ctx: &mut C,
    arg0: WritableGpr,
) -> ValueRegs {
    let v1 = constructor_writable_gpr_to_r_reg(ctx, arg0);
    let v2 = C::value_reg(ctx, v1);
    // Rule at src/isa/x64/inst.isle line 4026.
    return v2;
}

// Generated as internal constructor for term writable_xmm_to_r_reg.
pub fn constructor_writable_xmm_to_r_reg<C: Context>(
    ctx: &mut C,
    arg0: WritableXmm,
) -> Reg {
    let v1 = C::writable_xmm_to_reg(ctx, arg0);
    let v2 = C::writable_reg_to_reg(ctx, v1);
    // Rule at src/isa/x64/inst.isle line 4029.
    return v2;
}

// Generated as internal constructor for term writable_xmm_to_xmm_mem.
pub fn constructor_writable_xmm_to_xmm_mem<C: Context>(
    ctx: &mut C,
    arg0: WritableXmm,
) -> XmmMem {
    let v1 = C::writable_xmm_to_xmm(ctx, arg0);
    let v2 = &C::xmm_to_xmm_mem(ctx, v1);
    // Rule at src/isa/x64/inst.isle line 4032.
    return v2.clone();
}

// Generated as internal constructor for term writable_xmm_to_xmm_mem_aligned.
pub fn constructor_writable_xmm_to_xmm_mem_aligned<C: Context>(
    ctx: &mut C,
    arg0: WritableXmm,
) -> XmmMemAligned {
    let v1 = C::writable_xmm_to_xmm(ctx, arg0);
    let v2 = &constructor_xmm_to_xmm_mem_aligned(ctx, v1);
    // Rule at src/isa/x64/inst.isle line 4035.
    return v2.clone();
}

// Generated as internal constructor for term writable_xmm_to_value_regs.
pub fn constructor_writable_xmm_to_value_regs<C: Context>(
    ctx: &mut C,
    arg0: WritableXmm,
) -> ValueRegs {
    let v1 = constructor_writable_xmm_to_r_reg(ctx, arg0);
    let v2 = C::value_reg(ctx, v1);
    // Rule at src/isa/x64/inst.isle line 4038.
    return v2;
}

// Generated as internal constructor for term synthetic_amode_to_gpr_mem.
pub fn constructor_synthetic_amode_to_gpr_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
) -> GprMem {
    let v1 = &C::synthetic_amode_to_reg_mem(ctx, arg0);
    let v2 = &C::reg_mem_to_gpr_mem(ctx, v1);
    // Rule at src/isa/x64/inst.isle line 4048.
    return v2.clone();
}

// Generated as internal constructor for term amode_to_gpr_mem.
pub fn constructor_amode_to_gpr_mem<C: Context>(
    ctx: &mut C,
    arg0: &Amode,
) -> GprMem {
    let v1 = &C::amode_to_synthetic_amode(ctx, arg0);
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, v1);
    // Rule at src/isa/x64/inst.isle line 4046.
    return v2.clone();
}

// Generated as internal constructor for term amode_to_xmm_mem.
pub fn constructor_amode_to_xmm_mem<C: Context>(
    ctx: &mut C,
    arg0: &Amode,
) -> XmmMem {
    let v1 = &C::amode_to_synthetic_amode(ctx, arg0);
    let v2 = &constructor_synthetic_amode_to_xmm_mem(ctx, v1);
    // Rule at src/isa/x64/inst.isle line 4051.
    return v2.clone();
}

// Generated as internal constructor for term synthetic_amode_to_xmm_mem.
pub fn constructor_synthetic_amode_to_xmm_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
) -> XmmMem {
    let v1 = &C::synthetic_amode_to_reg_mem(ctx, arg0);
    let v2 = &C::reg_mem_to_xmm_mem(ctx, v1);
    // Rule at src/isa/x64/inst.isle line 4054.
    return v2.clone();
}

// Generated as internal constructor for term const_to_xmm_mem.
pub fn constructor_const_to_xmm_mem<C: Context>(
    ctx: &mut C,
    arg0: VCodeConstant,
) -> XmmMem {
    let v1 = &C::const_to_synthetic_amode(ctx, arg0);
    let v2 = &constructor_synthetic_amode_to_xmm_mem(ctx, v1);
    // Rule at src/isa/x64/inst.isle line 4059.
    return v2.clone();
}

// Generated as internal constructor for term const_to_reg_mem.
pub fn constructor_const_to_reg_mem<C: Context>(
    ctx: &mut C,
    arg0: VCodeConstant,
) -> RegMem {
    let v1 = &C::const_to_synthetic_amode(ctx, arg0);
    let v2 = RegMem::Mem {
        addr: v1.clone(),
    };
    // Rule at src/isa/x64/inst.isle line 4061.
    return v2;
}

// Generated as internal constructor for term xmm_to_xmm_mem_aligned.
pub fn constructor_xmm_to_xmm_mem_aligned<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
) -> XmmMemAligned {
    let v1 = &C::xmm_to_xmm_mem(ctx, arg0);
    let v2 = &C::xmm_mem_to_xmm_mem_aligned(ctx, v1);
    // Rule at src/isa/x64/inst.isle line 4064.
    return v2.clone();
}

// Generated as internal constructor for term amode_to_xmm_mem_aligned.
pub fn constructor_amode_to_xmm_mem_aligned<C: Context>(
    ctx: &mut C,
    arg0: &Amode,
) -> XmmMemAligned {
    let v1 = &constructor_amode_to_xmm_mem(ctx, arg0);
    let v2 = &C::xmm_mem_to_xmm_mem_aligned(ctx, v1);
    // Rule at src/isa/x64/inst.isle line 4066.
    return v2.clone();
}

// Generated as internal constructor for term synthetic_amode_to_xmm_mem_aligned.
pub fn constructor_synthetic_amode_to_xmm_mem_aligned<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
) -> XmmMemAligned {
    let v1 = &constructor_synthetic_amode_to_xmm_mem(ctx, arg0);
    let v2 = &C::xmm_mem_to_xmm_mem_aligned(ctx, v1);
    // Rule at src/isa/x64/inst.isle line 4068.
    return v2.clone();
}

// Generated as internal constructor for term put_in_xmm_mem_aligned.
pub fn constructor_put_in_xmm_mem_aligned<C: Context>(
    ctx: &mut C,
    arg0: Value,
) -> XmmMemAligned {
    let v1 = &C::put_in_xmm_mem(ctx, arg0);
    let v2 = &C::xmm_mem_to_xmm_mem_aligned(ctx, v1);
    // Rule at src/isa/x64/inst.isle line 4070.
    return v2.clone();
}

// Generated as internal constructor for term mov_to_preg.
pub fn constructor_mov_to_preg<C: Context>(
    ctx: &mut C,
    arg0: PReg,
    arg1: Gpr,
) -> SideEffectNoResult {
    let v2 = MInst::MovToPReg {
        src: arg1,
        dst: arg0,
    };
    let v3 = SideEffectNoResult::Inst {
        inst: v2,
    };
    // Rule at src/isa/x64/inst.isle line 4073.
    return v3;
}

// Generated as internal constructor for term x64_rbp.
pub fn constructor_x64_rbp<C: Context>(
    ctx: &mut C,
) -> Reg {
    let v0 = C::preg_rbp(ctx);
    let v1 = constructor_mov_from_preg(ctx, v0);
    // Rule at src/isa/x64/inst.isle line 4086.
    return v1;
}

// Generated as internal constructor for term x64_rsp.
pub fn constructor_x64_rsp<C: Context>(
    ctx: &mut C,
) -> Reg {
    let v0 = C::preg_rsp(ctx);
    let v1 = constructor_mov_from_preg(ctx, v0);
    // Rule at src/isa/x64/inst.isle line 4090.
    return v1;
}

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

// Generated as internal constructor for term lower.
pub fn constructor_lower<C: Context>(
    ctx: &mut C,
    arg0: Inst,
) -> Option<InstOutput> {
    let v6 = &C::inst_data_value(ctx, arg0);
    match v6 {
        &InstructionData::AtomicCas {
            opcode: ref v2381,
            args: ref v2382,
            flags: v2383,
        } => {
            if let &Opcode::AtomicCas = v2381 {
                let v1 = C::first_result(ctx, arg0);
                if let Some(v2) = v1 {
                    let v3 = C::value_type(ctx, v2);
                    if v3 == I128 {
                        let v2347 = C::has_cmpxchg16b(ctx);
                        if v2347 == true {
                            let v2384 = C::unpack_value_array_3(ctx, v2382);
                            let v2397 = C::put_in_regs(ctx, v2384.1);
                            let v2398 = C::put_in_regs(ctx, v2384.2);
                            let v2392 = C::zero_offset(ctx);
                            let v2399 = &constructor_to_amode(ctx, v2383, v2384.0, v2392);
                            let v2400 = constructor_x64_cmpxchg16b(ctx, v2397, v2398, v2399);
                            let v2401 = C::output(ctx, v2400);
                            let v2402 = Some(v2401);
                            // Rule at src/isa/x64/lower.isle line 3459.
                            return v2402;
                        }
                    }
                    let v4 = C::fits_in_64(ctx, v3);
                    if let Some(v5) = v4 {
                        let v2339 = C::ty_int(ctx, v3);
                        if let Some(v2340) = v2339 {
                            let v2388 = C::little_or_native_endian(ctx, v2383);
                            if let Some(v2389) = v2388 {
                                let v2384 = C::unpack_value_array_3(ctx, v2382);
                                let v2390 = constructor_put_in_gpr(ctx, v2384.1);
                                let v2391 = constructor_put_in_gpr(ctx, v2384.2);
                                let v2392 = C::zero_offset(ctx);
                                let v2393 = &constructor_to_amode(ctx, v2389, v2384.0, v2392);
                                let v2394 = constructor_x64_cmpxchg(ctx, v5, v2390, v2391, v2393);
                                let v2395 = constructor_output_gpr(ctx, v2394);
                                let v2396 = Some(v2395);
                                // Rule at src/isa/x64/lower.isle line 3456.
                                return v2396;
                            }
                        }
                    }
                }
            }
        }
        &InstructionData::AtomicRmw {
            opcode: ref v2403,
            args: ref v2404,
            flags: v2405,
            op: ref v2406,
        } => {
            if let &Opcode::AtomicRmw = v2403 {
                let v1 = C::first_result(ctx, arg0);
                if let Some(v2) = v1 {
                    let v2410 = C::little_or_native_endian(ctx, v2405);
                    if let Some(v2411) = v2410 {
                        let v3 = C::value_type(ctx, v2);
                        if v3 == I128 {
                            let v2347 = C::has_cmpxchg16b(ctx);
                            if v2347 == true {
                                let v70 = C::zero_offset(ctx);
                                let v2407 = C::unpack_value_array_2(ctx, v2404);
                                let v2418 = &constructor_to_amode(ctx, v2411, v2407.0, v70);
                                let v2449 = C::put_in_regs(ctx, v2407.1);
                                let v2450 = constructor_x64_atomic_128_rmw_seq(ctx, v2406, v2418, v2449);
                                let v2451 = C::output(ctx, v2450);
                                let v2452 = Some(v2451);
                                // Rule at src/isa/x64/lower.isle line 3512.
                                return v2452;
                            }
                        }
                        let v4 = C::fits_in_64(ctx, v3);
                        if let Some(v5) = v4 {
                            match v2406 {
                                &AtomicRmwOp::Add => {
                                    let v2430 = C::ty_int(ctx, v5);
                                    if let Some(v2431) = v2430 {
                                        let v2432 = C::value_is_unused(ctx, v2);
                                        if v2432 == true {
                                            let v2433 = &C::raw_operand_size_of_type(ctx, v2431);
                                            let v2341 = C::zero_offset(ctx);
                                            let v2407 = C::unpack_value_array_2(ctx, v2404);
                                            let v2413 = &constructor_to_amode(ctx, v2411, v2407.0, v2341);
                                            let v2414 = constructor_put_in_gpr(ctx, v2407.1);
                                            let v2434 = &constructor_x64_lock_add(ctx, v2433, v2413, v2414);
                                            let v2435 = constructor_side_effect_as_invalid(ctx, v2434);
                                            let v2436 = Some(v2435);
                                            // Rule at src/isa/x64/lower.isle line 3485.
                                            return v2436;
                                        }
                                    }
                                    let v2339 = C::ty_int(ctx, v3);
                                    if let Some(v2340) = v2339 {
                                        let v70 = C::zero_offset(ctx);
                                        let v2407 = C::unpack_value_array_2(ctx, v2404);
                                        let v2418 = &constructor_to_amode(ctx, v2411, v2407.0, v70);
                                        let v2419 = constructor_put_in_gpr(ctx, v2407.1);
                                        let v2420 = constructor_x64_xadd(ctx, v5, v2418, v2419);
                                        let v2421 = constructor_output_gpr(ctx, v2420);
                                        let v2422 = Some(v2421);
                                        // Rule at src/isa/x64/lower.isle line 3472.
                                        return v2422;
                                    }
                                }
                                &AtomicRmwOp::And => {
                                    let v2430 = C::ty_int(ctx, v5);
                                    if let Some(v2431) = v2430 {
                                        let v2432 = C::value_is_unused(ctx, v2);
                                        if v2432 == true {
                                            let v2433 = &C::raw_operand_size_of_type(ctx, v2431);
                                            let v2341 = C::zero_offset(ctx);
                                            let v2407 = C::unpack_value_array_2(ctx, v2404);
                                            let v2413 = &constructor_to_amode(ctx, v2411, v2407.0, v2341);
                                            let v2414 = constructor_put_in_gpr(ctx, v2407.1);
                                            let v2440 = &constructor_x64_lock_and(ctx, v2433, v2413, v2414);
                                            let v2441 = constructor_side_effect_as_invalid(ctx, v2440);
                                            let v2442 = Some(v2441);
                                            // Rule at src/isa/x64/lower.isle line 3495.
                                            return v2442;
                                        }
                                    }
                                }
                                &AtomicRmwOp::Or => {
                                    let v2430 = C::ty_int(ctx, v5);
                                    if let Some(v2431) = v2430 {
                                        let v2432 = C::value_is_unused(ctx, v2);
                                        if v2432 == true {
                                            let v2433 = &C::raw_operand_size_of_type(ctx, v2431);
                                            let v2341 = C::zero_offset(ctx);
                                            let v2407 = C::unpack_value_array_2(ctx, v2404);
                                            let v2413 = &constructor_to_amode(ctx, v2411, v2407.0, v2341);
                                            let v2414 = constructor_put_in_gpr(ctx, v2407.1);
                                            let v2443 = &constructor_x64_lock_or(ctx, v2433, v2413, v2414);
                                            let v2444 = constructor_side_effect_as_invalid(ctx, v2443);
                                            let v2445 = Some(v2444);
                                            // Rule at src/isa/x64/lower.isle line 3500.
                                            return v2445;
                                        }
                                    }
                                }
                                &AtomicRmwOp::Sub => {
                                    let v2430 = C::ty_int(ctx, v5);
                                    if let Some(v2431) = v2430 {
                                        let v2432 = C::value_is_unused(ctx, v2);
                                        if v2432 == true {
                                            let v2433 = &C::raw_operand_size_of_type(ctx, v2431);
                                            let v2341 = C::zero_offset(ctx);
                                            let v2407 = C::unpack_value_array_2(ctx, v2404);
                                            let v2413 = &constructor_to_amode(ctx, v2411, v2407.0, v2341);
                                            let v2414 = constructor_put_in_gpr(ctx, v2407.1);
                                            let v2437 = &constructor_x64_lock_sub(ctx, v2433, v2413, v2414);
                                            let v2438 = constructor_side_effect_as_invalid(ctx, v2437);
                                            let v2439 = Some(v2438);
                                            // Rule at src/isa/x64/lower.isle line 3490.
                                            return v2439;
                                        }
                                    }
                                    let v2339 = C::ty_int(ctx, v3);
                                    if let Some(v2340) = v2339 {
                                        let v70 = C::zero_offset(ctx);
                                        let v2407 = C::unpack_value_array_2(ctx, v2404);
                                        let v2418 = &constructor_to_amode(ctx, v2411, v2407.0, v70);
                                        let v2419 = constructor_put_in_gpr(ctx, v2407.1);
                                        let v2423 = constructor_x64_neg(ctx, v5, v2419);
                                        let v2424 = constructor_x64_xadd(ctx, v5, v2418, v2423);
                                        let v2425 = constructor_output_gpr(ctx, v2424);
                                        let v2426 = Some(v2425);
                                        // Rule at src/isa/x64/lower.isle line 3475.
                                        return v2426;
                                    }
                                }
                                &AtomicRmwOp::Xchg => {
                                    let v2339 = C::ty_int(ctx, v3);
                                    if let Some(v2340) = v2339 {
                                        let v70 = C::zero_offset(ctx);
                                        let v2407 = C::unpack_value_array_2(ctx, v2404);
                                        let v2418 = &constructor_to_amode(ctx, v2411, v2407.0, v70);
                                        let v2419 = constructor_put_in_gpr(ctx, v2407.1);
                                        let v2427 = constructor_x64_xchg(ctx, v5, v2418, v2419);
                                        let v2428 = constructor_output_gpr(ctx, v2427);
                                        let v2429 = Some(v2428);
                                        // Rule at src/isa/x64/lower.isle line 3479.
                                        return v2429;
                                    }
                                }
                                &AtomicRmwOp::Xor => {
                                    let v2430 = C::ty_int(ctx, v5);
                                    if let Some(v2431) = v2430 {
                                        let v2432 = C::value_is_unused(ctx, v2);
                                        if v2432 == true {
                                            let v2433 = &C::raw_operand_size_of_type(ctx, v2431);
                                            let v2341 = C::zero_offset(ctx);
                                            let v2407 = C::unpack_value_array_2(ctx, v2404);
                                            let v2413 = &constructor_to_amode(ctx, v2411, v2407.0, v2341);
                                            let v2414 = constructor_put_in_gpr(ctx, v2407.1);
                                            let v2446 = &constructor_x64_lock_xor(ctx, v2433, v2413, v2414);
                                            let v2447 = constructor_side_effect_as_invalid(ctx, v2446);
                                            let v2448 = Some(v2447);
                                            // Rule at src/isa/x64/lower.isle line 3505.
                                            return v2448;
                                        }
                                    }
                                }
                                _ => {}
                            }
                            let v2339 = C::ty_int(ctx, v3);
                            if let Some(v2340) = v2339 {
                                let v2412 = &constructor_atomic_rmw_seq_op(ctx, v2406);
                                let v2341 = C::zero_offset(ctx);
                                let v2407 = C::unpack_value_array_2(ctx, v2404);
                                let v2413 = &constructor_to_amode(ctx, v2411, v2407.0, v2341);
                                let v2414 = constructor_put_in_gpr(ctx, v2407.1);
                                let v2415 = constructor_x64_atomic_rmw_seq(ctx, v5, v2412, v2413, v2414);
                                let v2416 = constructor_output_gpr(ctx, v2415);
                                let v2417 = Some(v2416);
                                // Rule at src/isa/x64/lower.isle line 3467.
                                return v2417;
                            }
                        }
                    }
                }
            }
        }
        &InstructionData::Binary {
            opcode: ref v57,
            args: ref v58,
        } => {
            match v57 {
                &Opcode::Swizzle => {
                    let v59 = C::unpack_value_array_2(ctx, v58);
                    let v1760 = constructor_put_in_xmm(ctx, v59.1);
                    let v3230 = C::emit_u128_le_const(ctx, 0x70707070707070707070707070707070_u128);
                    let v3231 = &constructor_const_to_xmm_mem(ctx, v3230);
                    let v3232 = constructor_x64_paddusb(ctx, v1760, v3231);
                    let v532 = constructor_put_in_xmm(ctx, v59.0);
                    let v3233 = C::xmm_to_reg(ctx, v3232);
                    let v3234 = &constructor_xmm_to_reg_mem(ctx, v3233);
                    let v3235 = &C::xmm_mem_to_reg_mem(ctx, v3234);
                    let v3236 = constructor_lower_pshufb(ctx, v532, v3235);
                    let v3237 = constructor_output_xmm(ctx, v3236);
                    let v3238 = Some(v3237);
                    // Rule at src/isa/x64/lower.isle line 4713.
                    return v3238;
                }
                &Opcode::X86Pshufb => {
                    let v772 = C::has_ssse3(ctx);
                    if v772 == true {
                        let v59 = C::unpack_value_array_2(ctx, v58);
                        let v93 = constructor_put_in_xmm(ctx, v59.0);
                        let v94 = &C::put_in_xmm_mem(ctx, v59.1);
                        let v3239 = constructor_x64_pshufb(ctx, v93, v94);
                        let v3240 = constructor_output_xmm(ctx, v3239);
                        let v3241 = Some(v3240);
                        // Rule at src/isa/x64/lower.isle line 4719.
                        return v3241;
                    }
                }
                &Opcode::Smin => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        let v1154 = C::ty_vec128(ctx, v3);
                        if let Some(v1155) = v1154 {
                            let v1159 = constructor_has_pmins(ctx, v1155);
                            if v1159 == true {
                                let v59 = C::unpack_value_array_2(ctx, v58);
                                let v93 = constructor_put_in_xmm(ctx, v59.0);
                                let v94 = &C::put_in_xmm_mem(ctx, v59.1);
                                let v1160 = constructor_x64_pmins(ctx, v1155, v93, v94);
                                let v1161 = constructor_output_xmm(ctx, v1160);
                                let v1162 = Some(v1161);
                                // Rule at src/isa/x64/lower.isle line 1819.
                                return v1162;
                            }
                            let v59 = C::unpack_value_array_2(ctx, v58);
                            let v93 = constructor_put_in_xmm(ctx, v59.0);
                            let v682 = constructor_put_in_xmm(ctx, v59.1);
                            let v501 = &C::xmm_to_xmm_mem(ctx, v93);
                            let v1163 = constructor_x64_pcmpgt(ctx, v1155, v682, v501);
                            let v503 = &C::xmm_to_xmm_mem(ctx, v93);
                            let v1164 = constructor_x64_pand(ctx, v1163, v503);
                            let v687 = &C::xmm_to_xmm_mem(ctx, v682);
                            let v1165 = constructor_x64_pandn(ctx, v1163, v687);
                            let v1166 = &C::xmm_to_xmm_mem(ctx, v1165);
                            let v1167 = constructor_x64_por(ctx, v1164, v1166);
                            let v1168 = constructor_output_xmm(ctx, v1167);
                            let v1169 = Some(v1168);
                            // Rule at src/isa/x64/lower.isle line 1823.
                            return v1169;
                        }
                        let v4 = C::fits_in_64(ctx, v3);
                        if let Some(v5) = v4 {
                            let v59 = C::unpack_value_array_2(ctx, v58);
                            let v1147 = constructor_cmp_and_choose(ctx, v5, &CC::L, v59.0, v59.1);
                            let v1148 = C::output(ctx, v1147);
                            let v1149 = Some(v1148);
                            // Rule at src/isa/x64/lower.isle line 1769.
                            return v1149;
                        }
                    }
                }
                &Opcode::Umin => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        let v1154 = C::ty_vec128(ctx, v3);
                        if let Some(v1155) = v1154 {
                            let v1194 = constructor_has_pminu(ctx, v1155);
                            if v1194 == true {
                                let v59 = C::unpack_value_array_2(ctx, v58);
                                let v93 = constructor_put_in_xmm(ctx, v59.0);
                                let v94 = &C::put_in_xmm_mem(ctx, v59.1);
                                let v1195 = constructor_x64_pminu(ctx, v1155, v93, v94);
                                let v1196 = constructor_output_xmm(ctx, v1195);
                                let v1197 = Some(v1196);
                                // Rule at src/isa/x64/lower.isle line 1871.
                                return v1197;
                            }
                        }
                        if v3 == I16X8 {
                            let v59 = C::unpack_value_array_2(ctx, v58);
                            let v93 = constructor_put_in_xmm(ctx, v59.0);
                            let v94 = &C::put_in_xmm_mem(ctx, v59.1);
                            let v254 = constructor_x64_psubusw(ctx, v93, v94);
                            let v1198 = &C::xmm_to_xmm_mem(ctx, v254);
                            let v1199 = constructor_x64_psubw(ctx, v93, v1198);
                            let v1200 = constructor_output_xmm(ctx, v1199);
                            let v1201 = Some(v1200);
                            // Rule at src/isa/x64/lower.isle line 1877.
                            return v1201;
                        }
                        if let Some(v1155) = v1154 {
                            let v59 = C::unpack_value_array_2(ctx, v58);
                            let v93 = constructor_put_in_xmm(ctx, v59.0);
                            let v682 = constructor_put_in_xmm(ctx, v59.1);
                            let v1179 = constructor_flip_high_bit_mask(ctx, v1155);
                            let v1180 = &C::xmm_to_xmm_mem(ctx, v1179);
                            let v1181 = constructor_x64_pxor(ctx, v93, v1180);
                            let v1182 = &C::xmm_to_xmm_mem(ctx, v1179);
                            let v1183 = constructor_x64_pxor(ctx, v682, v1182);
                            let v1202 = &C::xmm_to_xmm_mem(ctx, v1181);
                            let v1203 = constructor_x64_pcmpgt(ctx, v1155, v1183, v1202);
                            let v1186 = &C::xmm_to_xmm_mem(ctx, v93);
                            let v1204 = constructor_x64_pand(ctx, v1203, v1186);
                            let v1188 = &C::xmm_to_xmm_mem(ctx, v682);
                            let v1205 = constructor_x64_pandn(ctx, v1203, v1188);
                            let v1206 = &C::xmm_to_xmm_mem(ctx, v1205);
                            let v1207 = constructor_x64_por(ctx, v1204, v1206);
                            let v1208 = constructor_output_xmm(ctx, v1207);
                            let v1209 = Some(v1208);
                            // Rule at src/isa/x64/lower.isle line 1882.
                            return v1209;
                        }
                        let v4 = C::fits_in_64(ctx, v3);
                        if let Some(v5) = v4 {
                            let v59 = C::unpack_value_array_2(ctx, v58);
                            let v1139 = constructor_cmp_and_choose(ctx, v5, &CC::B, v59.0, v59.1);
                            let v1140 = C::output(ctx, v1139);
                            let v1141 = Some(v1140);
                            // Rule at src/isa/x64/lower.isle line 1763.
                            return v1141;
                        }
                    }
                }
                &Opcode::Smax => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        let v1154 = C::ty_vec128(ctx, v3);
                        if let Some(v1155) = v1154 {
                            let v59 = C::unpack_value_array_2(ctx, v58);
                            let v93 = constructor_put_in_xmm(ctx, v59.0);
                            let v682 = constructor_put_in_xmm(ctx, v59.1);
                            let v1156 = constructor_lower_vec_smax(ctx, v1155, v93, v682);
                            let v1157 = constructor_output_xmm(ctx, v1156);
                            let v1158 = Some(v1157);
                            // Rule at src/isa/x64/lower.isle line 1799.
                            return v1158;
                        }
                        let v4 = C::fits_in_64(ctx, v3);
                        if let Some(v5) = v4 {
                            let v59 = C::unpack_value_array_2(ctx, v58);
                            let v1151 = constructor_cmp_and_choose(ctx, v5, &CC::NL, v59.0, v59.1);
                            let v1152 = C::output(ctx, v1151);
                            let v1153 = Some(v1152);
                            // Rule at src/isa/x64/lower.isle line 1772.
                            return v1153;
                        }
                    }
                }
                &Opcode::Umax => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        let v1154 = C::ty_vec128(ctx, v3);
                        if let Some(v1155) = v1154 {
                            let v1170 = constructor_has_pmaxu(ctx, v1155);
                            if v1170 == true {
                                let v59 = C::unpack_value_array_2(ctx, v58);
                                let v93 = constructor_put_in_xmm(ctx, v59.0);
                                let v94 = &C::put_in_xmm_mem(ctx, v59.1);
                                let v1171 = constructor_x64_pmaxu(ctx, v1155, v93, v94);
                                let v1172 = constructor_output_xmm(ctx, v1171);
                                let v1173 = Some(v1172);
                                // Rule at src/isa/x64/lower.isle line 1835.
                                return v1173;
                            }
                        }
                        if v3 == I16X8 {
                            let v59 = C::unpack_value_array_2(ctx, v58);
                            let v93 = constructor_put_in_xmm(ctx, v59.0);
                            let v682 = constructor_put_in_xmm(ctx, v59.1);
                            let v501 = &C::xmm_to_xmm_mem(ctx, v93);
                            let v1174 = constructor_x64_psubusw(ctx, v682, v501);
                            let v1175 = &C::xmm_to_xmm_mem(ctx, v1174);
                            let v1176 = constructor_x64_paddw(ctx, v93, v1175);
                            let v1177 = constructor_output_xmm(ctx, v1176);
                            let v1178 = Some(v1177);
                            // Rule at src/isa/x64/lower.isle line 1841.
                            return v1178;
                        }
                        if let Some(v1155) = v1154 {
                            let v59 = C::unpack_value_array_2(ctx, v58);
                            let v93 = constructor_put_in_xmm(ctx, v59.0);
                            let v682 = constructor_put_in_xmm(ctx, v59.1);
                            let v1179 = constructor_flip_high_bit_mask(ctx, v1155);
                            let v1180 = &C::xmm_to_xmm_mem(ctx, v1179);
                            let v1181 = constructor_x64_pxor(ctx, v93, v1180);
                            let v1182 = &C::xmm_to_xmm_mem(ctx, v1179);
                            let v1183 = constructor_x64_pxor(ctx, v682, v1182);
                            let v1184 = &C::xmm_to_xmm_mem(ctx, v1183);
                            let v1185 = constructor_x64_pcmpgt(ctx, v1155, v1181, v1184);
                            let v1186 = &C::xmm_to_xmm_mem(ctx, v93);
                            let v1187 = constructor_x64_pand(ctx, v1185, v1186);
                            let v1188 = &C::xmm_to_xmm_mem(ctx, v682);
                            let v1189 = constructor_x64_pandn(ctx, v1185, v1188);
                            let v1190 = &C::xmm_to_xmm_mem(ctx, v1189);
                            let v1191 = constructor_x64_por(ctx, v1187, v1190);
                            let v1192 = constructor_output_xmm(ctx, v1191);
                            let v1193 = Some(v1192);
                            // Rule at src/isa/x64/lower.isle line 1848.
                            return v1193;
                        }
                        let v4 = C::fits_in_64(ctx, v3);
                        if let Some(v5) = v4 {
                            let v59 = C::unpack_value_array_2(ctx, v58);
                            let v1143 = constructor_cmp_and_choose(ctx, v5, &CC::NB, v59.0, v59.1);
                            let v1144 = C::output(ctx, v1143);
                            let v1145 = Some(v1144);
                            // Rule at src/isa/x64/lower.isle line 1766.
                            return v1145;
                        }
                    }
                }
                &Opcode::AvgRound => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        let v89 = C::multi_lane(ctx, v3);
                        if let Some(v90) = v89 {
                            match v90.0 {
                                0x8_u32 => {
                                    if v90.1 == 0x10_u32 {
                                        let v59 = C::unpack_value_array_2(ctx, v58);
                                        let v93 = constructor_put_in_xmm(ctx, v59.0);
                                        let v94 = &C::put_in_xmm_mem(ctx, v59.1);
                                        let v617 = constructor_x64_pavgb(ctx, v93, v94);
                                        let v618 = constructor_output_xmm(ctx, v617);
                                        let v619 = Some(v618);
                                        // Rule at src/isa/x64/lower.isle line 1026.
                                        return v619;
                                    }
                                }
                                0x10_u32 => {
                                    if v90.1 == 0x8_u32 {
                                        let v59 = C::unpack_value_array_2(ctx, v58);
                                        let v93 = constructor_put_in_xmm(ctx, v59.0);
                                        let v94 = &C::put_in_xmm_mem(ctx, v59.1);
                                        let v620 = constructor_x64_pavgw(ctx, v93, v94);
                                        let v621 = constructor_output_xmm(ctx, v620);
                                        let v622 = Some(v621);
                                        // Rule at src/isa/x64/lower.isle line 1030.
                                        return v622;
                                    }
                                }
                                _ => {}
                            }
                        }
                    }
                }
                &Opcode::UaddSat => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        let v89 = C::multi_lane(ctx, v3);
                        if let Some(v90) = v89 {
                            match v90.0 {
                                0x8_u32 => {
                                    if v90.1 == 0x10_u32 {
                                        let v59 = C::unpack_value_array_2(ctx, v58);
                                        let v93 = constructor_put_in_xmm(ctx, v59.0);
                                        let v94 = &C::put_in_xmm_mem(ctx, v59.1);
                                        let v215 = constructor_x64_paddusb(ctx, v93, v94);
                                        let v216 = constructor_output_xmm(ctx, v215);
                                        let v217 = Some(v216);
                                        // Rule at src/isa/x64/lower.isle line 234.
                                        return v217;
                                    }
                                }
                                0x10_u32 => {
                                    if v90.1 == 0x8_u32 {
                                        let v59 = C::unpack_value_array_2(ctx, v58);
                                        let v93 = constructor_put_in_xmm(ctx, v59.0);
                                        let v94 = &C::put_in_xmm_mem(ctx, v59.1);
                                        let v218 = constructor_x64_paddusw(ctx, v93, v94);
                                        let v219 = constructor_output_xmm(ctx, v218);
                                        let v220 = Some(v219);
                                        // Rule at src/isa/x64/lower.isle line 238.
                                        return v220;
                                    }
                                }
                                _ => {}
                            }
                        }
                    }
                }
                &Opcode::SaddSat => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        let v89 = C::multi_lane(ctx, v3);
                        if let Some(v90) = v89 {
                            match v90.0 {
                                0x8_u32 => {
                                    if v90.1 == 0x10_u32 {
                                        let v59 = C::unpack_value_array_2(ctx, v58);
                                        let v93 = constructor_put_in_xmm(ctx, v59.0);
                                        let v94 = &C::put_in_xmm_mem(ctx, v59.1);
                                        let v209 = constructor_x64_paddsb(ctx, v93, v94);
                                        let v210 = constructor_output_xmm(ctx, v209);
                                        let v211 = Some(v210);
                                        // Rule at src/isa/x64/lower.isle line 224.
                                        return v211;
                                    }
                                }
                                0x10_u32 => {
                                    if v90.1 == 0x8_u32 {
                                        let v59 = C::unpack_value_array_2(ctx, v58);
                                        let v93 = constructor_put_in_xmm(ctx, v59.0);
                                        let v94 = &C::put_in_xmm_mem(ctx, v59.1);
                                        let v212 = constructor_x64_paddsw(ctx, v93, v94);
                                        let v213 = constructor_output_xmm(ctx, v212);
                                        let v214 = Some(v213);
                                        // Rule at src/isa/x64/lower.isle line 228.
                                        return v214;
                                    }
                                }
                                _ => {}
                            }
                        }
                    }
                }
                &Opcode::UsubSat => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        let v89 = C::multi_lane(ctx, v3);
                        if let Some(v90) = v89 {
                            match v90.0 {
                                0x8_u32 => {
                                    if v90.1 == 0x10_u32 {
                                        let v59 = C::unpack_value_array_2(ctx, v58);
                                        let v93 = constructor_put_in_xmm(ctx, v59.0);
                                        let v94 = &C::put_in_xmm_mem(ctx, v59.1);
                                        let v251 = constructor_x64_psubusb(ctx, v93, v94);
                                        let v252 = constructor_output_xmm(ctx, v251);
                                        let v253 = Some(v252);
                                        // Rule at src/isa/x64/lower.isle line 307.
                                        return v253;
                                    }
                                }
                                0x10_u32 => {
                                    if v90.1 == 0x8_u32 {
                                        let v59 = C::unpack_value_array_2(ctx, v58);
                                        let v93 = constructor_put_in_xmm(ctx, v59.0);
                                        let v94 = &C::put_in_xmm_mem(ctx, v59.1);
                                        let v254 = constructor_x64_psubusw(ctx, v93, v94);
                                        let v255 = constructor_output_xmm(ctx, v254);
                                        let v256 = Some(v255);
                                        // Rule at src/isa/x64/lower.isle line 311.
                                        return v256;
                                    }
                                }
                                _ => {}
                            }
                        }
                    }
                }
                &Opcode::SsubSat => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        let v89 = C::multi_lane(ctx, v3);
                        if let Some(v90) = v89 {
                            match v90.0 {
                                0x8_u32 => {
                                    if v90.1 == 0x10_u32 {
                                        let v59 = C::unpack_value_array_2(ctx, v58);
                                        let v93 = constructor_put_in_xmm(ctx, v59.0);
                                        let v94 = &C::put_in_xmm_mem(ctx, v59.1);
                                        let v245 = constructor_x64_psubsb(ctx, v93, v94);
                                        let v246 = constructor_output_xmm(ctx, v245);
                                        let v247 = Some(v246);
                                        // Rule at src/isa/x64/lower.isle line 297.
                                        return v247;
                                    }
                                }
                                0x10_u32 => {
                                    if v90.1 == 0x8_u32 {
                                        let v59 = C::unpack_value_array_2(ctx, v58);
                                        let v93 = constructor_put_in_xmm(ctx, v59.0);
                                        let v94 = &C::put_in_xmm_mem(ctx, v59.1);
                                        let v248 = constructor_x64_psubsw(ctx, v93, v94);
                                        let v249 = constructor_output_xmm(ctx, v248);
                                        let v250 = Some(v249);
                                        // Rule at src/isa/x64/lower.isle line 301.
                                        return v250;
                                    }
                                }
                                _ => {}
                            }
                        }
                    }
                }
                &Opcode::Iadd => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        if v3 == I128 {
                            let v59 = C::unpack_value_array_2(ctx, v58);
                            let v120 = C::def_inst(ctx, v59.1);
                            if let Some(v121) = v120 {
                                let v122 = &C::inst_data_value(ctx, v121);
                                match v122 {
                                    &InstructionData::Binary {
                                        opcode: ref v123,
                                        args: ref v124,
                                    } => {
                                        if let &Opcode::Iconcat = v123 {
                                            let v107 = C::put_in_regs(ctx, v59.0);
                                            let v128 = C::put_in_regs(ctx, v59.0);
                                            let v129 = constructor_value_regs_get_gpr(ctx, v128, 0x0_usize);
                                            let v130 = C::put_in_regs(ctx, v59.0);
                                            let v131 = constructor_value_regs_get_gpr(ctx, v130, 0x1_usize);
                                            let v125 = C::unpack_value_array_2(ctx, v124);
                                            let v132 = &constructor_put_in_gpr_mem_imm(ctx, v125.0);
                                            let v133 = &constructor_put_in_gpr_mem_imm(ctx, v125.1);
                                            let v134 = constructor_iadd128(ctx, v129, v131, v132, v133);
                                            let v135 = C::output(ctx, v134);
                                            let v136 = Some(v135);
                                            // Rule at src/isa/x64/lower.isle line 106.
                                            return v136;
                                        }
                                    }
                                    &InstructionData::Unary {
                                        opcode: ref v137,
                                        arg: v138,
                                    } => {
                                        if let &Opcode::Uextend = v137 {
                                            let v139 = C::value_type(ctx, v138);
                                            if v139 == I64 {
                                                let v147 = C::def_inst(ctx, v59.0);
                                                if let Some(v148) = v147 {
                                                    let v149 = &C::inst_data_value(ctx, v148);
                                                    if let &InstructionData::Unary {
                                                        opcode: ref v150,
                                                        arg: v151,
                                                    } = v149 {
                                                        if let &Opcode::Uextend = v150 {
                                                            let v153 = constructor_extend_to_gpr(ctx, v151, I64, &ExtendKind::Zero);
                                                            let v154 = &constructor_put_in_gpr_mem_imm(ctx, v138);
                                                            let v155 = &constructor_x64_add_with_flags_paired(ctx, I64, v153, v154);
                                                            let v157 = &constructor_x64_setcc_paired(ctx, &CC::B);
                                                            let v158 = constructor_with_flags(ctx, v155, v157);
                                                            let v159 = C::value_regs_get(ctx, v158, 0x0_usize);
                                                            let v161 = C::value_regs_get(ctx, v158, 0x1_usize);
                                                            let v162 = &C::reg_to_gpr_mem(ctx, v161);
                                                            let v163 = constructor_x64_movzx(ctx, &ExtMode::BQ, v162);
                                                            let v164 = C::gpr_to_reg(ctx, v163);
                                                            let v165 = C::value_regs(ctx, v159, v164);
                                                            let v166 = C::output(ctx, v165);
                                                            let v167 = Some(v166);
                                                            // Rule at src/isa/x64/lower.isle line 117.
                                                            return v167;
                                                        }
                                                    }
                                                }
                                                let v107 = C::put_in_regs(ctx, v59.0);
                                                let v128 = C::put_in_regs(ctx, v59.0);
                                                let v129 = constructor_value_regs_get_gpr(ctx, v128, 0x0_usize);
                                                let v130 = C::put_in_regs(ctx, v59.0);
                                                let v131 = constructor_value_regs_get_gpr(ctx, v130, 0x1_usize);
                                                let v140 = &constructor_put_in_gpr_mem_imm(ctx, v138);
                                                let v142 = RegMemImm::Imm {
                                                    simm32: 0x0_u32,
                                                };
                                                let v143 = &C::gpr_mem_imm_new(ctx, &v142);
                                                let v144 = constructor_iadd128(ctx, v129, v131, v140, v143);
                                                let v145 = C::output(ctx, v144);
                                                let v146 = Some(v145);
                                                // Rule at src/isa/x64/lower.isle line 109.
                                                return v146;
                                            }
                                        }
                                    }
                                    _ => {}
                                }
                            }
                            let v107 = C::put_in_regs(ctx, v59.0);
                            let v108 = C::put_in_regs(ctx, v59.1);
                            let v110 = constructor_value_regs_get_gpr(ctx, v107, 0x0_usize);
                            let v112 = constructor_value_regs_get_gpr(ctx, v107, 0x1_usize);
                            let v113 = constructor_value_regs_get_gpr(ctx, v108, 0x0_usize);
                            let v114 = &C::gpr_to_gpr_mem_imm(ctx, v113);
                            let v115 = constructor_value_regs_get_gpr(ctx, v108, 0x1_usize);
                            let v116 = &C::gpr_to_gpr_mem_imm(ctx, v115);
                            let v117 = constructor_iadd128(ctx, v110, v112, v114, v116);
                            let v118 = C::output(ctx, v117);
                            let v119 = Some(v118);
                            // Rule at src/isa/x64/lower.isle line 97.
                            return v119;
                        }
                        let v89 = C::multi_lane(ctx, v3);
                        if let Some(v90) = v89 {
                            match v90.0 {
                                0x8_u32 => {
                                    if v90.1 == 0x10_u32 {
                                        let v59 = C::unpack_value_array_2(ctx, v58);
                                        let v93 = constructor_put_in_xmm(ctx, v59.0);
                                        let v94 = &C::put_in_xmm_mem(ctx, v59.1);
                                        let v95 = constructor_x64_paddb(ctx, v93, v94);
                                        let v96 = constructor_output_xmm(ctx, v95);
                                        let v97 = Some(v96);
                                        // Rule at src/isa/x64/lower.isle line 80.
                                        return v97;
                                    }
                                }
                                0x10_u32 => {
                                    if v90.1 == 0x8_u32 {
                                        let v59 = C::unpack_value_array_2(ctx, v58);
                                        let v93 = constructor_put_in_xmm(ctx, v59.0);
                                        let v94 = &C::put_in_xmm_mem(ctx, v59.1);
                                        let v98 = constructor_x64_paddw(ctx, v93, v94);
                                        let v99 = constructor_output_xmm(ctx, v98);
                                        let v100 = Some(v99);
                                        // Rule at src/isa/x64/lower.isle line 84.
                                        return v100;
                                    }
                                }
                                0x20_u32 => {
                                    if v90.1 == 0x4_u32 {
                                        let v59 = C::unpack_value_array_2(ctx, v58);
                                        let v93 = constructor_put_in_xmm(ctx, v59.0);
                                        let v94 = &C::put_in_xmm_mem(ctx, v59.1);
                                        let v101 = constructor_x64_paddd(ctx, v93, v94);
                                        let v102 = constructor_output_xmm(ctx, v101);
                                        let v103 = Some(v102);
                                        // Rule at src/isa/x64/lower.isle line 88.
                                        return v103;
                                    }
                                }
                                0x40_u32 => {
                                    if v90.1 == 0x2_u32 {
                                        let v59 = C::unpack_value_array_2(ctx, v58);
                                        let v93 = constructor_put_in_xmm(ctx, v59.0);
                                        let v94 = &C::put_in_xmm_mem(ctx, v59.1);
                                        let v104 = constructor_x64_paddq(ctx, v93, v94);
                                        let v105 = constructor_output_xmm(ctx, v104);
                                        let v106 = Some(v105);
                                        // Rule at src/isa/x64/lower.isle line 92.
                                        return v106;
                                    }
                                }
                                _ => {}
                            }
                        }
                        let v4 = C::fits_in_64(ctx, v3);
                        if let Some(v5) = v4 {
                            let v59 = C::unpack_value_array_2(ctx, v58);
                            let v82 = &C::sinkable_load(ctx, v59.0);
                            if let Some(v83) = v82 {
                                let v84 = constructor_put_in_gpr(ctx, v59.1);
                                let v85 = &constructor_sink_load_to_gpr_mem_imm(ctx, v83);
                                let v86 = constructor_x64_add(ctx, v5, v84, v85);
                                let v87 = constructor_output_gpr(ctx, v86);
                                let v88 = Some(v87);
                                // Rule at src/isa/x64/lower.isle line 74.
                                return v88;
                            }
                            let v76 = &C::sinkable_load(ctx, v59.1);
                            if let Some(v77) = v76 {
                                let v62 = constructor_put_in_gpr(ctx, v59.0);
                                let v78 = &constructor_sink_load_to_gpr_mem_imm(ctx, v77);
                                let v79 = constructor_x64_add(ctx, v5, v62, v78);
                                let v80 = constructor_output_gpr(ctx, v79);
                                let v81 = Some(v80);
                                // Rule at src/isa/x64/lower.isle line 71.
                                return v81;
                            }
                        }
                        let v67 = C::ty_32_or_64(ctx, v3);
                        if let Some(v68) = v67 {
                            let v70 = C::zero_offset(ctx);
                            let v69 = C::mem_flags_trusted(ctx);
                            let v59 = C::unpack_value_array_2(ctx, v58);
                            let v71 = &constructor_to_amode_add(ctx, v69, v59.0, v59.1, v70);
                            let v72 = &C::amode_to_synthetic_amode(ctx, v71);
                            let v73 = constructor_x64_lea(ctx, v68, v72);
                            let v74 = constructor_output_gpr(ctx, v73);
                            let v75 = Some(v74);
                            // Rule at src/isa/x64/lower.isle line 65.
                            return v75;
                        }
                        let v55 = C::fits_in_16(ctx, v3);
                        if let Some(v56) = v55 {
                            let v59 = C::unpack_value_array_2(ctx, v58);
                            let v62 = constructor_put_in_gpr(ctx, v59.0);
                            let v63 = &constructor_put_in_gpr_mem_imm(ctx, v59.1);
                            let v64 = constructor_x64_add(ctx, v56, v62, v63);
                            let v65 = constructor_output_gpr(ctx, v64);
                            let v66 = Some(v65);
                            // Rule at src/isa/x64/lower.isle line 54.
                            return v66;
                        }
                    }
                }
                &Opcode::Isub => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        if v3 == I128 {
                            let v59 = C::unpack_value_array_2(ctx, v58);
                            let v120 = C::def_inst(ctx, v59.1);
                            if let Some(v121) = v120 {
                                let v122 = &C::inst_data_value(ctx, v121);
                                match v122 {
                                    &InstructionData::Binary {
                                        opcode: ref v123,
                                        args: ref v124,
                                    } => {
                                        if let &Opcode::Iconcat = v123 {
                                            let v107 = C::put_in_regs(ctx, v59.0);
                                            let v128 = C::put_in_regs(ctx, v59.0);
                                            let v129 = constructor_value_regs_get_gpr(ctx, v128, 0x0_usize);
                                            let v130 = C::put_in_regs(ctx, v59.0);
                                            let v131 = constructor_value_regs_get_gpr(ctx, v130, 0x1_usize);
                                            let v125 = C::unpack_value_array_2(ctx, v124);
                                            let v132 = &constructor_put_in_gpr_mem_imm(ctx, v125.0);
                                            let v133 = &constructor_put_in_gpr_mem_imm(ctx, v125.1);
                                            let v239 = constructor_isub128(ctx, v129, v131, v132, v133);
                                            let v240 = C::output(ctx, v239);
                                            let v241 = Some(v240);
                                            // Rule at src/isa/x64/lower.isle line 279.
                                            return v241;
                                        }
                                    }
                                    &InstructionData::Unary {
                                        opcode: ref v137,
                                        arg: v138,
                                    } => {
                                        if let &Opcode::Uextend = v137 {
                                            let v139 = C::value_type(ctx, v138);
                                            if v139 == I64 {
                                                let v107 = C::put_in_regs(ctx, v59.0);
                                                let v128 = C::put_in_regs(ctx, v59.0);
                                                let v129 = constructor_value_regs_get_gpr(ctx, v128, 0x0_usize);
                                                let v130 = C::put_in_regs(ctx, v59.0);
                                                let v131 = constructor_value_regs_get_gpr(ctx, v130, 0x1_usize);
                                                let v140 = &constructor_put_in_gpr_mem_imm(ctx, v138);
                                                let v142 = RegMemImm::Imm {
                                                    simm32: 0x0_u32,
                                                };
                                                let v143 = &C::gpr_mem_imm_new(ctx, &v142);
                                                let v242 = constructor_isub128(ctx, v129, v131, v140, v143);
                                                let v243 = C::output(ctx, v242);
                                                let v244 = Some(v243);
                                                // Rule at src/isa/x64/lower.isle line 282.
                                                return v244;
                                            }
                                        }
                                    }
                                    _ => {}
                                }
                            }
                            let v107 = C::put_in_regs(ctx, v59.0);
                            let v108 = C::put_in_regs(ctx, v59.1);
                            let v110 = constructor_value_regs_get_gpr(ctx, v107, 0x0_usize);
                            let v112 = constructor_value_regs_get_gpr(ctx, v107, 0x1_usize);
                            let v113 = constructor_value_regs_get_gpr(ctx, v108, 0x0_usize);
                            let v114 = &C::gpr_to_gpr_mem_imm(ctx, v113);
                            let v115 = constructor_value_regs_get_gpr(ctx, v108, 0x1_usize);
                            let v116 = &C::gpr_to_gpr_mem_imm(ctx, v115);
                            let v236 = constructor_isub128(ctx, v110, v112, v114, v116);
                            let v237 = C::output(ctx, v236);
                            let v238 = Some(v237);
                            // Rule at src/isa/x64/lower.isle line 270.
                            return v238;
                        }
                        let v89 = C::multi_lane(ctx, v3);
                        if let Some(v90) = v89 {
                            match v90.0 {
                                0x8_u32 => {
                                    if v90.1 == 0x10_u32 {
                                        let v59 = C::unpack_value_array_2(ctx, v58);
                                        let v93 = constructor_put_in_xmm(ctx, v59.0);
                                        let v94 = &C::put_in_xmm_mem(ctx, v59.1);
                                        let v224 = constructor_x64_psubb(ctx, v93, v94);
                                        let v225 = constructor_output_xmm(ctx, v224);
                                        let v226 = Some(v225);
                                        // Rule at src/isa/x64/lower.isle line 253.
                                        return v226;
                                    }
                                }
                                0x10_u32 => {
                                    if v90.1 == 0x8_u32 {
                                        let v59 = C::unpack_value_array_2(ctx, v58);
                                        let v93 = constructor_put_in_xmm(ctx, v59.0);
                                        let v94 = &C::put_in_xmm_mem(ctx, v59.1);
                                        let v227 = constructor_x64_psubw(ctx, v93, v94);
                                        let v228 = constructor_output_xmm(ctx, v227);
                                        let v229 = Some(v228);
                                        // Rule at src/isa/x64/lower.isle line 257.
                                        return v229;
                                    }
                                }
                                0x20_u32 => {
                                    if v90.1 == 0x4_u32 {
                                        let v59 = C::unpack_value_array_2(ctx, v58);
                                        let v93 = constructor_put_in_xmm(ctx, v59.0);
                                        let v94 = &C::put_in_xmm_mem(ctx, v59.1);
                                        let v230 = constructor_x64_psubd(ctx, v93, v94);
                                        let v231 = constructor_output_xmm(ctx, v230);
                                        let v232 = Some(v231);
                                        // Rule at src/isa/x64/lower.isle line 261.
                                        return v232;
                                    }
                                }
                                0x40_u32 => {
                                    if v90.1 == 0x2_u32 {
                                        let v59 = C::unpack_value_array_2(ctx, v58);
                                        let v93 = constructor_put_in_xmm(ctx, v59.0);
                                        let v94 = &C::put_in_xmm_mem(ctx, v59.1);
                                        let v233 = constructor_x64_psubq(ctx, v93, v94);
                                        let v234 = constructor_output_xmm(ctx, v233);
                                        let v235 = Some(v234);
                                        // Rule at src/isa/x64/lower.isle line 265.
                                        return v235;
                                    }
                                }
                                _ => {}
                            }
                        }
                        let v4 = C::fits_in_64(ctx, v3);
                        if let Some(v5) = v4 {
                            let v59 = C::unpack_value_array_2(ctx, v58);
                            let v62 = constructor_put_in_gpr(ctx, v59.0);
                            let v63 = &constructor_put_in_gpr_mem_imm(ctx, v59.1);
                            let v221 = constructor_x64_sub(ctx, v5, v62, v63);
                            let v222 = constructor_output_gpr(ctx, v221);
                            let v223 = Some(v222);
                            // Rule at src/isa/x64/lower.isle line 247.
                            return v223;
                        }
                    }
                }
                &Opcode::Imul => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        if v3 == I128 {
                            let v59 = C::unpack_value_array_2(ctx, v58);
                            let v120 = C::def_inst(ctx, v59.1);
                            if let Some(v121) = v120 {
                                let v122 = &C::inst_data_value(ctx, v121);
                                match v122 {
                                    &InstructionData::Binary {
                                        opcode: ref v123,
                                        args: ref v124,
                                    } => {
                                        if let &Opcode::Iconcat = v123 {
                                            let v147 = C::def_inst(ctx, v59.0);
                                            if let Some(v148) = v147 {
                                                let v149 = &C::inst_data_value(ctx, v148);
                                                if let &InstructionData::Binary {
                                                    opcode: ref v365,
                                                    args: ref v366,
                                                } = v149 {
                                                    if let &Opcode::Iconcat = v365 {
                                                        let v367 = C::unpack_value_array_2(ctx, v366);
                                                        let v394 = constructor_put_in_gpr(ctx, v367.0);
                                                        let v662 = constructor_put_in_gpr(ctx, v367.1);
                                                        let v125 = C::unpack_value_array_2(ctx, v124);
                                                        let v663 = &constructor_put_in_gpr_mem(ctx, v125.0);
                                                        let v664 = &constructor_put_in_gpr_mem(ctx, v125.1);
                                                        let v665 = constructor_imul128(ctx, v394, v662, v663, v664);
                                                        let v666 = C::output(ctx, v665);
                                                        let v667 = Some(v666);
                                                        // Rule at src/isa/x64/lower.isle line 1074.
                                                        return v667;
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    &InstructionData::Unary {
                                        opcode: ref v137,
                                        arg: v138,
                                    } => {
                                        match v137 {
                                            &Opcode::Uextend => {
                                                let v139 = C::value_type(ctx, v138);
                                                if v139 == I64 {
                                                    let v147 = C::def_inst(ctx, v59.0);
                                                    if let Some(v148) = v147 {
                                                        let v149 = &C::inst_data_value(ctx, v148);
                                                        if let &InstructionData::Unary {
                                                            opcode: ref v150,
                                                            arg: v151,
                                                        } = v149 {
                                                            if let &Opcode::Uextend = v150 {
                                                                let v668 = C::value_type(ctx, v151);
                                                                if v668 == I64 {
                                                                    let v296 = constructor_put_in_gpr(ctx, v151);
                                                                    let v650 = &constructor_put_in_gpr_mem(ctx, v138);
                                                                    let v192 = false;
                                                                    let v669 = constructor_x64_mul(ctx, I64, v192, v296, v650);
                                                                    let v670 = C::output(ctx, v669);
                                                                    let v671 = Some(v670);
                                                                    // Rule at src/isa/x64/lower.isle line 1116.
                                                                    return v671;
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                            &Opcode::Sextend => {
                                                let v139 = C::value_type(ctx, v138);
                                                if v139 == I64 {
                                                    let v147 = C::def_inst(ctx, v59.0);
                                                    if let Some(v148) = v147 {
                                                        let v149 = &C::inst_data_value(ctx, v148);
                                                        if let &InstructionData::Unary {
                                                            opcode: ref v150,
                                                            arg: v151,
                                                        } = v149 {
                                                            if let &Opcode::Sextend = v150 {
                                                                let v668 = C::value_type(ctx, v151);
                                                                if v668 == I64 {
                                                                    let v296 = constructor_put_in_gpr(ctx, v151);
                                                                    let v650 = &constructor_put_in_gpr_mem(ctx, v138);
                                                                    let v202 = true;
                                                                    let v672 = constructor_x64_mul(ctx, I64, v202, v296, v650);
                                                                    let v673 = C::output(ctx, v672);
                                                                    let v674 = Some(v673);
                                                                    // Rule at src/isa/x64/lower.isle line 1119.
                                                                    return v674;
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                            _ => {}
                                        }
                                    }
                                    _ => {}
                                }
                            }
                        }
                        let v89 = C::multi_lane(ctx, v3);
                        if let Some(v90) = v89 {
                            if v90.0 == 0x40_u32 {
                                if v90.1 == 0x2_u32 {
                                    let v520 = C::has_avx512vl(ctx);
                                    if v520 == true {
                                        let v700 = C::has_avx512dq(ctx);
                                        if v700 == true {
                                            let v59 = C::unpack_value_array_2(ctx, v58);
                                            let v93 = constructor_put_in_xmm(ctx, v59.0);
                                            let v94 = &C::put_in_xmm_mem(ctx, v59.1);
                                            let v701 = constructor_x64_vpmullq(ctx, v93, v94);
                                            let v702 = constructor_output_xmm(ctx, v701);
                                            let v703 = Some(v702);
                                            // Rule at src/isa/x64/lower.isle line 1150.
                                            return v703;
                                        }
                                    }
                                }
                            }
                        }
                        if v3 == I128 {
                            let v59 = C::unpack_value_array_2(ctx, v58);
                            let v107 = C::put_in_regs(ctx, v59.0);
                            let v108 = C::put_in_regs(ctx, v59.1);
                            let v110 = constructor_value_regs_get_gpr(ctx, v107, 0x0_usize);
                            let v112 = constructor_value_regs_get_gpr(ctx, v107, 0x1_usize);
                            let v113 = constructor_value_regs_get_gpr(ctx, v108, 0x0_usize);
                            let v657 = &C::gpr_to_gpr_mem(ctx, v113);
                            let v115 = constructor_value_regs_get_gpr(ctx, v108, 0x1_usize);
                            let v658 = &C::gpr_to_gpr_mem(ctx, v115);
                            let v659 = constructor_imul128(ctx, v110, v112, v657, v658);
                            let v660 = C::output(ctx, v659);
                            let v661 = Some(v660);
                            // Rule at src/isa/x64/lower.isle line 1065.
                            return v661;
                        }
                        if let Some(v90) = v89 {
                            match v90.0 {
                                0x10_u32 => {
                                    if v90.1 == 0x8_u32 {
                                        let v59 = C::unpack_value_array_2(ctx, v58);
                                        let v93 = constructor_put_in_xmm(ctx, v59.0);
                                        let v94 = &C::put_in_xmm_mem(ctx, v59.1);
                                        let v675 = constructor_x64_pmullw(ctx, v93, v94);
                                        let v676 = constructor_output_xmm(ctx, v675);
                                        let v677 = Some(v676);
                                        // Rule at src/isa/x64/lower.isle line 1127.
                                        return v677;
                                    }
                                }
                                0x20_u32 => {
                                    if v90.1 == 0x4_u32 {
                                        let v59 = C::unpack_value_array_2(ctx, v58);
                                        let v120 = C::def_inst(ctx, v59.1);
                                        if let Some(v121) = v120 {
                                            let v122 = &C::inst_data_value(ctx, v121);
                                            if let &InstructionData::Unary {
                                                opcode: ref v137,
                                                arg: v138,
                                            } = v122 {
                                                match v137 {
                                                    &Opcode::SwidenLow => {
                                                        let v147 = C::def_inst(ctx, v59.0);
                                                        if let Some(v148) = v147 {
                                                            let v149 = &C::inst_data_value(ctx, v148);
                                                            if let &InstructionData::Unary {
                                                                opcode: ref v150,
                                                                arg: v151,
                                                            } = v149 {
                                                                if let &Opcode::SwidenLow = v150 {
                                                                    let v668 = C::value_type(ctx, v151);
                                                                    let v722 = C::multi_lane(ctx, v668);
                                                                    if let Some(v723) = v722 {
                                                                        if v723.0 == 0x10_u32 {
                                                                            if v723.1 == 0x8_u32 {
                                                                                let v139 = C::value_type(ctx, v138);
                                                                                let v726 = C::multi_lane(ctx, v139);
                                                                                if let Some(v727) = v726 {
                                                                                    if v727.0 == 0x10_u32 {
                                                                                        if v727.1 == 0x8_u32 {
                                                                                            let v286 = constructor_put_in_xmm(ctx, v151);
                                                                                            let v730 = constructor_put_in_xmm(ctx, v138);
                                                                                            let v731 = &C::xmm_to_xmm_mem(ctx, v730);
                                                                                            let v732 = constructor_x64_pmullw(ctx, v286, v731);
                                                                                            let v733 = &C::xmm_to_xmm_mem(ctx, v730);
                                                                                            let v734 = constructor_x64_pmulhw(ctx, v286, v733);
                                                                                            let v735 = &C::xmm_to_xmm_mem(ctx, v734);
                                                                                            let v748 = constructor_x64_punpcklwd(ctx, v732, v735);
                                                                                            let v749 = constructor_output_xmm(ctx, v748);
                                                                                            let v750 = Some(v749);
                                                                                            // Rule at src/isa/x64/lower.isle line 1220.
                                                                                            return v750;
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                    &Opcode::SwidenHigh => {
                                                        let v147 = C::def_inst(ctx, v59.0);
                                                        if let Some(v148) = v147 {
                                                            let v149 = &C::inst_data_value(ctx, v148);
                                                            if let &InstructionData::Unary {
                                                                opcode: ref v150,
                                                                arg: v151,
                                                            } = v149 {
                                                                if let &Opcode::SwidenHigh = v150 {
                                                                    let v668 = C::value_type(ctx, v151);
                                                                    let v722 = C::multi_lane(ctx, v668);
                                                                    if let Some(v723) = v722 {
                                                                        if v723.0 == 0x10_u32 {
                                                                            if v723.1 == 0x8_u32 {
                                                                                let v139 = C::value_type(ctx, v138);
                                                                                let v726 = C::multi_lane(ctx, v139);
                                                                                if let Some(v727) = v726 {
                                                                                    if v727.0 == 0x10_u32 {
                                                                                        if v727.1 == 0x8_u32 {
                                                                                            let v286 = constructor_put_in_xmm(ctx, v151);
                                                                                            let v730 = constructor_put_in_xmm(ctx, v138);
                                                                                            let v731 = &C::xmm_to_xmm_mem(ctx, v730);
                                                                                            let v732 = constructor_x64_pmullw(ctx, v286, v731);
                                                                                            let v733 = &C::xmm_to_xmm_mem(ctx, v730);
                                                                                            let v734 = constructor_x64_pmulhw(ctx, v286, v733);
                                                                                            let v735 = &C::xmm_to_xmm_mem(ctx, v734);
                                                                                            let v736 = constructor_x64_punpckhwd(ctx, v732, v735);
                                                                                            let v737 = constructor_output_xmm(ctx, v736);
                                                                                            let v738 = Some(v737);
                                                                                            // Rule at src/isa/x64/lower.isle line 1197.
                                                                                            return v738;
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                    &Opcode::UwidenLow => {
                                                        let v147 = C::def_inst(ctx, v59.0);
                                                        if let Some(v148) = v147 {
                                                            let v149 = &C::inst_data_value(ctx, v148);
                                                            if let &InstructionData::Unary {
                                                                opcode: ref v150,
                                                                arg: v151,
                                                            } = v149 {
                                                                if let &Opcode::UwidenLow = v150 {
                                                                    let v668 = C::value_type(ctx, v151);
                                                                    let v722 = C::multi_lane(ctx, v668);
                                                                    if let Some(v723) = v722 {
                                                                        if v723.0 == 0x10_u32 {
                                                                            if v723.1 == 0x8_u32 {
                                                                                let v139 = C::value_type(ctx, v138);
                                                                                let v726 = C::multi_lane(ctx, v139);
                                                                                if let Some(v727) = v726 {
                                                                                    if v727.0 == 0x10_u32 {
                                                                                        if v727.1 == 0x8_u32 {
                                                                                            let v286 = constructor_put_in_xmm(ctx, v151);
                                                                                            let v730 = constructor_put_in_xmm(ctx, v138);
                                                                                            let v731 = &C::xmm_to_xmm_mem(ctx, v730);
                                                                                            let v732 = constructor_x64_pmullw(ctx, v286, v731);
                                                                                            let v733 = &C::xmm_to_xmm_mem(ctx, v730);
                                                                                            let v758 = constructor_x64_pmulhuw(ctx, v286, v733);
                                                                                            let v759 = &C::xmm_to_xmm_mem(ctx, v758);
                                                                                            let v766 = constructor_x64_punpcklwd(ctx, v732, v759);
                                                                                            let v767 = constructor_output_xmm(ctx, v766);
                                                                                            let v768 = Some(v767);
                                                                                            // Rule at src/isa/x64/lower.isle line 1265.
                                                                                            return v768;
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                    &Opcode::UwidenHigh => {
                                                        let v147 = C::def_inst(ctx, v59.0);
                                                        if let Some(v148) = v147 {
                                                            let v149 = &C::inst_data_value(ctx, v148);
                                                            if let &InstructionData::Unary {
                                                                opcode: ref v150,
                                                                arg: v151,
                                                            } = v149 {
                                                                if let &Opcode::UwidenHigh = v150 {
                                                                    let v668 = C::value_type(ctx, v151);
                                                                    let v722 = C::multi_lane(ctx, v668);
                                                                    if let Some(v723) = v722 {
                                                                        if v723.0 == 0x10_u32 {
                                                                            if v723.1 == 0x8_u32 {
                                                                                let v139 = C::value_type(ctx, v138);
                                                                                let v726 = C::multi_lane(ctx, v139);
                                                                                if let Some(v727) = v726 {
                                                                                    if v727.0 == 0x10_u32 {
                                                                                        if v727.1 == 0x8_u32 {
                                                                                            let v286 = constructor_put_in_xmm(ctx, v151);
                                                                                            let v730 = constructor_put_in_xmm(ctx, v138);
                                                                                            let v731 = &C::xmm_to_xmm_mem(ctx, v730);
                                                                                            let v732 = constructor_x64_pmullw(ctx, v286, v731);
                                                                                            let v733 = &C::xmm_to_xmm_mem(ctx, v730);
                                                                                            let v758 = constructor_x64_pmulhuw(ctx, v286, v733);
                                                                                            let v759 = &C::xmm_to_xmm_mem(ctx, v758);
                                                                                            let v760 = constructor_x64_punpckhwd(ctx, v732, v759);
                                                                                            let v761 = constructor_output_xmm(ctx, v760);
                                                                                            let v762 = Some(v761);
                                                                                            // Rule at src/isa/x64/lower.isle line 1243.
                                                                                            return v762;
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                    _ => {}
                                                }
                                            }
                                        }
                                        let v678 = C::has_sse41(ctx);
                                        if v678 == true {
                                            let v93 = constructor_put_in_xmm(ctx, v59.0);
                                            let v94 = &C::put_in_xmm_mem(ctx, v59.1);
                                            let v679 = constructor_x64_pmulld(ctx, v93, v94);
                                            let v680 = constructor_output_xmm(ctx, v679);
                                            let v681 = Some(v680);
                                            // Rule at src/isa/x64/lower.isle line 1130.
                                            return v681;
                                        }
                                        let v93 = constructor_put_in_xmm(ctx, v59.0);
                                        let v682 = constructor_put_in_xmm(ctx, v59.1);
                                        let v501 = &C::xmm_to_xmm_mem(ctx, v93);
                                        let v684 = constructor_x64_pshufd(ctx, v501, 0x31_u8);
                                        let v685 = &C::xmm_to_xmm_mem(ctx, v682);
                                        let v686 = constructor_x64_pshufd(ctx, v685, 0x31_u8);
                                        let v687 = &C::xmm_to_xmm_mem(ctx, v682);
                                        let v688 = constructor_x64_pmuludq(ctx, v93, v687);
                                        let v689 = &C::xmm_to_xmm_mem(ctx, v688);
                                        let v691 = constructor_x64_pshufd(ctx, v689, 0x8_u8);
                                        let v692 = &C::xmm_to_xmm_mem(ctx, v686);
                                        let v693 = constructor_x64_pmuludq(ctx, v684, v692);
                                        let v694 = &C::xmm_to_xmm_mem(ctx, v693);
                                        let v695 = constructor_x64_pshufd(ctx, v694, 0x8_u8);
                                        let v696 = &C::xmm_to_xmm_mem(ctx, v695);
                                        let v697 = constructor_x64_punpckldq(ctx, v691, v696);
                                        let v698 = constructor_output_xmm(ctx, v697);
                                        let v699 = Some(v698);
                                        // Rule at src/isa/x64/lower.isle line 1137.
                                        return v699;
                                    }
                                }
                                0x40_u32 => {
                                    if v90.1 == 0x2_u32 {
                                        let v59 = C::unpack_value_array_2(ctx, v58);
                                        let v120 = C::def_inst(ctx, v59.1);
                                        if let Some(v121) = v120 {
                                            let v122 = &C::inst_data_value(ctx, v121);
                                            if let &InstructionData::Unary {
                                                opcode: ref v137,
                                                arg: v138,
                                            } = v122 {
                                                match v137 {
                                                    &Opcode::SwidenLow => {
                                                        let v147 = C::def_inst(ctx, v59.0);
                                                        if let Some(v148) = v147 {
                                                            let v149 = &C::inst_data_value(ctx, v148);
                                                            if let &InstructionData::Unary {
                                                                opcode: ref v150,
                                                                arg: v151,
                                                            } = v149 {
                                                                if let &Opcode::SwidenLow = v150 {
                                                                    let v678 = C::has_sse41(ctx);
                                                                    if v678 == true {
                                                                        let v668 = C::value_type(ctx, v151);
                                                                        let v722 = C::multi_lane(ctx, v668);
                                                                        if let Some(v723) = v722 {
                                                                            if v723.0 == 0x20_u32 {
                                                                                if v723.1 == 0x4_u32 {
                                                                                    let v139 = C::value_type(ctx, v138);
                                                                                    let v726 = C::multi_lane(ctx, v139);
                                                                                    if let Some(v727) = v726 {
                                                                                        if v727.0 == 0x20_u32 {
                                                                                            if v727.1 == 0x4_u32 {
                                                                                                let v739 = &C::put_in_xmm_mem(ctx, v151);
                                                                                                let v752 = constructor_x64_pshufd(ctx, v739, 0x50_u8);
                                                                                                let v742 = &C::put_in_xmm_mem(ctx, v138);
                                                                                                let v753 = constructor_x64_pshufd(ctx, v742, 0x50_u8);
                                                                                                let v754 = &C::xmm_to_xmm_mem(ctx, v753);
                                                                                                let v755 = constructor_x64_pmuldq(ctx, v752, v754);
                                                                                                let v756 = constructor_output_xmm(ctx, v755);
                                                                                                let v757 = Some(v756);
                                                                                                // Rule at src/isa/x64/lower.isle line 1232.
                                                                                                return v757;
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                    &Opcode::SwidenHigh => {
                                                        let v147 = C::def_inst(ctx, v59.0);
                                                        if let Some(v148) = v147 {
                                                            let v149 = &C::inst_data_value(ctx, v148);
                                                            if let &InstructionData::Unary {
                                                                opcode: ref v150,
                                                                arg: v151,
                                                            } = v149 {
                                                                if let &Opcode::SwidenHigh = v150 {
                                                                    let v678 = C::has_sse41(ctx);
                                                                    if v678 == true {
                                                                        let v668 = C::value_type(ctx, v151);
                                                                        let v722 = C::multi_lane(ctx, v668);
                                                                        if let Some(v723) = v722 {
                                                                            if v723.0 == 0x20_u32 {
                                                                                if v723.1 == 0x4_u32 {
                                                                                    let v139 = C::value_type(ctx, v138);
                                                                                    let v726 = C::multi_lane(ctx, v139);
                                                                                    if let Some(v727) = v726 {
                                                                                        if v727.0 == 0x20_u32 {
                                                                                            if v727.1 == 0x4_u32 {
                                                                                                let v739 = &C::put_in_xmm_mem(ctx, v151);
                                                                                                let v741 = constructor_x64_pshufd(ctx, v739, 0xfa_u8);
                                                                                                let v742 = &C::put_in_xmm_mem(ctx, v138);
                                                                                                let v743 = constructor_x64_pshufd(ctx, v742, 0xfa_u8);
                                                                                                let v744 = &C::xmm_to_xmm_mem(ctx, v743);
                                                                                                let v745 = constructor_x64_pmuldq(ctx, v741, v744);
                                                                                                let v746 = constructor_output_xmm(ctx, v745);
                                                                                                let v747 = Some(v746);
                                                                                                // Rule at src/isa/x64/lower.isle line 1209.
                                                                                                return v747;
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                    &Opcode::UwidenLow => {
                                                        let v147 = C::def_inst(ctx, v59.0);
                                                        if let Some(v148) = v147 {
                                                            let v149 = &C::inst_data_value(ctx, v148);
                                                            if let &InstructionData::Unary {
                                                                opcode: ref v150,
                                                                arg: v151,
                                                            } = v149 {
                                                                if let &Opcode::UwidenLow = v150 {
                                                                    let v668 = C::value_type(ctx, v151);
                                                                    let v722 = C::multi_lane(ctx, v668);
                                                                    if let Some(v723) = v722 {
                                                                        if v723.0 == 0x20_u32 {
                                                                            if v723.1 == 0x4_u32 {
                                                                                let v139 = C::value_type(ctx, v138);
                                                                                let v726 = C::multi_lane(ctx, v139);
                                                                                if let Some(v727) = v726 {
                                                                                    if v727.0 == 0x20_u32 {
                                                                                        if v727.1 == 0x4_u32 {
                                                                                            let v739 = &C::put_in_xmm_mem(ctx, v151);
                                                                                            let v752 = constructor_x64_pshufd(ctx, v739, 0x50_u8);
                                                                                            let v742 = &C::put_in_xmm_mem(ctx, v138);
                                                                                            let v753 = constructor_x64_pshufd(ctx, v742, 0x50_u8);
                                                                                            let v754 = &C::xmm_to_xmm_mem(ctx, v753);
                                                                                            let v769 = constructor_x64_pmuludq(ctx, v752, v754);
                                                                                            let v770 = constructor_output_xmm(ctx, v769);
                                                                                            let v771 = Some(v770);
                                                                                            // Rule at src/isa/x64/lower.isle line 1277.
                                                                                            return v771;
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                    &Opcode::UwidenHigh => {
                                                        let v147 = C::def_inst(ctx, v59.0);
                                                        if let Some(v148) = v147 {
                                                            let v149 = &C::inst_data_value(ctx, v148);
                                                            if let &InstructionData::Unary {
                                                                opcode: ref v150,
                                                                arg: v151,
                                                            } = v149 {
                                                                if let &Opcode::UwidenHigh = v150 {
                                                                    let v668 = C::value_type(ctx, v151);
                                                                    let v722 = C::multi_lane(ctx, v668);
                                                                    if let Some(v723) = v722 {
                                                                        if v723.0 == 0x20_u32 {
                                                                            if v723.1 == 0x4_u32 {
                                                                                let v139 = C::value_type(ctx, v138);
                                                                                let v726 = C::multi_lane(ctx, v139);
                                                                                if let Some(v727) = v726 {
                                                                                    if v727.0 == 0x20_u32 {
                                                                                        if v727.1 == 0x4_u32 {
                                                                                            let v739 = &C::put_in_xmm_mem(ctx, v151);
                                                                                            let v741 = constructor_x64_pshufd(ctx, v739, 0xfa_u8);
                                                                                            let v742 = &C::put_in_xmm_mem(ctx, v138);
                                                                                            let v743 = constructor_x64_pshufd(ctx, v742, 0xfa_u8);
                                                                                            let v744 = &C::xmm_to_xmm_mem(ctx, v743);
                                                                                            let v763 = constructor_x64_pmuludq(ctx, v741, v744);
                                                                                            let v764 = constructor_output_xmm(ctx, v763);
                                                                                            let v765 = Some(v764);
                                                                                            // Rule at src/isa/x64/lower.isle line 1255.
                                                                                            return v765;
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                    _ => {}
                                                }
                                            }
                                        }
                                        let v93 = constructor_put_in_xmm(ctx, v59.0);
                                        let v682 = constructor_put_in_xmm(ctx, v59.1);
                                        let v705 = &C::xmi_imm(ctx, 0x20_u32);
                                        let v706 = constructor_x64_psrlq(ctx, v93, v705);
                                        let v685 = &C::xmm_to_xmm_mem(ctx, v682);
                                        let v707 = constructor_x64_pmuludq(ctx, v706, v685);
                                        let v708 = &C::xmi_imm(ctx, 0x20_u32);
                                        let v709 = constructor_x64_psrlq(ctx, v682, v708);
                                        let v710 = &C::xmm_to_xmm_mem(ctx, v709);
                                        let v711 = constructor_x64_pmuludq(ctx, v93, v710);
                                        let v712 = &C::xmm_to_xmm_mem(ctx, v711);
                                        let v713 = constructor_x64_paddq(ctx, v707, v712);
                                        let v714 = &C::xmi_imm(ctx, 0x20_u32);
                                        let v715 = constructor_x64_psllq(ctx, v713, v714);
                                        let v716 = &C::xmm_to_xmm_mem(ctx, v682);
                                        let v717 = constructor_x64_pmuludq(ctx, v93, v716);
                                        let v718 = &C::xmm_to_xmm_mem(ctx, v715);
                                        let v719 = constructor_x64_paddq(ctx, v717, v718);
                                        let v720 = constructor_output_xmm(ctx, v719);
                                        let v721 = Some(v720);
                                        // Rule at src/isa/x64/lower.isle line 1175.
                                        return v721;
                                    }
                                }
                                _ => {}
                            }
                        }
                        if v3 == I16 {
                            let v59 = C::unpack_value_array_2(ctx, v58);
                            let v120 = C::def_inst(ctx, v59.1);
                            if let Some(v121) = v120 {
                                let v122 = &C::inst_data_value(ctx, v121);
                                if let &InstructionData::Unary {
                                    opcode: ref v137,
                                    arg: v138,
                                } = v122 {
                                    match v137 {
                                        &Opcode::Uextend => {
                                            let v147 = C::def_inst(ctx, v59.0);
                                            if let Some(v148) = v147 {
                                                let v149 = &C::inst_data_value(ctx, v148);
                                                if let &InstructionData::Unary {
                                                    opcode: ref v150,
                                                    arg: v151,
                                                } = v149 {
                                                    if let &Opcode::Uextend = v150 {
                                                        let v296 = constructor_put_in_gpr(ctx, v151);
                                                        let v650 = &constructor_put_in_gpr_mem(ctx, v138);
                                                        let v192 = false;
                                                        let v654 = constructor_x64_mul8(ctx, v192, v296, v650);
                                                        let v655 = constructor_output_gpr(ctx, v654);
                                                        let v656 = Some(v655);
                                                        // Rule at src/isa/x64/lower.isle line 1060.
                                                        return v656;
                                                    }
                                                }
                                            }
                                        }
                                        &Opcode::Sextend => {
                                            let v147 = C::def_inst(ctx, v59.0);
                                            if let Some(v148) = v147 {
                                                let v149 = &C::inst_data_value(ctx, v148);
                                                if let &InstructionData::Unary {
                                                    opcode: ref v150,
                                                    arg: v151,
                                                } = v149 {
                                                    if let &Opcode::Sextend = v150 {
                                                        let v296 = constructor_put_in_gpr(ctx, v151);
                                                        let v650 = &constructor_put_in_gpr_mem(ctx, v138);
                                                        let v202 = true;
                                                        let v651 = constructor_x64_mul8(ctx, v202, v296, v650);
                                                        let v652 = constructor_output_gpr(ctx, v651);
                                                        let v653 = Some(v652);
                                                        // Rule at src/isa/x64/lower.isle line 1058.
                                                        return v653;
                                                    }
                                                }
                                            }
                                        }
                                        _ => {}
                                    }
                                }
                            }
                        }
                        let v363 = C::ty_int_ref_16_to_64(ctx, v3);
                        if let Some(v364) = v363 {
                            let v59 = C::unpack_value_array_2(ctx, v58);
                            let v643 = C::i64_from_iconst(ctx, v59.0);
                            if let Some(v644) = v643 {
                                let v645 = C::i64_from_i32(ctx, v644);
                                if let Some(v646) = v645 {
                                    let v308 = &constructor_put_in_gpr_mem(ctx, v59.1);
                                    let v647 = constructor_x64_imul_imm(ctx, v364, v308, v646);
                                    let v648 = constructor_output_gpr(ctx, v647);
                                    let v649 = Some(v648);
                                    // Rule at src/isa/x64/lower.isle line 1052.
                                    return v649;
                                }
                            }
                            let v636 = C::i64_from_iconst(ctx, v59.1);
                            if let Some(v637) = v636 {
                                let v638 = C::i64_from_i32(ctx, v637);
                                if let Some(v639) = v638 {
                                    let v302 = &constructor_put_in_gpr_mem(ctx, v59.0);
                                    let v640 = constructor_x64_imul_imm(ctx, v364, v302, v639);
                                    let v641 = constructor_output_gpr(ctx, v640);
                                    let v642 = Some(v641);
                                    // Rule at src/isa/x64/lower.isle line 1050.
                                    return v642;
                                }
                            }
                            let v82 = &C::sinkable_load(ctx, v59.0);
                            if let Some(v83) = v82 {
                                let v84 = constructor_put_in_gpr(ctx, v59.1);
                                let v626 = &constructor_sink_load_to_gpr_mem(ctx, v83);
                                let v633 = constructor_x64_imul(ctx, v364, v84, v626);
                                let v634 = constructor_output_gpr(ctx, v633);
                                let v635 = Some(v634);
                                // Rule at src/isa/x64/lower.isle line 1046.
                                return v635;
                            }
                            let v62 = constructor_put_in_gpr(ctx, v59.0);
                            let v193 = &constructor_put_in_gpr_mem(ctx, v59.1);
                            let v630 = constructor_x64_imul(ctx, v364, v62, v193);
                            let v631 = constructor_output_gpr(ctx, v630);
                            let v632 = Some(v631);
                            // Rule at src/isa/x64/lower.isle line 1044.
                            return v632;
                        }
                        if v3 == I8 {
                            let v59 = C::unpack_value_array_2(ctx, v58);
                            let v82 = &C::sinkable_load(ctx, v59.0);
                            if let Some(v83) = v82 {
                                let v84 = constructor_put_in_gpr(ctx, v59.1);
                                let v626 = &constructor_sink_load_to_gpr_mem(ctx, v83);
                                let v192 = false;
                                let v627 = constructor_x64_mul8(ctx, v192, v84, v626);
                                let v628 = constructor_output_gpr(ctx, v627);
                                let v629 = Some(v628);
                                // Rule at src/isa/x64/lower.isle line 1041.
                                return v629;
                            }
                            let v62 = constructor_put_in_gpr(ctx, v59.0);
                            let v193 = &constructor_put_in_gpr_mem(ctx, v59.1);
                            let v192 = false;
                            let v623 = constructor_x64_mul8(ctx, v192, v62, v193);
                            let v624 = constructor_output_gpr(ctx, v623);
                            let v625 = Some(v624);
                            // Rule at src/isa/x64/lower.isle line 1040.
                            return v625;
                        }
                    }
                }
                &Opcode::Umulhi => {
                    let v319 = C::has_bmi2(ctx);
                    if v319 == true {
                        let v59 = C::unpack_value_array_2(ctx, v58);
                        let v2894 = C::value_type(ctx, v59.0);
                        let v3072 = C::ty_32_or_64(ctx, v2894);
                        if let Some(v3073) = v3072 {
                            let v62 = constructor_put_in_gpr(ctx, v59.0);
                            let v193 = &constructor_put_in_gpr_mem(ctx, v59.1);
                            let v3074 = constructor_x64_mulx_hi(ctx, v3073, v62, v193);
                            let v3075 = constructor_output_gpr(ctx, v3074);
                            let v3076 = Some(v3075);
                            // Rule at src/isa/x64/lower.isle line 4526.
                            return v3076;
                        }
                    }
                    let v59 = C::unpack_value_array_2(ctx, v58);
                    let v2894 = C::value_type(ctx, v59.0);
                    let v3066 = C::ty_int_ref_16_to_64(ctx, v2894);
                    if let Some(v3067) = v3066 {
                        let v62 = constructor_put_in_gpr(ctx, v59.0);
                        let v193 = &constructor_put_in_gpr_mem(ctx, v59.1);
                        let v192 = false;
                        let v3068 = constructor_x64_mul(ctx, v3067, v192, v62, v193);
                        let v3069 = constructor_value_regs_get_gpr(ctx, v3068, 0x1_usize);
                        let v3070 = constructor_output_gpr(ctx, v3069);
                        let v3071 = Some(v3070);
                        // Rule at src/isa/x64/lower.isle line 4519.
                        return v3071;
                    }
                    if v2894 == I8 {
                        let v62 = constructor_put_in_gpr(ctx, v59.0);
                        let v193 = &constructor_put_in_gpr_mem(ctx, v59.1);
                        let v192 = false;
                        let v623 = constructor_x64_mul8(ctx, v192, v62, v193);
                        let v3063 = constructor_x64_shrw_mi(ctx, v623, 0x8_u8);
                        let v3064 = constructor_output_gpr(ctx, v3063);
                        let v3065 = Some(v3064);
                        // Rule at src/isa/x64/lower.isle line 4516.
                        return v3065;
                    }
                }
                &Opcode::Smulhi => {
                    let v59 = C::unpack_value_array_2(ctx, v58);
                    let v2894 = C::value_type(ctx, v59.0);
                    let v3066 = C::ty_int_ref_16_to_64(ctx, v2894);
                    if let Some(v3067) = v3066 {
                        let v62 = constructor_put_in_gpr(ctx, v59.0);
                        let v193 = &constructor_put_in_gpr_mem(ctx, v59.1);
                        let v202 = true;
                        let v3081 = constructor_x64_mul(ctx, v3067, v202, v62, v193);
                        let v3082 = constructor_value_regs_get_gpr(ctx, v3081, 0x1_usize);
                        let v3083 = constructor_output_gpr(ctx, v3082);
                        let v3084 = Some(v3083);
                        // Rule at src/isa/x64/lower.isle line 4535.
                        return v3084;
                    }
                    if v2894 == I8 {
                        let v62 = constructor_put_in_gpr(ctx, v59.0);
                        let v193 = &constructor_put_in_gpr_mem(ctx, v59.1);
                        let v202 = true;
                        let v3077 = constructor_x64_mul8(ctx, v202, v62, v193);
                        let v3078 = constructor_x64_sarw_mi(ctx, v3077, 0x8_u8);
                        let v3079 = constructor_output_gpr(ctx, v3078);
                        let v3080 = Some(v3079);
                        // Rule at src/isa/x64/lower.isle line 4532.
                        return v3080;
                    }
                }
                &Opcode::SqmulRoundSat => {
                    let v59 = C::unpack_value_array_2(ctx, v58);
                    let v2894 = C::value_type(ctx, v59.0);
                    if v2894 == I16X8 {
                        let v772 = C::has_ssse3(ctx);
                        if v772 == true {
                            let v93 = constructor_put_in_xmm(ctx, v59.0);
                            let v682 = constructor_put_in_xmm(ctx, v59.1);
                            let v3445 = C::emit_u128_le_const(ctx, 0x80008000800080008000800080008000_u128);
                            let v3446 = &constructor_const_to_xmm_mem(ctx, v3445);
                            let v685 = &C::xmm_to_xmm_mem(ctx, v682);
                            let v3447 = constructor_x64_pmulhrsw(ctx, v93, v685);
                            let v3448 = constructor_x64_pcmpeqw(ctx, v3447, v3446);
                            let v3449 = &C::xmm_to_xmm_mem(ctx, v3448);
                            let v3450 = constructor_x64_pxor(ctx, v3447, v3449);
                            let v3451 = constructor_output_xmm(ctx, v3450);
                            let v3452 = Some(v3451);
                            // Rule at src/isa/x64/lower.isle line 5010.
                            return v3452;
                        }
                        let v93 = constructor_put_in_xmm(ctx, v59.0);
                        let v682 = constructor_put_in_xmm(ctx, v59.1);
                        let v1873 = &C::xmm_to_xmm_mem(ctx, v682);
                        let v3453 = constructor_x64_pmullw(ctx, v93, v1873);
                        let v685 = &C::xmm_to_xmm_mem(ctx, v682);
                        let v3454 = constructor_x64_pmulhw(ctx, v93, v685);
                        let v3455 = &C::xmm_to_xmm_mem(ctx, v3454);
                        let v3456 = constructor_x64_punpcklwd(ctx, v3453, v3455);
                        let v3457 = &C::xmm_to_xmm_mem(ctx, v3454);
                        let v3458 = constructor_x64_punpckhwd(ctx, v3453, v3457);
                        let v3460 = C::emit_u128_le_const(ctx, 0x4000000040000000400000004000_u128);
                        let v3461 = &constructor_const_to_xmm_mem(ctx, v3460);
                        let v3462 = constructor_x64_movdqu_load(ctx, v3461);
                        let v3463 = &C::xmm_to_xmm_mem(ctx, v3462);
                        let v3464 = constructor_x64_paddd(ctx, v3456, v3463);
                        let v3465 = &C::xmm_to_xmm_mem(ctx, v3462);
                        let v3466 = constructor_x64_paddd(ctx, v3458, v3465);
                        let v3468 = &C::xmi_imm(ctx, 0xf_u32);
                        let v3469 = constructor_x64_psrad(ctx, v3464, v3468);
                        let v3470 = &C::xmi_imm(ctx, 0xf_u32);
                        let v3471 = constructor_x64_psrad(ctx, v3466, v3470);
                        let v3472 = &C::xmm_to_xmm_mem(ctx, v3471);
                        let v3473 = constructor_x64_packssdw(ctx, v3469, v3472);
                        let v3474 = constructor_output_xmm(ctx, v3473);
                        let v3475 = Some(v3474);
                        // Rule at src/isa/x64/lower.isle line 5026.
                        return v3475;
                    }
                }
                &Opcode::X86Pmulhrsw => {
                    let v772 = C::has_ssse3(ctx);
                    if v772 == true {
                        let v59 = C::unpack_value_array_2(ctx, v58);
                        let v2894 = C::value_type(ctx, v59.0);
                        if v2894 == I16X8 {
                            let v93 = constructor_put_in_xmm(ctx, v59.0);
                            let v94 = &C::put_in_xmm_mem(ctx, v59.1);
                            let v3476 = constructor_x64_pmulhrsw(ctx, v93, v94);
                            let v3477 = constructor_output_xmm(ctx, v3476);
                            let v3478 = Some(v3477);
                            // Rule at src/isa/x64/lower.isle line 5052.
                            return v3478;
                        }
                    }
                }
                &Opcode::Udiv => {
                    let v59 = C::unpack_value_array_2(ctx, v58);
                    let v2894 = C::value_type(ctx, v59.0);
                    if v2894 == I8 {
                        let v3001 = constructor_extend_to_gpr(ctx, v59.0, I32, &ExtendKind::Zero);
                        let v547 = constructor_put_in_gpr(ctx, v59.1);
                        let v3002 = &C::gpr_to_gpr_mem(ctx, v547);
                        let v3004 = constructor_x64_divb_m(ctx, v3001, v3002, &TrapCode::INTEGER_DIVISION_BY_ZERO);
                        let v3005 = constructor_output_gpr(ctx, v3004);
                        let v3006 = Some(v3005);
                        // Rule at src/isa/x64/lower.isle line 4405.
                        return v3006;
                    }
                    let v3007 = C::fits_in_64(ctx, v2894);
                    if let Some(v3008) = v3007 {
                        let v62 = constructor_put_in_gpr(ctx, v59.0);
                        let v16 = constructor_imm(ctx, I64, 0x0_u64);
                        let v3009 = C::gpr_new(ctx, v16);
                        let v3010 = constructor_put_in_gpr(ctx, v59.1);
                        let v3011 = &C::gpr_to_gpr_mem(ctx, v3010);
                        let v3012 = constructor_x64_div(ctx, v3008, v62, v3009, v3011, &TrapCode::INTEGER_DIVISION_BY_ZERO);
                        let v3013 = C::value_regs_get(ctx, v3012, 0x0_usize);
                        let v3014 = constructor_output_reg(ctx, v3013);
                        let v3015 = Some(v3014);
                        // Rule at src/isa/x64/lower.isle line 4413.
                        return v3015;
                    }
                }
                &Opcode::Sdiv => {
                    let v59 = C::unpack_value_array_2(ctx, v58);
                    let v2894 = C::value_type(ctx, v59.0);
                    if v2894 == I8 {
                        let v62 = constructor_put_in_gpr(ctx, v59.0);
                        let v3016 = constructor_x64_cbtw_zo(ctx, v62);
                        let v3017 = constructor_nonzero_sdiv_divisor(ctx, I8, v59.1);
                        let v3018 = &C::reg_to_gpr_mem(ctx, v3017);
                        let v3020 = constructor_x64_idivb_m(ctx, v3016, v3018, &TrapCode::INTEGER_OVERFLOW);
                        let v3021 = constructor_output_gpr(ctx, v3020);
                        let v3022 = Some(v3021);
                        // Rule at src/isa/x64/lower.isle line 4420.
                        return v3022;
                    }
                    let v3007 = C::fits_in_64(ctx, v2894);
                    if let Some(v3008) = v3007 {
                        let v62 = constructor_put_in_gpr(ctx, v59.0);
                        let v3023 = constructor_repeat_sign_bit(ctx, v3008, v62);
                        let v3024 = constructor_nonzero_sdiv_divisor(ctx, v3008, v59.1);
                        let v3025 = &C::reg_to_gpr_mem(ctx, v3024);
                        let v3026 = constructor_x64_idiv(ctx, v3008, v62, v3023, v3025, &TrapCode::INTEGER_OVERFLOW);
                        let v3027 = C::value_regs_get(ctx, v3026, 0x0_usize);
                        let v3028 = constructor_output_reg(ctx, v3027);
                        let v3029 = Some(v3028);
                        // Rule at src/isa/x64/lower.isle line 4425.
                        return v3029;
                    }
                }
                &Opcode::Urem => {
                    let v59 = C::unpack_value_array_2(ctx, v58);
                    let v2894 = C::value_type(ctx, v59.0);
                    if v2894 == I8 {
                        let v3001 = constructor_extend_to_gpr(ctx, v59.0, I32, &ExtendKind::Zero);
                        let v547 = constructor_put_in_gpr(ctx, v59.1);
                        let v3002 = &C::gpr_to_gpr_mem(ctx, v547);
                        let v3004 = constructor_x64_divb_m(ctx, v3001, v3002, &TrapCode::INTEGER_DIVISION_BY_ZERO);
                        let v3030 = constructor_x64_shrq_mi(ctx, v3004, 0x8_u8);
                        let v3031 = constructor_output_gpr(ctx, v3030);
                        let v3032 = Some(v3031);
                        // Rule at src/isa/x64/lower.isle line 4463.
                        return v3032;
                    }
                    let v3007 = C::fits_in_64(ctx, v2894);
                    if let Some(v3008) = v3007 {
                        let v62 = constructor_put_in_gpr(ctx, v59.0);
                        let v16 = constructor_imm(ctx, I64, 0x0_u64);
                        let v3009 = C::gpr_new(ctx, v16);
                        let v3010 = constructor_put_in_gpr(ctx, v59.1);
                        let v3011 = &C::gpr_to_gpr_mem(ctx, v3010);
                        let v3012 = constructor_x64_div(ctx, v3008, v62, v3009, v3011, &TrapCode::INTEGER_DIVISION_BY_ZERO);
                        let v3033 = C::value_regs_get(ctx, v3012, 0x1_usize);
                        let v3034 = constructor_output_reg(ctx, v3033);
                        let v3035 = Some(v3034);
                        // Rule at src/isa/x64/lower.isle line 4471.
                        return v3035;
                    }
                }
                &Opcode::Srem => {
                    let v59 = C::unpack_value_array_2(ctx, v58);
                    let v120 = C::def_inst(ctx, v59.1);
                    if let Some(v121) = v120 {
                        let v122 = &C::inst_data_value(ctx, v121);
                        if let &InstructionData::UnaryImm {
                            opcode: ref v518,
                            imm: v519,
                        } = v122 {
                            if let &Opcode::Iconst = v518 {
                                let v2894 = C::value_type(ctx, v59.0);
                                if v2894 == I8 {
                                    let v3036 = C::safe_divisor_from_imm64(ctx, I8, v519);
                                    if let Some(v3037) = v3036 {
                                        let v62 = constructor_put_in_gpr(ctx, v59.0);
                                        let v3016 = constructor_x64_cbtw_zo(ctx, v62);
                                        let v3038 = constructor_imm(ctx, I8, v3037);
                                        let v3039 = &C::reg_to_gpr_mem(ctx, v3038);
                                        let v3040 = constructor_x64_idivb_m(ctx, v3016, v3039, &TrapCode::INTEGER_DIVISION_BY_ZERO);
                                        let v3041 = constructor_x64_shrq_mi(ctx, v3040, 0x8_u8);
                                        let v3042 = constructor_output_gpr(ctx, v3041);
                                        let v3043 = Some(v3042);
                                        // Rule at src/isa/x64/lower.isle line 4483.
                                        return v3043;
                                    }
                                }
                                let v3044 = C::safe_divisor_from_imm64(ctx, v2894, v519);
                                if let Some(v3045) = v3044 {
                                    let v62 = constructor_put_in_gpr(ctx, v59.0);
                                    let v3046 = &C::raw_operand_size_of_type(ctx, v2894);
                                    let v3047 = constructor_repeat_sign_bit(ctx, v2894, v62);
                                    let v3048 = constructor_imm(ctx, v2894, v3045);
                                    let v3049 = &C::reg_to_gpr_mem(ctx, v3048);
                                    let v3050 = constructor_x64_idiv(ctx, v2894, v62, v3047, v3049, &TrapCode::INTEGER_DIVISION_BY_ZERO);
                                    let v3051 = C::value_regs_get(ctx, v3050, 0x1_usize);
                                    let v3052 = constructor_output_reg(ctx, v3051);
                                    let v3053 = Some(v3052);
                                    // Rule at src/isa/x64/lower.isle line 4492.
                                    return v3053;
                                }
                            }
                        }
                    }
                    let v2894 = C::value_type(ctx, v59.0);
                    if v2894 == I8 {
                        let v62 = constructor_put_in_gpr(ctx, v59.0);
                        let v3016 = constructor_x64_cbtw_zo(ctx, v62);
                        let v3054 = constructor_put_in_gpr(ctx, v59.1);
                        let v3055 = constructor_x64_checked_srem_seq8(ctx, v3016, v3054);
                        let v3056 = constructor_x64_shrq_mi(ctx, v3055, 0x8_u8);
                        let v3057 = constructor_output_gpr(ctx, v3056);
                        let v3058 = Some(v3057);
                        // Rule at src/isa/x64/lower.isle line 4502.
                        return v3058;
                    }
                    let v62 = constructor_put_in_gpr(ctx, v59.0);
                    let v3046 = &C::raw_operand_size_of_type(ctx, v2894);
                    let v3047 = constructor_repeat_sign_bit(ctx, v2894, v62);
                    let v3010 = constructor_put_in_gpr(ctx, v59.1);
                    let v3059 = constructor_x64_checked_srem_seq(ctx, v3046, v62, v3047, v3010);
                    let v3060 = C::value_regs_get(ctx, v3059, 0x1_usize);
                    let v3061 = constructor_output_reg(ctx, v3060);
                    let v3062 = Some(v3061);
                    // Rule at src/isa/x64/lower.isle line 4505.
                    return v3062;
                }
                &Opcode::UaddOverflow => {
                    let v59 = C::unpack_value_array_2(ctx, v58);
                    let v168 = C::value_type(ctx, v59.1);
                    let v169 = C::fits_in_64(ctx, v168);
                    if let Some(v170) = v169 {
                        let v62 = constructor_put_in_gpr(ctx, v59.0);
                        let v63 = &constructor_put_in_gpr_mem_imm(ctx, v59.1);
                        let v172 = constructor_construct_overflow_op_alu(ctx, v170, &CC::B, &ProduceFlagsOp::Add, v62, v63);
                        let v173 = Some(v172);
                        // Rule at src/isa/x64/lower.isle line 175.
                        return v173;
                    }
                    if v168 == I128 {
                        let v175 = constructor_construct_overflow_op_alu_128(ctx, &CC::B, &ProduceFlagsOp::Add, &ChainFlagsOp::Adc, v59.0, v59.1);
                        let v176 = Some(v175);
                        // Rule at src/isa/x64/lower.isle line 179.
                        return v176;
                    }
                }
                &Opcode::SaddOverflow => {
                    let v59 = C::unpack_value_array_2(ctx, v58);
                    let v168 = C::value_type(ctx, v59.1);
                    let v169 = C::fits_in_64(ctx, v168);
                    if let Some(v170) = v169 {
                        let v62 = constructor_put_in_gpr(ctx, v59.0);
                        let v63 = &constructor_put_in_gpr_mem_imm(ctx, v59.1);
                        let v178 = constructor_construct_overflow_op_alu(ctx, v170, &CC::O, &ProduceFlagsOp::Add, v62, v63);
                        let v179 = Some(v178);
                        // Rule at src/isa/x64/lower.isle line 184.
                        return v179;
                    }
                    if v168 == I128 {
                        let v180 = constructor_construct_overflow_op_alu_128(ctx, &CC::O, &ProduceFlagsOp::Add, &ChainFlagsOp::Adc, v59.0, v59.1);
                        let v181 = Some(v180);
                        // Rule at src/isa/x64/lower.isle line 187.
                        return v181;
                    }
                }
                &Opcode::UsubOverflow => {
                    let v59 = C::unpack_value_array_2(ctx, v58);
                    let v168 = C::value_type(ctx, v59.1);
                    let v169 = C::fits_in_64(ctx, v168);
                    if let Some(v170) = v169 {
                        let v62 = constructor_put_in_gpr(ctx, v59.0);
                        let v63 = &constructor_put_in_gpr_mem_imm(ctx, v59.1);
                        let v183 = constructor_construct_overflow_op_alu(ctx, v170, &CC::B, &ProduceFlagsOp::Sub, v62, v63);
                        let v184 = Some(v183);
                        // Rule at src/isa/x64/lower.isle line 192.
                        return v184;
                    }
                    if v168 == I128 {
                        let v186 = constructor_construct_overflow_op_alu_128(ctx, &CC::B, &ProduceFlagsOp::Sub, &ChainFlagsOp::Sbb, v59.0, v59.1);
                        let v187 = Some(v186);
                        // Rule at src/isa/x64/lower.isle line 195.
                        return v187;
                    }
                }
                &Opcode::SsubOverflow => {
                    let v59 = C::unpack_value_array_2(ctx, v58);
                    let v168 = C::value_type(ctx, v59.1);
                    let v169 = C::fits_in_64(ctx, v168);
                    if let Some(v170) = v169 {
                        let v62 = constructor_put_in_gpr(ctx, v59.0);
                        let v63 = &constructor_put_in_gpr_mem_imm(ctx, v59.1);
                        let v188 = constructor_construct_overflow_op_alu(ctx, v170, &CC::O, &ProduceFlagsOp::Sub, v62, v63);
                        let v189 = Some(v188);
                        // Rule at src/isa/x64/lower.isle line 200.
                        return v189;
                    }
                    if v168 == I128 {
                        let v190 = constructor_construct_overflow_op_alu_128(ctx, &CC::O, &ProduceFlagsOp::Sub, &ChainFlagsOp::Sbb, v59.0, v59.1);
                        let v191 = Some(v190);
                        // Rule at src/isa/x64/lower.isle line 203.
                        return v191;
                    }
                }
                &Opcode::UmulOverflow => {
                    let v59 = C::unpack_value_array_2(ctx, v58);
                    let v168 = C::value_type(ctx, v59.1);
                    let v197 = C::ty_int_ref_16_to_64(ctx, v168);
                    if let Some(v198) = v197 {
                        let v62 = constructor_put_in_gpr(ctx, v59.0);
                        let v193 = &constructor_put_in_gpr_mem(ctx, v59.1);
                        let v192 = false;
                        let v199 = &constructor_x64_mul_lo_with_flags_paired(ctx, v198, v192, v62, v193);
                        let v200 = constructor_construct_overflow_op(ctx, &CC::O, v199);
                        let v201 = Some(v200);
                        // Rule at src/isa/x64/lower.isle line 211.
                        return v201;
                    }
                    if v168 == I8 {
                        let v62 = constructor_put_in_gpr(ctx, v59.0);
                        let v193 = &constructor_put_in_gpr_mem(ctx, v59.1);
                        let v192 = false;
                        let v194 = &constructor_x64_mul8_with_flags_paired(ctx, v192, v62, v193);
                        let v195 = constructor_construct_overflow_op(ctx, &CC::O, v194);
                        let v196 = Some(v195);
                        // Rule at src/isa/x64/lower.isle line 208.
                        return v196;
                    }
                }
                &Opcode::SmulOverflow => {
                    let v59 = C::unpack_value_array_2(ctx, v58);
                    let v168 = C::value_type(ctx, v59.1);
                    let v197 = C::ty_int_ref_16_to_64(ctx, v168);
                    if let Some(v198) = v197 {
                        let v62 = constructor_put_in_gpr(ctx, v59.0);
                        let v193 = &constructor_put_in_gpr_mem(ctx, v59.1);
                        let v202 = true;
                        let v206 = &constructor_x64_mul_lo_with_flags_paired(ctx, v198, v202, v62, v193);
                        let v207 = constructor_construct_overflow_op(ctx, &CC::O, v206);
                        let v208 = Some(v207);
                        // Rule at src/isa/x64/lower.isle line 219.
                        return v208;
                    }
                    if v168 == I8 {
                        let v62 = constructor_put_in_gpr(ctx, v59.0);
                        let v193 = &constructor_put_in_gpr_mem(ctx, v59.1);
                        let v202 = true;
                        let v203 = &constructor_x64_mul8_with_flags_paired(ctx, v202, v62, v193);
                        let v204 = constructor_construct_overflow_op(ctx, &CC::O, v203);
                        let v205 = Some(v204);
                        // Rule at src/isa/x64/lower.isle line 216.
                        return v205;
                    }
                }
                &Opcode::Band => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        let v67 = C::ty_32_or_64(ctx, v3);
                        if let Some(v68) = v67 {
                            let v59 = C::unpack_value_array_2(ctx, v58);
                            let v300 = constructor_val_minus_one(ctx, v59.1);
                            if let Some(v301) = v300 {
                                let v319 = C::has_bmi2(ctx);
                                if v319 == true {
                                    let v320 = C::def_inst(ctx, v301);
                                    if let Some(v321) = v320 {
                                        let v322 = &C::inst_data_value(ctx, v321);
                                        if let &InstructionData::Binary {
                                            opcode: ref v323,
                                            args: ref v324,
                                        } = v322 {
                                            if let &Opcode::Ishl = v323 {
                                                let v325 = C::unpack_value_array_2(ctx, v324);
                                                let v328 = C::def_inst(ctx, v325.0);
                                                if let Some(v329) = v328 {
                                                    let v330 = &C::inst_data_value(ctx, v329);
                                                    if let &InstructionData::UnaryImm {
                                                        opcode: ref v331,
                                                        imm: v332,
                                                    } = v330 {
                                                        if let &Opcode::Iconst = v331 {
                                                            let v333 = C::u64_from_imm64(ctx, v332);
                                                            if v333 == 0x1_u64 {
                                                                let v302 = &constructor_put_in_gpr_mem(ctx, v59.0);
                                                                let v334 = constructor_put_in_gpr(ctx, v325.1);
                                                                let v335 = C::ty_bits(ctx, v68);
                                                                let v336 = C::u8_into_u32(ctx, v335);
                                                                let v338 = C::u32_wrapping_sub(ctx, v336, 0x1_u32);
                                                                let v339 = RegMemImm::Imm {
                                                                    simm32: v338,
                                                                };
                                                                let v340 = &C::gpr_mem_imm_new(ctx, &v339);
                                                                let v341 = constructor_x64_and(ctx, v68, v334, v340);
                                                                let v342 = constructor_x64_bzhi(ctx, v68, v302, v341);
                                                                let v343 = constructor_output_gpr(ctx, v342);
                                                                let v344 = Some(v343);
                                                                // Rule at src/isa/x64/lower.isle line 434.
                                                                return v344;
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            let v290 = C::has_bmi1(ctx);
                            if v290 == true {
                                let v120 = C::def_inst(ctx, v59.1);
                                if let Some(v121) = v120 {
                                    let v122 = &C::inst_data_value(ctx, v121);
                                    if let &InstructionData::Unary {
                                        opcode: ref v137,
                                        arg: v138,
                                    } = v122 {
                                        if let &Opcode::Ineg = v137 {
                                            if v59.0 == v138 {
                                                let v302 = &constructor_put_in_gpr_mem(ctx, v59.0);
                                                let v316 = constructor_x64_blsi(ctx, v68, v302);
                                                let v317 = constructor_output_gpr(ctx, v316);
                                                let v318 = Some(v317);
                                                // Rule at src/isa/x64/lower.isle line 421.
                                                return v318;
                                            }
                                        }
                                    }
                                }
                                let v147 = C::def_inst(ctx, v59.0);
                                if let Some(v148) = v147 {
                                    let v149 = &C::inst_data_value(ctx, v148);
                                    if let &InstructionData::Unary {
                                        opcode: ref v150,
                                        arg: v151,
                                    } = v149 {
                                        if let &Opcode::Ineg = v150 {
                                            if v59.1 == v151 {
                                                let v312 = &constructor_put_in_gpr_mem(ctx, v151);
                                                let v313 = constructor_x64_blsi(ctx, v68, v312);
                                                let v314 = constructor_output_gpr(ctx, v313);
                                                let v315 = Some(v314);
                                                // Rule at src/isa/x64/lower.isle line 418.
                                                return v315;
                                            }
                                        }
                                    }
                                }
                                let v306 = constructor_val_minus_one(ctx, v59.0);
                                if let Some(v307) = v306 {
                                    if v59.1 == v307 {
                                        let v308 = &constructor_put_in_gpr_mem(ctx, v59.1);
                                        let v309 = constructor_x64_blsr(ctx, v68, v308);
                                        let v310 = constructor_output_gpr(ctx, v309);
                                        let v311 = Some(v310);
                                        // Rule at src/isa/x64/lower.isle line 411.
                                        return v311;
                                    }
                                }
                                if let Some(v301) = v300 {
                                    if v59.0 == v301 {
                                        let v302 = &constructor_put_in_gpr_mem(ctx, v59.0);
                                        let v303 = constructor_x64_blsr(ctx, v68, v302);
                                        let v304 = constructor_output_gpr(ctx, v303);
                                        let v305 = Some(v304);
                                        // Rule at src/isa/x64/lower.isle line 407.
                                        return v305;
                                    }
                                }
                            }
                        }
                        let v257 = C::ty_int_ref_scalar_64(ctx, v3);
                        if let Some(v258) = v257 {
                            let v290 = C::has_bmi1(ctx);
                            if v290 == true {
                                let v59 = C::unpack_value_array_2(ctx, v58);
                                let v147 = C::def_inst(ctx, v59.0);
                                if let Some(v148) = v147 {
                                    let v149 = &C::inst_data_value(ctx, v148);
                                    if let &InstructionData::Unary {
                                        opcode: ref v150,
                                        arg: v151,
                                    } = v149 {
                                        if let &Opcode::Bnot = v150 {
                                            let v296 = constructor_put_in_gpr(ctx, v151);
                                            let v193 = &constructor_put_in_gpr_mem(ctx, v59.1);
                                            let v297 = constructor_x64_andn(ctx, v3, v296, v193);
                                            let v298 = constructor_output_gpr(ctx, v297);
                                            let v299 = Some(v298);
                                            // Rule at src/isa/x64/lower.isle line 395.
                                            return v299;
                                        }
                                    }
                                }
                                let v120 = C::def_inst(ctx, v59.1);
                                if let Some(v121) = v120 {
                                    let v122 = &C::inst_data_value(ctx, v121);
                                    if let &InstructionData::Unary {
                                        opcode: ref v137,
                                        arg: v138,
                                    } = v122 {
                                        if let &Opcode::Bnot = v137 {
                                            let v291 = constructor_put_in_gpr(ctx, v138);
                                            let v292 = &constructor_put_in_gpr_mem(ctx, v59.0);
                                            let v293 = constructor_x64_andn(ctx, v3, v291, v292);
                                            let v294 = constructor_output_gpr(ctx, v293);
                                            let v295 = Some(v294);
                                            // Rule at src/isa/x64/lower.isle line 390.
                                            return v295;
                                        }
                                    }
                                }
                            }
                        }
                        let v89 = C::multi_lane(ctx, v3);
                        if let Some(v90) = v89 {
                            let v59 = C::unpack_value_array_2(ctx, v58);
                            let v147 = C::def_inst(ctx, v59.0);
                            if let Some(v148) = v147 {
                                let v149 = &C::inst_data_value(ctx, v148);
                                if let &InstructionData::Unary {
                                    opcode: ref v150,
                                    arg: v151,
                                } = v149 {
                                    if let &Opcode::Bnot = v150 {
                                        let v286 = constructor_put_in_xmm(ctx, v151);
                                        let v94 = &C::put_in_xmm_mem(ctx, v59.1);
                                        let v287 = constructor_sse_and_not(ctx, v3, v286, v94);
                                        let v288 = constructor_output_xmm(ctx, v287);
                                        let v289 = Some(v288);
                                        // Rule at src/isa/x64/lower.isle line 387.
                                        return v289;
                                    }
                                }
                            }
                            let v120 = C::def_inst(ctx, v59.1);
                            if let Some(v121) = v120 {
                                let v122 = &C::inst_data_value(ctx, v121);
                                if let &InstructionData::Unary {
                                    opcode: ref v137,
                                    arg: v138,
                                } = v122 {
                                    if let &Opcode::Bnot = v137 {
                                        let v281 = constructor_put_in_xmm(ctx, v138);
                                        let v282 = &C::put_in_xmm_mem(ctx, v59.0);
                                        let v283 = constructor_sse_and_not(ctx, v3, v281, v282);
                                        let v284 = constructor_output_xmm(ctx, v283);
                                        let v285 = Some(v284);
                                        // Rule at src/isa/x64/lower.isle line 385.
                                        return v285;
                                    }
                                }
                            }
                        }
                        if v3 == I128 {
                            let v59 = C::unpack_value_array_2(ctx, v58);
                            let v107 = C::put_in_regs(ctx, v59.0);
                            let v108 = C::put_in_regs(ctx, v59.1);
                            let v278 = constructor_and_i128(ctx, v107, v108);
                            let v279 = C::output(ctx, v278);
                            let v280 = Some(v279);
                            // Rule at src/isa/x64/lower.isle line 366.
                            return v280;
                        }
                        if let Some(v90) = v89 {
                            let v59 = C::unpack_value_array_2(ctx, v58);
                            let v93 = constructor_put_in_xmm(ctx, v59.0);
                            let v94 = &C::put_in_xmm_mem(ctx, v59.1);
                            let v275 = constructor_sse_and(ctx, v3, v93, v94);
                            let v276 = constructor_output_xmm(ctx, v275);
                            let v277 = Some(v276);
                            // Rule at src/isa/x64/lower.isle line 349.
                            return v277;
                        }
                        let v270 = C::ty_scalar_float(ctx, v3);
                        if let Some(v271) = v270 {
                            let v59 = C::unpack_value_array_2(ctx, v58);
                            let v93 = constructor_put_in_xmm(ctx, v59.0);
                            let v94 = &C::put_in_xmm_mem(ctx, v59.1);
                            let v272 = constructor_sse_and(ctx, v271, v93, v94);
                            let v273 = constructor_output_xmm(ctx, v272);
                            let v274 = Some(v273);
                            // Rule at src/isa/x64/lower.isle line 337.
                            return v274;
                        }
                        if let Some(v258) = v257 {
                            let v59 = C::unpack_value_array_2(ctx, v58);
                            let v265 = &C::simm32_from_value(ctx, v59.0);
                            if let Some(v266) = v265 {
                                let v84 = constructor_put_in_gpr(ctx, v59.1);
                                let v267 = constructor_x64_and(ctx, v3, v84, v266);
                                let v268 = constructor_output_gpr(ctx, v267);
                                let v269 = Some(v268);
                                // Rule at src/isa/x64/lower.isle line 331.
                                return v269;
                            }
                            let v82 = &C::sinkable_load(ctx, v59.0);
                            if let Some(v83) = v82 {
                                let v84 = constructor_put_in_gpr(ctx, v59.1);
                                let v85 = &constructor_sink_load_to_gpr_mem_imm(ctx, v83);
                                let v262 = constructor_x64_and(ctx, v3, v84, v85);
                                let v263 = constructor_output_gpr(ctx, v262);
                                let v264 = Some(v263);
                                // Rule at src/isa/x64/lower.isle line 327.
                                return v264;
                            }
                            let v62 = constructor_put_in_gpr(ctx, v59.0);
                            let v63 = &constructor_put_in_gpr_mem_imm(ctx, v59.1);
                            let v259 = constructor_x64_and(ctx, v3, v62, v63);
                            let v260 = constructor_output_gpr(ctx, v259);
                            let v261 = Some(v260);
                            // Rule at src/isa/x64/lower.isle line 320.
                            return v261;
                        }
                    }
                }
                &Opcode::Bor => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v59 = C::unpack_value_array_2(ctx, v58);
                        let v120 = C::def_inst(ctx, v59.1);
                        if let Some(v121) = v120 {
                            let v122 = &C::inst_data_value(ctx, v121);
                            if let &InstructionData::Binary {
                                opcode: ref v123,
                                args: ref v124,
                            } = v122 {
                                match v123 {
                                    &Opcode::Ishl => {
                                        let v147 = C::def_inst(ctx, v59.0);
                                        if let Some(v148) = v147 {
                                            let v149 = &C::inst_data_value(ctx, v148);
                                            if let &InstructionData::Binary {
                                                opcode: ref v365,
                                                args: ref v366,
                                            } = v149 {
                                                if let &Opcode::Ushr = v365 {
                                                    let v3 = C::value_type(ctx, v2);
                                                    let v363 = C::ty_int_ref_16_to_64(ctx, v3);
                                                    if let Some(v364) = v363 {
                                                        let v367 = C::unpack_value_array_2(ctx, v366);
                                                        let v370 = C::def_inst(ctx, v367.1);
                                                        if let Some(v371) = v370 {
                                                            let v372 = &C::inst_data_value(ctx, v371);
                                                            if let &InstructionData::UnaryImm {
                                                                opcode: ref v373,
                                                                imm: v374,
                                                            } = v372 {
                                                                if let &Opcode::Iconst = v373 {
                                                                    let v375 = C::u64_from_imm64(ctx, v374);
                                                                    let v376 = C::u64_from_u8(ctx, v375);
                                                                    if let Some(v377) = v376 {
                                                                        let v125 = C::unpack_value_array_2(ctx, v124);
                                                                        let v378 = C::def_inst(ctx, v125.1);
                                                                        if let Some(v379) = v378 {
                                                                            let v380 = &C::inst_data_value(ctx, v379);
                                                                            if let &InstructionData::UnaryImm {
                                                                                opcode: ref v381,
                                                                                imm: v382,
                                                                            } = v380 {
                                                                                if let &Opcode::Iconst = v381 {
                                                                                    let v383 = C::u64_from_imm64(ctx, v382);
                                                                                    let v384 = C::u64_from_u8(ctx, v383);
                                                                                    if let Some(v385) = v384 {
                                                                                        let v388 = C::u8_into_u64(ctx, v377);
                                                                                        let v392 = C::u64_gt(ctx, v388, 0x0_u64);
                                                                                        if v392 == true {
                                                                                            let v389 = C::u8_into_u64(ctx, v385);
                                                                                            let v393 = C::u64_gt(ctx, v389, 0x0_u64);
                                                                                            if v393 == true {
                                                                                                let v386 = C::ty_bits(ctx, v364);
                                                                                                let v387 = C::u8_into_u64(ctx, v386);
                                                                                                let v399 = C::u64_wrapping_add(ctx, v389, v388);
                                                                                                let v400 = C::u64_eq(ctx, v387, v399);
                                                                                                if v400 == true {
                                                                                                    let v401 = constructor_put_in_gpr(ctx, v125.0);
                                                                                                    let v402 = constructor_put_in_gpr(ctx, v367.0);
                                                                                                    let v403 = constructor_x64_shld(ctx, v364, v401, v402, v385);
                                                                                                    let v404 = constructor_output_gpr(ctx, v403);
                                                                                                    let v405 = Some(v404);
                                                                                                    // Rule at src/isa/x64/lower.isle line 502.
                                                                                                    return v405;
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    &Opcode::Ushr => {
                                        let v147 = C::def_inst(ctx, v59.0);
                                        if let Some(v148) = v147 {
                                            let v149 = &C::inst_data_value(ctx, v148);
                                            if let &InstructionData::Binary {
                                                opcode: ref v365,
                                                args: ref v366,
                                            } = v149 {
                                                if let &Opcode::Ishl = v365 {
                                                    let v3 = C::value_type(ctx, v2);
                                                    let v363 = C::ty_int_ref_16_to_64(ctx, v3);
                                                    if let Some(v364) = v363 {
                                                        let v367 = C::unpack_value_array_2(ctx, v366);
                                                        let v370 = C::def_inst(ctx, v367.1);
                                                        if let Some(v371) = v370 {
                                                            let v372 = &C::inst_data_value(ctx, v371);
                                                            if let &InstructionData::UnaryImm {
                                                                opcode: ref v373,
                                                                imm: v374,
                                                            } = v372 {
                                                                if let &Opcode::Iconst = v373 {
                                                                    let v375 = C::u64_from_imm64(ctx, v374);
                                                                    let v376 = C::u64_from_u8(ctx, v375);
                                                                    if let Some(v377) = v376 {
                                                                        let v125 = C::unpack_value_array_2(ctx, v124);
                                                                        let v378 = C::def_inst(ctx, v125.1);
                                                                        if let Some(v379) = v378 {
                                                                            let v380 = &C::inst_data_value(ctx, v379);
                                                                            if let &InstructionData::UnaryImm {
                                                                                opcode: ref v381,
                                                                                imm: v382,
                                                                            } = v380 {
                                                                                if let &Opcode::Iconst = v381 {
                                                                                    let v383 = C::u64_from_imm64(ctx, v382);
                                                                                    let v384 = C::u64_from_u8(ctx, v383);
                                                                                    if let Some(v385) = v384 {
                                                                                        let v386 = C::ty_bits(ctx, v364);
                                                                                        let v387 = C::u8_into_u64(ctx, v386);
                                                                                        let v388 = C::u8_into_u64(ctx, v377);
                                                                                        let v389 = C::u8_into_u64(ctx, v385);
                                                                                        let v390 = C::u64_wrapping_add(ctx, v388, v389);
                                                                                        let v391 = C::u64_eq(ctx, v387, v390);
                                                                                        if v391 == true {
                                                                                            let v392 = C::u64_gt(ctx, v388, 0x0_u64);
                                                                                            if v392 == true {
                                                                                                let v393 = C::u64_gt(ctx, v389, 0x0_u64);
                                                                                                if v393 == true {
                                                                                                    let v394 = constructor_put_in_gpr(ctx, v367.0);
                                                                                                    let v395 = constructor_put_in_gpr(ctx, v125.0);
                                                                                                    let v396 = constructor_x64_shld(ctx, v364, v394, v395, v377);
                                                                                                    let v397 = constructor_output_gpr(ctx, v396);
                                                                                                    let v398 = Some(v397);
                                                                                                    // Rule at src/isa/x64/lower.isle line 496.
                                                                                                    return v398;
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    _ => {}
                                }
                            }
                        }
                        let v3 = C::value_type(ctx, v2);
                        if v3 == I128 {
                            let v107 = C::put_in_regs(ctx, v59.0);
                            let v108 = C::put_in_regs(ctx, v59.1);
                            let v360 = constructor_or_i128(ctx, v107, v108);
                            let v361 = C::output(ctx, v360);
                            let v362 = Some(v361);
                            // Rule at src/isa/x64/lower.isle line 488.
                            return v362;
                        }
                        let v89 = C::multi_lane(ctx, v3);
                        if let Some(v90) = v89 {
                            let v93 = constructor_put_in_xmm(ctx, v59.0);
                            let v94 = &C::put_in_xmm_mem(ctx, v59.1);
                            let v357 = constructor_sse_or(ctx, v3, v93, v94);
                            let v358 = constructor_output_xmm(ctx, v357);
                            let v359 = Some(v358);
                            // Rule at src/isa/x64/lower.isle line 473.
                            return v359;
                        }
                        let v270 = C::ty_scalar_float(ctx, v3);
                        if let Some(v271) = v270 {
                            let v93 = constructor_put_in_xmm(ctx, v59.0);
                            let v94 = &C::put_in_xmm_mem(ctx, v59.1);
                            let v354 = constructor_sse_or(ctx, v271, v93, v94);
                            let v355 = constructor_output_xmm(ctx, v354);
                            let v356 = Some(v355);
                            // Rule at src/isa/x64/lower.isle line 461.
                            return v356;
                        }
                        let v257 = C::ty_int_ref_scalar_64(ctx, v3);
                        if let Some(v258) = v257 {
                            let v265 = &C::simm32_from_value(ctx, v59.0);
                            if let Some(v266) = v265 {
                                let v84 = constructor_put_in_gpr(ctx, v59.1);
                                let v351 = constructor_x64_or(ctx, v3, v84, v266);
                                let v352 = constructor_output_gpr(ctx, v351);
                                let v353 = Some(v352);
                                // Rule at src/isa/x64/lower.isle line 455.
                                return v353;
                            }
                            let v82 = &C::sinkable_load(ctx, v59.0);
                            if let Some(v83) = v82 {
                                let v84 = constructor_put_in_gpr(ctx, v59.1);
                                let v85 = &constructor_sink_load_to_gpr_mem_imm(ctx, v83);
                                let v348 = constructor_x64_or(ctx, v3, v84, v85);
                                let v349 = constructor_output_gpr(ctx, v348);
                                let v350 = Some(v349);
                                // Rule at src/isa/x64/lower.isle line 451.
                                return v350;
                            }
                            let v62 = constructor_put_in_gpr(ctx, v59.0);
                            let v63 = &constructor_put_in_gpr_mem_imm(ctx, v59.1);
                            let v345 = constructor_x64_or(ctx, v3, v62, v63);
                            let v346 = constructor_output_gpr(ctx, v345);
                            let v347 = Some(v346);
                            // Rule at src/isa/x64/lower.isle line 444.
                            return v347;
                        }
                    }
                }
                &Opcode::Bxor => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        let v67 = C::ty_32_or_64(ctx, v3);
                        if let Some(v68) = v67 {
                            let v290 = C::has_bmi1(ctx);
                            if v290 == true {
                                let v59 = C::unpack_value_array_2(ctx, v58);
                                let v306 = constructor_val_minus_one(ctx, v59.0);
                                if let Some(v307) = v306 {
                                    if v59.1 == v307 {
                                        let v308 = &constructor_put_in_gpr_mem(ctx, v59.1);
                                        let v436 = constructor_x64_blsmsk(ctx, v68, v308);
                                        let v437 = constructor_output_gpr(ctx, v436);
                                        let v438 = Some(v437);
                                        // Rule at src/isa/x64/lower.isle line 558.
                                        return v438;
                                    }
                                }
                                let v300 = constructor_val_minus_one(ctx, v59.1);
                                if let Some(v301) = v300 {
                                    if v59.0 == v301 {
                                        let v302 = &constructor_put_in_gpr_mem(ctx, v59.0);
                                        let v433 = constructor_x64_blsmsk(ctx, v68, v302);
                                        let v434 = constructor_output_gpr(ctx, v433);
                                        let v435 = Some(v434);
                                        // Rule at src/isa/x64/lower.isle line 554.
                                        return v435;
                                    }
                                }
                            }
                        }
                        if v3 == I128 {
                            let v59 = C::unpack_value_array_2(ctx, v58);
                            let v107 = C::put_in_regs(ctx, v59.0);
                            let v421 = constructor_value_regs_get_gpr(ctx, v107, 0x0_usize);
                            let v422 = constructor_value_regs_get_gpr(ctx, v107, 0x1_usize);
                            let v423 = C::put_in_regs(ctx, v59.1);
                            let v424 = constructor_value_regs_get_gpr(ctx, v423, 0x0_usize);
                            let v425 = constructor_value_regs_get_gpr(ctx, v423, 0x1_usize);
                            let v426 = &C::gpr_to_gpr_mem_imm(ctx, v424);
                            let v427 = constructor_x64_xor(ctx, I64, v421, v426);
                            let v428 = &C::gpr_to_gpr_mem_imm(ctx, v425);
                            let v429 = constructor_x64_xor(ctx, I64, v422, v428);
                            let v430 = constructor_value_gprs(ctx, v427, v429);
                            let v431 = C::output(ctx, v430);
                            let v432 = Some(v431);
                            // Rule at src/isa/x64/lower.isle line 542.
                            return v432;
                        }
                        let v89 = C::multi_lane(ctx, v3);
                        if let Some(v90) = v89 {
                            let v59 = C::unpack_value_array_2(ctx, v58);
                            let v93 = constructor_put_in_xmm(ctx, v59.0);
                            let v94 = &C::put_in_xmm_mem(ctx, v59.1);
                            let v418 = constructor_x64_xor_vector(ctx, v3, v93, v94);
                            let v419 = constructor_output_xmm(ctx, v418);
                            let v420 = Some(v419);
                            // Rule at src/isa/x64/lower.isle line 537.
                            return v420;
                        }
                        let v270 = C::ty_scalar_float(ctx, v3);
                        if let Some(v271) = v270 {
                            let v59 = C::unpack_value_array_2(ctx, v58);
                            let v93 = constructor_put_in_xmm(ctx, v59.0);
                            let v94 = &C::put_in_xmm_mem(ctx, v59.1);
                            let v415 = constructor_x64_xor_vector(ctx, v271, v93, v94);
                            let v416 = constructor_output_xmm(ctx, v415);
                            let v417 = Some(v416);
                            // Rule at src/isa/x64/lower.isle line 532.
                            return v417;
                        }
                        let v257 = C::ty_int_ref_scalar_64(ctx, v3);
                        if let Some(v258) = v257 {
                            let v59 = C::unpack_value_array_2(ctx, v58);
                            let v265 = &C::simm32_from_value(ctx, v59.0);
                            if let Some(v266) = v265 {
                                let v84 = constructor_put_in_gpr(ctx, v59.1);
                                let v412 = constructor_x64_xor(ctx, v3, v84, v266);
                                let v413 = constructor_output_gpr(ctx, v412);
                                let v414 = Some(v413);
                                // Rule at src/isa/x64/lower.isle line 526.
                                return v414;
                            }
                            let v82 = &C::sinkable_load(ctx, v59.0);
                            if let Some(v83) = v82 {
                                let v84 = constructor_put_in_gpr(ctx, v59.1);
                                let v85 = &constructor_sink_load_to_gpr_mem_imm(ctx, v83);
                                let v409 = constructor_x64_xor(ctx, v3, v84, v85);
                                let v410 = constructor_output_gpr(ctx, v409);
                                let v411 = Some(v410);
                                // Rule at src/isa/x64/lower.isle line 522.
                                return v411;
                            }
                            let v62 = constructor_put_in_gpr(ctx, v59.0);
                            let v63 = &constructor_put_in_gpr_mem_imm(ctx, v59.1);
                            let v406 = constructor_x64_xor(ctx, v3, v62, v63);
                            let v407 = constructor_output_gpr(ctx, v406);
                            let v408 = Some(v407);
                            // Rule at src/isa/x64/lower.isle line 515.
                            return v408;
                        }
                    }
                }
                &Opcode::Rotl => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        if v3 == I128 {
                            let v59 = C::unpack_value_array_2(ctx, v58);
                            let v107 = C::put_in_regs(ctx, v59.0);
                            let v557 = constructor_lo_gpr(ctx, v59.1);
                            let v558 = constructor_shl_i128(ctx, v107, v557);
                            let v560 = constructor_imm(ctx, I64, 0x80_u64);
                            let v561 = C::gpr_new(ctx, v560);
                            let v562 = &C::gpr_to_gpr_mem_imm(ctx, v557);
                            let v563 = constructor_x64_sub(ctx, I64, v561, v562);
                            let v564 = constructor_shr_i128(ctx, v107, v563);
                            let v565 = constructor_or_i128(ctx, v558, v564);
                            let v566 = C::output(ctx, v565);
                            let v567 = Some(v566);
                            // Rule at src/isa/x64/lower.isle line 963.
                            return v567;
                        }
                        let v4 = C::fits_in_64(ctx, v3);
                        if let Some(v5) = v4 {
                            let v59 = C::unpack_value_array_2(ctx, v58);
                            let v62 = constructor_put_in_gpr(ctx, v59.0);
                            let v439 = &constructor_put_masked_in_imm8_gpr(ctx, v59.1, v5);
                            let v554 = constructor_x64_rotl(ctx, v5, v62, v439);
                            let v555 = constructor_output_gpr(ctx, v554);
                            let v556 = Some(v555);
                            // Rule at src/isa/x64/lower.isle line 957.
                            return v556;
                        }
                    }
                }
                &Opcode::Rotr => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        if v3 == I128 {
                            let v59 = C::unpack_value_array_2(ctx, v58);
                            let v107 = C::put_in_regs(ctx, v59.0);
                            let v557 = constructor_lo_gpr(ctx, v59.1);
                            let v571 = constructor_shr_i128(ctx, v107, v557);
                            let v560 = constructor_imm(ctx, I64, 0x80_u64);
                            let v561 = C::gpr_new(ctx, v560);
                            let v562 = &C::gpr_to_gpr_mem_imm(ctx, v557);
                            let v563 = constructor_x64_sub(ctx, I64, v561, v562);
                            let v572 = constructor_shl_i128(ctx, v107, v563);
                            let v573 = constructor_or_i128(ctx, v571, v572);
                            let v574 = C::output(ctx, v573);
                            let v575 = Some(v574);
                            // Rule at src/isa/x64/lower.isle line 984.
                            return v575;
                        }
                        let v4 = C::fits_in_64(ctx, v3);
                        if let Some(v5) = v4 {
                            let v59 = C::unpack_value_array_2(ctx, v58);
                            let v62 = constructor_put_in_gpr(ctx, v59.0);
                            let v439 = &constructor_put_masked_in_imm8_gpr(ctx, v59.1, v5);
                            let v568 = constructor_x64_rotr(ctx, v5, v62, v439);
                            let v569 = constructor_output_gpr(ctx, v568);
                            let v570 = Some(v569);
                            // Rule at src/isa/x64/lower.isle line 978.
                            return v570;
                        }
                    }
                }
                &Opcode::Ishl => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        match v3 {
                            I128 => {
                                let v59 = C::unpack_value_array_2(ctx, v58);
                                let v443 = constructor_lo_gpr(ctx, v59.1);
                                let v128 = C::put_in_regs(ctx, v59.0);
                                let v444 = constructor_shl_i128(ctx, v128, v443);
                                let v445 = C::output(ctx, v444);
                                let v446 = Some(v445);
                                // Rule at src/isa/x64/lower.isle line 604.
                                return v446;
                            }
                            I8X16 => {
                                let v59 = C::unpack_value_array_2(ctx, v58);
                                let v447 = &constructor_mask_xmm_shift(ctx, v3, v59.1);
                                let v448 = constructor_put_in_xmm(ctx, v59.0);
                                let v449 = &constructor_mov_rmi_to_xmm(ctx, v447);
                                let v450 = constructor_x64_psllw(ctx, v448, v449);
                                let v451 = &constructor_ishl_i8x16_mask(ctx, v447);
                                let v454 = constructor_x64_load(ctx, I8X16, v451, &ExtKind::None);
                                let v455 = RegMem::Reg {
                                    reg: v454,
                                };
                                let v456 = &C::reg_mem_to_xmm_mem(ctx, &v455);
                                let v457 = constructor_sse_and(ctx, I8X16, v450, v456);
                                let v458 = constructor_output_xmm(ctx, v457);
                                let v459 = Some(v458);
                                // Rule at src/isa/x64/lower.isle line 616.
                                return v459;
                            }
                            I16X8 => {
                                let v59 = C::unpack_value_array_2(ctx, v58);
                                let v93 = constructor_put_in_xmm(ctx, v59.0);
                                let v460 = &constructor_mask_xmm_shift(ctx, v3, v59.1);
                                let v461 = &constructor_mov_rmi_to_xmm(ctx, v460);
                                let v462 = constructor_x64_psllw(ctx, v93, v461);
                                let v463 = constructor_output_xmm(ctx, v462);
                                let v464 = Some(v463);
                                // Rule at src/isa/x64/lower.isle line 662.
                                return v464;
                            }
                            I32X4 => {
                                let v59 = C::unpack_value_array_2(ctx, v58);
                                let v93 = constructor_put_in_xmm(ctx, v59.0);
                                let v460 = &constructor_mask_xmm_shift(ctx, v3, v59.1);
                                let v461 = &constructor_mov_rmi_to_xmm(ctx, v460);
                                let v465 = constructor_x64_pslld(ctx, v93, v461);
                                let v466 = constructor_output_xmm(ctx, v465);
                                let v467 = Some(v466);
                                // Rule at src/isa/x64/lower.isle line 665.
                                return v467;
                            }
                            I64X2 => {
                                let v59 = C::unpack_value_array_2(ctx, v58);
                                let v93 = constructor_put_in_xmm(ctx, v59.0);
                                let v460 = &constructor_mask_xmm_shift(ctx, v3, v59.1);
                                let v461 = &constructor_mov_rmi_to_xmm(ctx, v460);
                                let v468 = constructor_x64_psllq(ctx, v93, v461);
                                let v469 = constructor_output_xmm(ctx, v468);
                                let v470 = Some(v469);
                                // Rule at src/isa/x64/lower.isle line 668.
                                return v470;
                            }
                            _ => {}
                        }
                        let v4 = C::fits_in_64(ctx, v3);
                        if let Some(v5) = v4 {
                            let v59 = C::unpack_value_array_2(ctx, v58);
                            let v62 = constructor_put_in_gpr(ctx, v59.0);
                            let v439 = &constructor_put_masked_in_imm8_gpr(ctx, v59.1, v5);
                            let v440 = constructor_x64_shl(ctx, v5, v62, v439);
                            let v441 = constructor_output_gpr(ctx, v440);
                            let v442 = Some(v441);
                            // Rule at src/isa/x64/lower.isle line 567.
                            return v442;
                        }
                    }
                }
                &Opcode::Ushr => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        match v3 {
                            I128 => {
                                let v59 = C::unpack_value_array_2(ctx, v58);
                                let v443 = constructor_lo_gpr(ctx, v59.1);
                                let v128 = C::put_in_regs(ctx, v59.0);
                                let v475 = constructor_shr_i128(ctx, v128, v443);
                                let v476 = C::output(ctx, v475);
                                let v477 = Some(v476);
                                // Rule at src/isa/x64/lower.isle line 712.
                                return v477;
                            }
                            I8X16 => {
                                let v59 = C::unpack_value_array_2(ctx, v58);
                                let v447 = &constructor_mask_xmm_shift(ctx, v3, v59.1);
                                let v448 = constructor_put_in_xmm(ctx, v59.0);
                                let v449 = &constructor_mov_rmi_to_xmm(ctx, v447);
                                let v478 = constructor_x64_psrlw(ctx, v448, v449);
                                let v479 = &constructor_ushr_i8x16_mask(ctx, v447);
                                let v480 = &constructor_synthetic_amode_to_xmm_mem(ctx, v479);
                                let v481 = constructor_sse_and(ctx, I8X16, v478, v480);
                                let v482 = constructor_output_xmm(ctx, v481);
                                let v483 = Some(v482);
                                // Rule at src/isa/x64/lower.isle line 722.
                                return v483;
                            }
                            I16X8 => {
                                let v59 = C::unpack_value_array_2(ctx, v58);
                                let v93 = constructor_put_in_xmm(ctx, v59.0);
                                let v460 = &constructor_mask_xmm_shift(ctx, v3, v59.1);
                                let v461 = &constructor_mov_rmi_to_xmm(ctx, v460);
                                let v484 = constructor_x64_psrlw(ctx, v93, v461);
                                let v485 = constructor_output_xmm(ctx, v484);
                                let v486 = Some(v485);
                                // Rule at src/isa/x64/lower.isle line 768.
                                return v486;
                            }
                            I32X4 => {
                                let v59 = C::unpack_value_array_2(ctx, v58);
                                let v93 = constructor_put_in_xmm(ctx, v59.0);
                                let v460 = &constructor_mask_xmm_shift(ctx, v3, v59.1);
                                let v461 = &constructor_mov_rmi_to_xmm(ctx, v460);
                                let v487 = constructor_x64_psrld(ctx, v93, v461);
                                let v488 = constructor_output_xmm(ctx, v487);
                                let v489 = Some(v488);
                                // Rule at src/isa/x64/lower.isle line 771.
                                return v489;
                            }
                            I64X2 => {
                                let v59 = C::unpack_value_array_2(ctx, v58);
                                let v93 = constructor_put_in_xmm(ctx, v59.0);
                                let v460 = &constructor_mask_xmm_shift(ctx, v3, v59.1);
                                let v461 = &constructor_mov_rmi_to_xmm(ctx, v460);
                                let v490 = constructor_x64_psrlq(ctx, v93, v461);
                                let v491 = constructor_output_xmm(ctx, v490);
                                let v492 = Some(v491);
                                // Rule at src/isa/x64/lower.isle line 774.
                                return v492;
                            }
                            _ => {}
                        }
                        let v4 = C::fits_in_64(ctx, v3);
                        if let Some(v5) = v4 {
                            let v59 = C::unpack_value_array_2(ctx, v58);
                            let v471 = constructor_extend_to_gpr(ctx, v59.0, v5, &ExtendKind::Zero);
                            let v439 = &constructor_put_masked_in_imm8_gpr(ctx, v59.1, v5);
                            let v472 = constructor_x64_shr(ctx, v5, v471, v439);
                            let v473 = constructor_output_gpr(ctx, v472);
                            let v474 = Some(v473);
                            // Rule at src/isa/x64/lower.isle line 675.
                            return v474;
                        }
                    }
                }
                &Opcode::Sshr => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        match v3 {
                            I128 => {
                                let v59 = C::unpack_value_array_2(ctx, v58);
                                let v443 = constructor_lo_gpr(ctx, v59.1);
                                let v128 = C::put_in_regs(ctx, v59.0);
                                let v498 = constructor_sar_i128(ctx, v128, v443);
                                let v499 = C::output(ctx, v498);
                                let v500 = Some(v499);
                                // Rule at src/isa/x64/lower.isle line 824.
                                return v500;
                            }
                            I8X16 => {
                                let v59 = C::unpack_value_array_2(ctx, v58);
                                let v93 = constructor_put_in_xmm(ctx, v59.0);
                                let v460 = &constructor_mask_xmm_shift(ctx, v3, v59.1);
                                let v501 = &C::xmm_to_xmm_mem(ctx, v93);
                                let v502 = constructor_x64_punpcklbw(ctx, v93, v501);
                                let v503 = &C::xmm_to_xmm_mem(ctx, v93);
                                let v504 = constructor_x64_punpckhbw(ctx, v93, v503);
                                let v168 = C::value_type(ctx, v59.1);
                                let v505 = &constructor_sshr_i8x16_bigger_shift(ctx, v168, v460);
                                let v506 = constructor_x64_psraw(ctx, v502, v505);
                                let v507 = constructor_x64_psraw(ctx, v504, v505);
                                let v508 = &C::xmm_to_xmm_mem(ctx, v507);
                                let v509 = constructor_x64_packsswb(ctx, v506, v508);
                                let v510 = constructor_output_xmm(ctx, v509);
                                let v511 = Some(v510);
                                // Rule at src/isa/x64/lower.isle line 845.
                                return v511;
                            }
                            I16X8 => {
                                let v59 = C::unpack_value_array_2(ctx, v58);
                                let v93 = constructor_put_in_xmm(ctx, v59.0);
                                let v460 = &constructor_mask_xmm_shift(ctx, v3, v59.1);
                                let v461 = &constructor_mov_rmi_to_xmm(ctx, v460);
                                let v512 = constructor_x64_psraw(ctx, v93, v461);
                                let v513 = constructor_output_xmm(ctx, v512);
                                let v514 = Some(v513);
                                // Rule at src/isa/x64/lower.isle line 874.
                                return v514;
                            }
                            I32X4 => {
                                let v59 = C::unpack_value_array_2(ctx, v58);
                                let v93 = constructor_put_in_xmm(ctx, v59.0);
                                let v460 = &constructor_mask_xmm_shift(ctx, v3, v59.1);
                                let v461 = &constructor_mov_rmi_to_xmm(ctx, v460);
                                let v515 = constructor_x64_psrad(ctx, v93, v461);
                                let v516 = constructor_output_xmm(ctx, v515);
                                let v517 = Some(v516);
                                // Rule at src/isa/x64/lower.isle line 877.
                                return v517;
                            }
                            I64X2 => {
                                let v520 = C::has_avx512vl(ctx);
                                if v520 == true {
                                    let v521 = C::has_avx512f(ctx);
                                    if v521 == true {
                                        let v59 = C::unpack_value_array_2(ctx, v58);
                                        let v120 = C::def_inst(ctx, v59.1);
                                        if let Some(v121) = v120 {
                                            let v122 = &C::inst_data_value(ctx, v121);
                                            if let &InstructionData::UnaryImm {
                                                opcode: ref v518,
                                                imm: v519,
                                            } = v122 {
                                                if let &Opcode::Iconst = v518 {
                                                    let v522 = &C::put_in_xmm_mem(ctx, v59.0);
                                                    let v523 = C::shift_amount_masked(ctx, v3, v519);
                                                    let v524 = constructor_x64_vpsraq_imm(ctx, v522, v523);
                                                    let v525 = constructor_output_xmm(ctx, v524);
                                                    let v526 = Some(v525);
                                                    // Rule at src/isa/x64/lower.isle line 883.
                                                    return v526;
                                                }
                                            }
                                        }
                                        let v84 = constructor_put_in_gpr(ctx, v59.1);
                                        let v527 = C::shift_mask(ctx, v3);
                                        let v528 = C::u8_into_u32(ctx, v527);
                                        let v529 = RegMemImm::Imm {
                                            simm32: v528,
                                        };
                                        let v530 = &C::gpr_mem_imm_new(ctx, &v529);
                                        let v531 = constructor_x64_and(ctx, I64, v84, v530);
                                        let v532 = constructor_put_in_xmm(ctx, v59.0);
                                        let v533 = &C::gpr_to_gpr_mem(ctx, v531);
                                        let v534 = constructor_x64_movd_to_xmm(ctx, v533);
                                        let v535 = &C::xmm_to_xmm_mem(ctx, v534);
                                        let v536 = constructor_x64_vpsraq(ctx, v532, v535);
                                        let v537 = constructor_output_xmm(ctx, v536);
                                        let v538 = Some(v537);
                                        // Rule at src/isa/x64/lower.isle line 888.
                                        return v538;
                                    }
                                }
                                let v59 = C::unpack_value_array_2(ctx, v58);
                                let v120 = C::def_inst(ctx, v59.1);
                                if let Some(v121) = v120 {
                                    let v122 = &C::inst_data_value(ctx, v121);
                                    if let &InstructionData::UnaryImm {
                                        opcode: ref v518,
                                        imm: v519,
                                    } = v122 {
                                        if let &Opcode::Iconst = v518 {
                                            let v539 = C::u64_from_imm64(ctx, v519);
                                            let v540 = C::u64_from_u32(ctx, v539);
                                            if let Some(v541) = v540 {
                                                let v93 = constructor_put_in_xmm(ctx, v59.0);
                                                let v543 = C::u32_and(ctx, v541, 0x3f_u32);
                                                let v544 = constructor_lower_i64x2_sshr_imm(ctx, v93, v543);
                                                let v545 = constructor_output_xmm(ctx, v544);
                                                let v546 = Some(v545);
                                                // Rule at src/isa/x64/lower.isle line 894.
                                                return v546;
                                            }
                                        }
                                    }
                                }
                                let v93 = constructor_put_in_xmm(ctx, v59.0);
                                let v547 = constructor_put_in_gpr(ctx, v59.1);
                                let v548 = RegMemImm::Imm {
                                    simm32: 0x3f_u32,
                                };
                                let v549 = &C::gpr_mem_imm_new(ctx, &v548);
                                let v550 = constructor_x64_and(ctx, I64, v547, v549);
                                let v551 = constructor_lower_i64x2_sshr_gpr(ctx, v93, v550);
                                let v552 = constructor_output_xmm(ctx, v551);
                                let v553 = Some(v552);
                                // Rule at src/isa/x64/lower.isle line 897.
                                return v553;
                            }
                            _ => {}
                        }
                        let v4 = C::fits_in_64(ctx, v3);
                        if let Some(v5) = v4 {
                            let v59 = C::unpack_value_array_2(ctx, v58);
                            let v494 = constructor_extend_to_gpr(ctx, v59.0, v5, &ExtendKind::Sign);
                            let v439 = &constructor_put_masked_in_imm8_gpr(ctx, v59.1, v5);
                            let v495 = constructor_x64_sar(ctx, v5, v494, v439);
                            let v496 = constructor_output_gpr(ctx, v495);
                            let v497 = Some(v496);
                            // Rule at src/isa/x64/lower.isle line 787.
                            return v497;
                        }
                    }
                }
                &Opcode::Fadd => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        match v3 {
                            F32 => {
                                let v59 = C::unpack_value_array_2(ctx, v58);
                                let v82 = &C::sinkable_load(ctx, v59.0);
                                if let Some(v83) = v82 {
                                    let v1760 = constructor_put_in_xmm(ctx, v59.1);
                                    let v1776 = &constructor_sink_load_to_xmm_mem(ctx, v83);
                                    let v1777 = constructor_x64_addss(ctx, v1760, v1776);
                                    let v1778 = constructor_output_xmm(ctx, v1777);
                                    let v1779 = Some(v1778);
                                    // Rule at src/isa/x64/lower.isle line 2684.
                                    return v1779;
                                }
                                let v93 = constructor_put_in_xmm(ctx, v59.0);
                                let v94 = &C::put_in_xmm_mem(ctx, v59.1);
                                let v1764 = constructor_x64_addss(ctx, v93, v94);
                                let v1765 = constructor_output_xmm(ctx, v1764);
                                let v1766 = Some(v1765);
                                // Rule at src/isa/x64/lower.isle line 2673.
                                return v1766;
                            }
                            F64 => {
                                let v59 = C::unpack_value_array_2(ctx, v58);
                                let v82 = &C::sinkable_load(ctx, v59.0);
                                if let Some(v83) = v82 {
                                    let v1760 = constructor_put_in_xmm(ctx, v59.1);
                                    let v1776 = &constructor_sink_load_to_xmm_mem(ctx, v83);
                                    let v1780 = constructor_x64_addsd(ctx, v1760, v1776);
                                    let v1781 = constructor_output_xmm(ctx, v1780);
                                    let v1782 = Some(v1781);
                                    // Rule at src/isa/x64/lower.isle line 2686.
                                    return v1782;
                                }
                                let v93 = constructor_put_in_xmm(ctx, v59.0);
                                let v94 = &C::put_in_xmm_mem(ctx, v59.1);
                                let v1767 = constructor_x64_addsd(ctx, v93, v94);
                                let v1768 = constructor_output_xmm(ctx, v1767);
                                let v1769 = Some(v1768);
                                // Rule at src/isa/x64/lower.isle line 2675.
                                return v1769;
                            }
                            F32X4 => {
                                let v59 = C::unpack_value_array_2(ctx, v58);
                                let v82 = &C::sinkable_load(ctx, v59.0);
                                if let Some(v83) = v82 {
                                    let v1760 = constructor_put_in_xmm(ctx, v59.1);
                                    let v1776 = &constructor_sink_load_to_xmm_mem(ctx, v83);
                                    let v1783 = constructor_x64_addps(ctx, v1760, v1776);
                                    let v1784 = constructor_output_xmm(ctx, v1783);
                                    let v1785 = Some(v1784);
                                    // Rule at src/isa/x64/lower.isle line 2688.
                                    return v1785;
                                }
                                let v93 = constructor_put_in_xmm(ctx, v59.0);
                                let v94 = &C::put_in_xmm_mem(ctx, v59.1);
                                let v1770 = constructor_x64_addps(ctx, v93, v94);
                                let v1771 = constructor_output_xmm(ctx, v1770);
                                let v1772 = Some(v1771);
                                // Rule at src/isa/x64/lower.isle line 2677.
                                return v1772;
                            }
                            F64X2 => {
                                let v59 = C::unpack_value_array_2(ctx, v58);
                                let v82 = &C::sinkable_load(ctx, v59.0);
                                if let Some(v83) = v82 {
                                    let v1760 = constructor_put_in_xmm(ctx, v59.1);
                                    let v1776 = &constructor_sink_load_to_xmm_mem(ctx, v83);
                                    let v1786 = constructor_x64_addpd(ctx, v1760, v1776);
                                    let v1787 = constructor_output_xmm(ctx, v1786);
                                    let v1788 = Some(v1787);
                                    // Rule at src/isa/x64/lower.isle line 2690.
                                    return v1788;
                                }
                                let v93 = constructor_put_in_xmm(ctx, v59.0);
                                let v94 = &C::put_in_xmm_mem(ctx, v59.1);
                                let v1773 = constructor_x64_addpd(ctx, v93, v94);
                                let v1774 = constructor_output_xmm(ctx, v1773);
                                let v1775 = Some(v1774);
                                // Rule at src/isa/x64/lower.isle line 2679.
                                return v1775;
                            }
                            _ => {}
                        }
                    }
                }
                &Opcode::Fsub => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        match v3 {
                            F32 => {
                                let v59 = C::unpack_value_array_2(ctx, v58);
                                let v93 = constructor_put_in_xmm(ctx, v59.0);
                                let v94 = &C::put_in_xmm_mem(ctx, v59.1);
                                let v1789 = constructor_x64_subss(ctx, v93, v94);
                                let v1790 = constructor_output_xmm(ctx, v1789);
                                let v1791 = Some(v1790);
                                // Rule at src/isa/x64/lower.isle line 2695.
                                return v1791;
                            }
                            F64 => {
                                let v59 = C::unpack_value_array_2(ctx, v58);
                                let v93 = constructor_put_in_xmm(ctx, v59.0);
                                let v94 = &C::put_in_xmm_mem(ctx, v59.1);
                                let v1792 = constructor_x64_subsd(ctx, v93, v94);
                                let v1793 = constructor_output_xmm(ctx, v1792);
                                let v1794 = Some(v1793);
                                // Rule at src/isa/x64/lower.isle line 2697.
                                return v1794;
                            }
                            F32X4 => {
                                let v59 = C::unpack_value_array_2(ctx, v58);
                                let v93 = constructor_put_in_xmm(ctx, v59.0);
                                let v94 = &C::put_in_xmm_mem(ctx, v59.1);
                                let v1795 = constructor_x64_subps(ctx, v93, v94);
                                let v1796 = constructor_output_xmm(ctx, v1795);
                                let v1797 = Some(v1796);
                                // Rule at src/isa/x64/lower.isle line 2699.
                                return v1797;
                            }
                            F64X2 => {
                                let v59 = C::unpack_value_array_2(ctx, v58);
                                let v93 = constructor_put_in_xmm(ctx, v59.0);
                                let v94 = &C::put_in_xmm_mem(ctx, v59.1);
                                let v1798 = constructor_x64_subpd(ctx, v93, v94);
                                let v1799 = constructor_output_xmm(ctx, v1798);
                                let v1800 = Some(v1799);
                                // Rule at src/isa/x64/lower.isle line 2701.
                                return v1800;
                            }
                            _ => {}
                        }
                    }
                }
                &Opcode::Fmul => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        match v3 {
                            F32 => {
                                let v59 = C::unpack_value_array_2(ctx, v58);
                                let v82 = &C::sinkable_load(ctx, v59.0);
                                if let Some(v83) = v82 {
                                    let v1760 = constructor_put_in_xmm(ctx, v59.1);
                                    let v1776 = &constructor_sink_load_to_xmm_mem(ctx, v83);
                                    let v1813 = constructor_x64_mulss(ctx, v1760, v1776);
                                    let v1814 = constructor_output_xmm(ctx, v1813);
                                    let v1815 = Some(v1814);
                                    // Rule at src/isa/x64/lower.isle line 2717.
                                    return v1815;
                                }
                                let v93 = constructor_put_in_xmm(ctx, v59.0);
                                let v94 = &C::put_in_xmm_mem(ctx, v59.1);
                                let v1801 = constructor_x64_mulss(ctx, v93, v94);
                                let v1802 = constructor_output_xmm(ctx, v1801);
                                let v1803 = Some(v1802);
                                // Rule at src/isa/x64/lower.isle line 2706.
                                return v1803;
                            }
                            F64 => {
                                let v59 = C::unpack_value_array_2(ctx, v58);
                                let v82 = &C::sinkable_load(ctx, v59.0);
                                if let Some(v83) = v82 {
                                    let v1760 = constructor_put_in_xmm(ctx, v59.1);
                                    let v1776 = &constructor_sink_load_to_xmm_mem(ctx, v83);
                                    let v1816 = constructor_x64_mulsd(ctx, v1760, v1776);
                                    let v1817 = constructor_output_xmm(ctx, v1816);
                                    let v1818 = Some(v1817);
                                    // Rule at src/isa/x64/lower.isle line 2719.
                                    return v1818;
                                }
                                let v93 = constructor_put_in_xmm(ctx, v59.0);
                                let v94 = &C::put_in_xmm_mem(ctx, v59.1);
                                let v1804 = constructor_x64_mulsd(ctx, v93, v94);
                                let v1805 = constructor_output_xmm(ctx, v1804);
                                let v1806 = Some(v1805);
                                // Rule at src/isa/x64/lower.isle line 2708.
                                return v1806;
                            }
                            F32X4 => {
                                let v59 = C::unpack_value_array_2(ctx, v58);
                                let v82 = &C::sinkable_load(ctx, v59.0);
                                if let Some(v83) = v82 {
                                    let v1760 = constructor_put_in_xmm(ctx, v59.1);
                                    let v1776 = &constructor_sink_load_to_xmm_mem(ctx, v83);
                                    let v1819 = constructor_x64_mulps(ctx, v1760, v1776);
                                    let v1820 = constructor_output_xmm(ctx, v1819);
                                    let v1821 = Some(v1820);
                                    // Rule at src/isa/x64/lower.isle line 2721.
                                    return v1821;
                                }
                                let v93 = constructor_put_in_xmm(ctx, v59.0);
                                let v94 = &C::put_in_xmm_mem(ctx, v59.1);
                                let v1807 = constructor_x64_mulps(ctx, v93, v94);
                                let v1808 = constructor_output_xmm(ctx, v1807);
                                let v1809 = Some(v1808);
                                // Rule at src/isa/x64/lower.isle line 2710.
                                return v1809;
                            }
                            F64X2 => {
                                let v59 = C::unpack_value_array_2(ctx, v58);
                                let v82 = &C::sinkable_load(ctx, v59.0);
                                if let Some(v83) = v82 {
                                    let v1760 = constructor_put_in_xmm(ctx, v59.1);
                                    let v1776 = &constructor_sink_load_to_xmm_mem(ctx, v83);
                                    let v1822 = constructor_x64_mulpd(ctx, v1760, v1776);
                                    let v1823 = constructor_output_xmm(ctx, v1822);
                                    let v1824 = Some(v1823);
                                    // Rule at src/isa/x64/lower.isle line 2723.
                                    return v1824;
                                }
                                let v93 = constructor_put_in_xmm(ctx, v59.0);
                                let v94 = &C::put_in_xmm_mem(ctx, v59.1);
                                let v1810 = constructor_x64_mulpd(ctx, v93, v94);
                                let v1811 = constructor_output_xmm(ctx, v1810);
                                let v1812 = Some(v1811);
                                // Rule at src/isa/x64/lower.isle line 2712.
                                return v1812;
                            }
                            _ => {}
                        }
                    }
                }
                &Opcode::Fdiv => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        match v3 {
                            F32 => {
                                let v59 = C::unpack_value_array_2(ctx, v58);
                                let v93 = constructor_put_in_xmm(ctx, v59.0);
                                let v94 = &C::put_in_xmm_mem(ctx, v59.1);
                                let v1825 = constructor_x64_divss(ctx, v93, v94);
                                let v1826 = constructor_output_xmm(ctx, v1825);
                                let v1827 = Some(v1826);
                                // Rule at src/isa/x64/lower.isle line 2728.
                                return v1827;
                            }
                            F64 => {
                                let v59 = C::unpack_value_array_2(ctx, v58);
                                let v93 = constructor_put_in_xmm(ctx, v59.0);
                                let v94 = &C::put_in_xmm_mem(ctx, v59.1);
                                let v1828 = constructor_x64_divsd(ctx, v93, v94);
                                let v1829 = constructor_output_xmm(ctx, v1828);
                                let v1830 = Some(v1829);
                                // Rule at src/isa/x64/lower.isle line 2730.
                                return v1830;
                            }
                            F32X4 => {
                                let v59 = C::unpack_value_array_2(ctx, v58);
                                let v93 = constructor_put_in_xmm(ctx, v59.0);
                                let v94 = &C::put_in_xmm_mem(ctx, v59.1);
                                let v1831 = constructor_x64_divps(ctx, v93, v94);
                                let v1832 = constructor_output_xmm(ctx, v1831);
                                let v1833 = Some(v1832);
                                // Rule at src/isa/x64/lower.isle line 2732.
                                return v1833;
                            }
                            F64X2 => {
                                let v59 = C::unpack_value_array_2(ctx, v58);
                                let v93 = constructor_put_in_xmm(ctx, v59.0);
                                let v94 = &C::put_in_xmm_mem(ctx, v59.1);
                                let v1834 = constructor_x64_divpd(ctx, v93, v94);
                                let v1835 = constructor_output_xmm(ctx, v1834);
                                let v1836 = Some(v1835);
                                // Rule at src/isa/x64/lower.isle line 2734.
                                return v1836;
                            }
                            _ => {}
                        }
                    }
                }
                &Opcode::Fcopysign => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        match v3 {
                            F32 => {
                                let v59 = C::unpack_value_array_2(ctx, v58);
                                let v2894 = C::value_type(ctx, v59.0);
                                if v2894 == F32 {
                                    let v2958 = constructor_imm(ctx, F32, 0x80000000_u64);
                                    let v2959 = C::xmm_new(ctx, v2958);
                                    let v2960 = constructor_put_in_xmm(ctx, v59.0);
                                    let v2961 = constructor_put_in_xmm(ctx, v59.1);
                                    let v2962 = &C::xmm_to_xmm_mem(ctx, v2960);
                                    let v2963 = constructor_x64_andnps(ctx, v2959, v2962);
                                    let v2964 = &C::xmm_to_xmm_mem(ctx, v2961);
                                    let v2965 = constructor_x64_andps(ctx, v2959, v2964);
                                    let v2966 = &C::xmm_to_xmm_mem(ctx, v2965);
                                    let v2967 = constructor_x64_orps(ctx, v2963, v2966);
                                    let v2968 = constructor_output_xmm(ctx, v2967);
                                    let v2969 = Some(v2968);
                                    // Rule at src/isa/x64/lower.isle line 4299.
                                    return v2969;
                                }
                            }
                            F64 => {
                                let v59 = C::unpack_value_array_2(ctx, v58);
                                let v2894 = C::value_type(ctx, v59.0);
                                if v2894 == F64 {
                                    let v2970 = constructor_imm(ctx, F64, 0x8000000000000000_u64);
                                    let v2971 = C::xmm_new(ctx, v2970);
                                    let v2960 = constructor_put_in_xmm(ctx, v59.0);
                                    let v2961 = constructor_put_in_xmm(ctx, v59.1);
                                    let v2962 = &C::xmm_to_xmm_mem(ctx, v2960);
                                    let v2972 = constructor_x64_andnpd(ctx, v2971, v2962);
                                    let v2964 = &C::xmm_to_xmm_mem(ctx, v2961);
                                    let v2973 = constructor_x64_andpd(ctx, v2971, v2964);
                                    let v2974 = &C::xmm_to_xmm_mem(ctx, v2973);
                                    let v2975 = constructor_x64_orpd(ctx, v2972, v2974);
                                    let v2976 = constructor_output_xmm(ctx, v2975);
                                    let v2977 = Some(v2976);
                                    // Rule at src/isa/x64/lower.isle line 4307.
                                    return v2977;
                                }
                            }
                            _ => {}
                        }
                    }
                }
                &Opcode::Fmin => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        match v3 {
                            F32 => {
                                let v59 = C::unpack_value_array_2(ctx, v58);
                                let v93 = constructor_put_in_xmm(ctx, v59.0);
                                let v682 = constructor_put_in_xmm(ctx, v59.1);
                                let v202 = true;
                                let v1867 = constructor_xmm_min_max_seq(ctx, F32, v202, v93, v682);
                                let v1868 = constructor_output_xmm(ctx, v1867);
                                let v1869 = Some(v1868);
                                // Rule at src/isa/x64/lower.isle line 2765.
                                return v1869;
                            }
                            F64 => {
                                let v59 = C::unpack_value_array_2(ctx, v58);
                                let v93 = constructor_put_in_xmm(ctx, v59.0);
                                let v682 = constructor_put_in_xmm(ctx, v59.1);
                                let v202 = true;
                                let v1870 = constructor_xmm_min_max_seq(ctx, F64, v202, v93, v682);
                                let v1871 = constructor_output_xmm(ctx, v1870);
                                let v1872 = Some(v1871);
                                // Rule at src/isa/x64/lower.isle line 2767.
                                return v1872;
                            }
                            F32X4 => {
                                let v59 = C::unpack_value_array_2(ctx, v58);
                                let v93 = constructor_put_in_xmm(ctx, v59.0);
                                let v682 = constructor_put_in_xmm(ctx, v59.1);
                                let v1873 = &C::xmm_to_xmm_mem(ctx, v682);
                                let v1874 = constructor_x64_minps(ctx, v93, v1873);
                                let v503 = &C::xmm_to_xmm_mem(ctx, v93);
                                let v1875 = constructor_x64_minps(ctx, v682, v503);
                                let v1876 = &C::xmm_to_xmm_mem(ctx, v1875);
                                let v1877 = constructor_x64_orps(ctx, v1874, v1876);
                                let v1878 = &C::xmm_to_xmm_mem(ctx, v1875);
                                let v1879 = constructor_x64_cmpps(ctx, v1877, v1878, &FcmpImm::Unordered);
                                let v1880 = &C::xmm_to_xmm_mem(ctx, v1879);
                                let v1881 = constructor_x64_orps(ctx, v1877, v1880);
                                let v1883 = &C::xmi_imm(ctx, 0xa_u32);
                                let v1884 = constructor_x64_psrld(ctx, v1879, v1883);
                                let v1885 = &C::xmm_to_xmm_mem(ctx, v1881);
                                let v1886 = constructor_x64_andnps(ctx, v1884, v1885);
                                let v1887 = constructor_output_xmm(ctx, v1886);
                                let v1888 = Some(v1887);
                                // Rule at src/isa/x64/lower.isle line 2782.
                                return v1888;
                            }
                            F64X2 => {
                                let v59 = C::unpack_value_array_2(ctx, v58);
                                let v93 = constructor_put_in_xmm(ctx, v59.0);
                                let v682 = constructor_put_in_xmm(ctx, v59.1);
                                let v1873 = &C::xmm_to_xmm_mem(ctx, v682);
                                let v1889 = constructor_x64_minpd(ctx, v93, v1873);
                                let v503 = &C::xmm_to_xmm_mem(ctx, v93);
                                let v1890 = constructor_x64_minpd(ctx, v682, v503);
                                let v1891 = &C::xmm_to_xmm_mem(ctx, v1890);
                                let v1892 = constructor_x64_orpd(ctx, v1889, v1891);
                                let v1893 = &C::xmm_to_xmm_mem(ctx, v1890);
                                let v1894 = constructor_x64_cmppd(ctx, v1889, v1893, &FcmpImm::Unordered);
                                let v1895 = &C::xmm_to_xmm_mem(ctx, v1894);
                                let v1896 = constructor_x64_orpd(ctx, v1892, v1895);
                                let v1898 = &C::xmi_imm(ctx, 0xd_u32);
                                let v1899 = constructor_x64_psrlq(ctx, v1894, v1898);
                                let v1900 = &C::xmm_to_xmm_mem(ctx, v1896);
                                let v1901 = constructor_x64_andnpd(ctx, v1899, v1900);
                                let v1902 = constructor_output_xmm(ctx, v1901);
                                let v1903 = Some(v1902);
                                // Rule at src/isa/x64/lower.isle line 2827.
                                return v1903;
                            }
                            _ => {}
                        }
                    }
                }
                &Opcode::Fmax => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        match v3 {
                            F32 => {
                                let v59 = C::unpack_value_array_2(ctx, v58);
                                let v93 = constructor_put_in_xmm(ctx, v59.0);
                                let v682 = constructor_put_in_xmm(ctx, v59.1);
                                let v192 = false;
                                let v1904 = constructor_xmm_min_max_seq(ctx, F32, v192, v93, v682);
                                let v1905 = constructor_output_xmm(ctx, v1904);
                                let v1906 = Some(v1905);
                                // Rule at src/isa/x64/lower.isle line 2841.
                                return v1906;
                            }
                            F64 => {
                                let v59 = C::unpack_value_array_2(ctx, v58);
                                let v93 = constructor_put_in_xmm(ctx, v59.0);
                                let v682 = constructor_put_in_xmm(ctx, v59.1);
                                let v192 = false;
                                let v1907 = constructor_xmm_min_max_seq(ctx, F64, v192, v93, v682);
                                let v1908 = constructor_output_xmm(ctx, v1907);
                                let v1909 = Some(v1908);
                                // Rule at src/isa/x64/lower.isle line 2843.
                                return v1909;
                            }
                            F32X4 => {
                                let v59 = C::unpack_value_array_2(ctx, v58);
                                let v93 = constructor_put_in_xmm(ctx, v59.0);
                                let v682 = constructor_put_in_xmm(ctx, v59.1);
                                let v1873 = &C::xmm_to_xmm_mem(ctx, v682);
                                let v1910 = constructor_x64_maxps(ctx, v93, v1873);
                                let v503 = &C::xmm_to_xmm_mem(ctx, v93);
                                let v1911 = constructor_x64_maxps(ctx, v682, v503);
                                let v1912 = &C::xmm_to_xmm_mem(ctx, v1911);
                                let v1913 = constructor_x64_xorps(ctx, v1910, v1912);
                                let v1914 = &C::xmm_to_xmm_mem(ctx, v1913);
                                let v1915 = constructor_x64_orps(ctx, v1910, v1914);
                                let v1916 = &C::xmm_to_xmm_mem(ctx, v1913);
                                let v1917 = constructor_x64_subps(ctx, v1915, v1916);
                                let v1918 = &C::xmm_to_xmm_mem(ctx, v1915);
                                let v1919 = constructor_x64_cmpps(ctx, v1915, v1918, &FcmpImm::Unordered);
                                let v1920 = &C::xmi_imm(ctx, 0xa_u32);
                                let v1921 = constructor_x64_psrld(ctx, v1919, v1920);
                                let v1922 = &C::xmm_to_xmm_mem(ctx, v1917);
                                let v1923 = constructor_x64_andnps(ctx, v1921, v1922);
                                let v1924 = constructor_output_xmm(ctx, v1923);
                                let v1925 = Some(v1924);
                                // Rule at src/isa/x64/lower.isle line 2849.
                                return v1925;
                            }
                            F64X2 => {
                                let v59 = C::unpack_value_array_2(ctx, v58);
                                let v93 = constructor_put_in_xmm(ctx, v59.0);
                                let v682 = constructor_put_in_xmm(ctx, v59.1);
                                let v1873 = &C::xmm_to_xmm_mem(ctx, v682);
                                let v1926 = constructor_x64_maxpd(ctx, v93, v1873);
                                let v503 = &C::xmm_to_xmm_mem(ctx, v93);
                                let v1927 = constructor_x64_maxpd(ctx, v682, v503);
                                let v1928 = &C::xmm_to_xmm_mem(ctx, v1927);
                                let v1929 = constructor_x64_xorpd(ctx, v1926, v1928);
                                let v1930 = &C::xmm_to_xmm_mem(ctx, v1929);
                                let v1931 = constructor_x64_orpd(ctx, v1926, v1930);
                                let v1932 = &C::xmm_to_xmm_mem(ctx, v1929);
                                let v1933 = constructor_x64_subpd(ctx, v1931, v1932);
                                let v1934 = &C::xmm_to_xmm_mem(ctx, v1931);
                                let v1935 = constructor_x64_cmppd(ctx, v1931, v1934, &FcmpImm::Unordered);
                                let v1936 = &C::xmi_imm(ctx, 0xd_u32);
                                let v1937 = constructor_x64_psrlq(ctx, v1935, v1936);
                                let v1938 = &C::xmm_to_xmm_mem(ctx, v1933);
                                let v1939 = constructor_x64_andnpd(ctx, v1937, v1938);
                                let v1940 = constructor_output_xmm(ctx, v1939);
                                let v1941 = Some(v1940);
                                // Rule at src/isa/x64/lower.isle line 2894.
                                return v1941;
                            }
                            _ => {}
                        }
                    }
                }
                &Opcode::Snarrow => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        match v3 {
                            I8X16 => {
                                let v59 = C::unpack_value_array_2(ctx, v58);
                                let v2894 = C::value_type(ctx, v59.0);
                                if v2894 == I16X8 {
                                    let v93 = constructor_put_in_xmm(ctx, v59.0);
                                    let v94 = &C::put_in_xmm_mem(ctx, v59.1);
                                    let v2895 = constructor_x64_packsswb(ctx, v93, v94);
                                    let v2896 = constructor_output_xmm(ctx, v2895);
                                    let v2897 = Some(v2896);
                                    // Rule at src/isa/x64/lower.isle line 4183.
                                    return v2897;
                                }
                            }
                            I16X8 => {
                                let v59 = C::unpack_value_array_2(ctx, v58);
                                let v2894 = C::value_type(ctx, v59.0);
                                if v2894 == I32X4 {
                                    let v93 = constructor_put_in_xmm(ctx, v59.0);
                                    let v94 = &C::put_in_xmm_mem(ctx, v59.1);
                                    let v2898 = constructor_x64_packssdw(ctx, v93, v94);
                                    let v2899 = constructor_output_xmm(ctx, v2898);
                                    let v2900 = Some(v2899);
                                    // Rule at src/isa/x64/lower.isle line 4186.
                                    return v2900;
                                }
                            }
                            I32X4 => {
                                let v59 = C::unpack_value_array_2(ctx, v58);
                                let v120 = C::def_inst(ctx, v59.1);
                                if let Some(v121) = v120 {
                                    let v122 = &C::inst_data_value(ctx, v121);
                                    if let &InstructionData::UnaryConst {
                                        opcode: ref v2904,
                                        constant_handle: v2905,
                                    } = v122 {
                                        if let &Opcode::Vconst = v2904 {
                                            let v147 = C::def_inst(ctx, v59.0);
                                            if let Some(v148) = v147 {
                                                let v149 = &C::inst_data_value(ctx, v148);
                                                if let &InstructionData::Unary {
                                                    opcode: ref v150,
                                                    arg: v151,
                                                } = v149 {
                                                    match v150 {
                                                        &Opcode::FcvtToSintSat => {
                                                            let v2901 = C::first_result(ctx, v148);
                                                            if let Some(v2902) = v2901 {
                                                                let v2903 = C::value_type(ctx, v2902);
                                                                if v2903 == I64X2 {
                                                                    let v2906 = C::u128_from_constant(ctx, v2905);
                                                                    if let Some(v2907) = v2906 {
                                                                        if v2907 == 0x0_u128 {
                                                                            let v286 = constructor_put_in_xmm(ctx, v151);
                                                                            let v2908 = &C::xmm_to_xmm_mem(ctx, v286);
                                                                            let v2909 = constructor_x64_cmppd(ctx, v286, v2908, &FcmpImm::Equal);
                                                                            let v2911 = C::emit_u128_le_const(ctx, 0x41dfffffffc0000041dfffffffc00000_u128);
                                                                            let v2912 = &constructor_const_to_xmm_mem(ctx, v2911);
                                                                            let v2913 = constructor_x64_andps(ctx, v2909, v2912);
                                                                            let v2914 = &C::xmm_to_xmm_mem(ctx, v2913);
                                                                            let v2915 = constructor_x64_minpd(ctx, v286, v2914);
                                                                            let v2916 = &C::xmm_to_xmm_mem(ctx, v2915);
                                                                            let v2917 = constructor_x64_cvttpd2dq(ctx, v2916);
                                                                            let v2918 = constructor_output_xmm(ctx, v2917);
                                                                            let v2919 = Some(v2918);
                                                                            // Rule at src/isa/x64/lower.isle line 4195.
                                                                            return v2919;
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        &Opcode::X86Cvtt2dq => {
                                                            let v2901 = C::first_result(ctx, v148);
                                                            if let Some(v2902) = v2901 {
                                                                let v2903 = C::value_type(ctx, v2902);
                                                                if v2903 == I64X2 {
                                                                    let v2906 = C::u128_from_constant(ctx, v2905);
                                                                    if let Some(v2907) = v2906 {
                                                                        if v2907 == 0x0_u128 {
                                                                            let v739 = &C::put_in_xmm_mem(ctx, v151);
                                                                            let v2920 = constructor_x64_cvttpd2dq(ctx, v739);
                                                                            let v2921 = constructor_output_xmm(ctx, v2920);
                                                                            let v2922 = Some(v2921);
                                                                            // Rule at src/isa/x64/lower.isle line 4219.
                                                                            return v2922;
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            _ => {}
                        }
                    }
                }
                &Opcode::Unarrow => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        match v3 {
                            I8X16 => {
                                let v59 = C::unpack_value_array_2(ctx, v58);
                                let v2894 = C::value_type(ctx, v59.0);
                                if v2894 == I16X8 {
                                    let v93 = constructor_put_in_xmm(ctx, v59.0);
                                    let v94 = &C::put_in_xmm_mem(ctx, v59.1);
                                    let v2923 = constructor_x64_packuswb(ctx, v93, v94);
                                    let v2924 = constructor_output_xmm(ctx, v2923);
                                    let v2925 = Some(v2924);
                                    // Rule at src/isa/x64/lower.isle line 4225.
                                    return v2925;
                                }
                            }
                            I16X8 => {
                                let v59 = C::unpack_value_array_2(ctx, v58);
                                let v2894 = C::value_type(ctx, v59.0);
                                if v2894 == I32X4 {
                                    let v678 = C::has_sse41(ctx);
                                    if v678 == true {
                                        let v93 = constructor_put_in_xmm(ctx, v59.0);
                                        let v94 = &C::put_in_xmm_mem(ctx, v59.1);
                                        let v2926 = constructor_x64_packusdw(ctx, v93, v94);
                                        let v2927 = constructor_output_xmm(ctx, v2926);
                                        let v2928 = Some(v2927);
                                        // Rule at src/isa/x64/lower.isle line 4228.
                                        return v2928;
                                    }
                                    let v93 = constructor_put_in_xmm(ctx, v59.0);
                                    let v2929 = constructor_unarrow_i32x4_lanes_to_low_u16_lanes(ctx, v93);
                                    let v2930 = constructor_put_in_xmm(ctx, v59.1);
                                    let v2931 = constructor_unarrow_i32x4_lanes_to_low_u16_lanes(ctx, v2930);
                                    let v2932 = &C::xmm_to_xmm_mem(ctx, v2931);
                                    let v2933 = constructor_x64_punpcklqdq(ctx, v2929, v2932);
                                    let v2934 = constructor_output_xmm(ctx, v2933);
                                    let v2935 = Some(v2934);
                                    // Rule at src/isa/x64/lower.isle line 4238.
                                    return v2935;
                                }
                            }
                            _ => {}
                        }
                    }
                }
                &Opcode::Uunarrow => {
                    let v59 = C::unpack_value_array_2(ctx, v58);
                    let v120 = C::def_inst(ctx, v59.1);
                    if let Some(v121) = v120 {
                        let v122 = &C::inst_data_value(ctx, v121);
                        if let &InstructionData::UnaryConst {
                            opcode: ref v2904,
                            constant_handle: v2905,
                        } = v122 {
                            if let &Opcode::Vconst = v2904 {
                                let v147 = C::def_inst(ctx, v59.0);
                                if let Some(v148) = v147 {
                                    let v149 = &C::inst_data_value(ctx, v148);
                                    if let &InstructionData::Unary {
                                        opcode: ref v150,
                                        arg: v151,
                                    } = v149 {
                                        if let &Opcode::FcvtToUintSat = v150 {
                                            let v668 = C::value_type(ctx, v151);
                                            if v668 == F64X2 {
                                                let v2906 = C::u128_from_constant(ctx, v2905);
                                                if let Some(v2907) = v2906 {
                                                    if v2907 == 0x0_u128 {
                                                        let v286 = constructor_put_in_xmm(ctx, v151);
                                                        let v2567 = constructor_xmm_zero(ctx, F64X2);
                                                        let v3479 = &C::xmm_to_xmm_mem(ctx, v2567);
                                                        let v3480 = constructor_x64_maxpd(ctx, v286, v3479);
                                                        let v3482 = C::emit_u128_le_const(ctx, 0x41efffffffe0000041efffffffe00000_u128);
                                                        let v3483 = &constructor_const_to_xmm_mem(ctx, v3482);
                                                        let v3484 = constructor_x64_minpd(ctx, v3480, v3483);
                                                        let v3485 = C::xmm_to_reg(ctx, v3484);
                                                        let v3486 = &constructor_xmm_to_reg_mem(ctx, v3485);
                                                        let v3487 = &C::xmm_mem_to_reg_mem(ctx, v3486);
                                                        let v3488 = constructor_x64_round(ctx, F64X2, v3487, &RoundImm::RoundZero);
                                                        let v3489 = C::emit_u128_le_const(ctx, 0x43300000000000004330000000000000_u128);
                                                        let v3490 = &constructor_const_to_xmm_mem(ctx, v3489);
                                                        let v3491 = constructor_x64_addpd(ctx, v3488, v3490);
                                                        let v3492 = &C::xmm_to_xmm_mem(ctx, v2567);
                                                        let v3493 = constructor_x64_shufps(ctx, v3491, v3492, 0x88_u8);
                                                        let v3494 = constructor_output_xmm(ctx, v3493);
                                                        let v3495 = Some(v3494);
                                                        // Rule at src/isa/x64/lower.isle line 5070.
                                                        return v3495;
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
                &Opcode::IaddPairwise => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        match v3 {
                            I8X16 => {
                                let v2717 = C::emit_u128_le_const(ctx, 0xff00ff00ff00ff00ff00ff00ff00ff_u128);
                                let v2718 = &constructor_const_to_xmm_mem(ctx, v2717);
                                let v2719 = constructor_x64_movdqu_load(ctx, v2718);
                                let v59 = C::unpack_value_array_2(ctx, v58);
                                let v2720 = constructor_put_in_xmm(ctx, v59.0);
                                let v2721 = &C::xmm_to_xmm_mem(ctx, v2719);
                                let v2722 = constructor_x64_pand(ctx, v2720, v2721);
                                let v2723 = constructor_put_in_xmm(ctx, v59.1);
                                let v2724 = &C::xmm_to_xmm_mem(ctx, v2719);
                                let v2725 = constructor_x64_pand(ctx, v2723, v2724);
                                let v2726 = &C::xmm_to_xmm_mem(ctx, v2725);
                                let v2727 = constructor_x64_packuswb(ctx, v2722, v2726);
                                let v2728 = constructor_put_in_xmm(ctx, v59.0);
                                let v2730 = &C::xmi_imm(ctx, 0x8_u32);
                                let v2731 = constructor_x64_psrlw(ctx, v2728, v2730);
                                let v2732 = constructor_put_in_xmm(ctx, v59.1);
                                let v2733 = &C::xmi_imm(ctx, 0x8_u32);
                                let v2734 = constructor_x64_psrlw(ctx, v2732, v2733);
                                let v2735 = &C::xmm_to_xmm_mem(ctx, v2734);
                                let v2736 = constructor_x64_packuswb(ctx, v2731, v2735);
                                let v2737 = &C::xmm_to_xmm_mem(ctx, v2736);
                                let v2738 = constructor_x64_paddb(ctx, v2727, v2737);
                                let v2739 = constructor_output_xmm(ctx, v2738);
                                let v2740 = Some(v2739);
                                // Rule at src/isa/x64/lower.isle line 3972.
                                return v2740;
                            }
                            I16X8 => {
                                let v772 = C::has_ssse3(ctx);
                                if v772 == true {
                                    let v59 = C::unpack_value_array_2(ctx, v58);
                                    let v120 = C::def_inst(ctx, v59.1);
                                    if let Some(v121) = v120 {
                                        let v122 = &C::inst_data_value(ctx, v121);
                                        if let &InstructionData::Unary {
                                            opcode: ref v137,
                                            arg: v138,
                                        } = v122 {
                                            match v137 {
                                                &Opcode::SwidenHigh => {
                                                    let v147 = C::def_inst(ctx, v59.0);
                                                    if let Some(v148) = v147 {
                                                        let v149 = &C::inst_data_value(ctx, v148);
                                                        if let &InstructionData::Unary {
                                                            opcode: ref v150,
                                                            arg: v151,
                                                        } = v149 {
                                                            if let &Opcode::SwidenLow = v150 {
                                                                if v138 == v151 {
                                                                    let v668 = C::value_type(ctx, v151);
                                                                    if v668 == I8X16 {
                                                                        let v2780 = C::emit_u128_le_const(ctx, 0x1010101010101010101010101010101_u128);
                                                                        let v2781 = constructor_x64_xmm_load_const(ctx, I8X16, v2780);
                                                                        let v2782 = &C::put_in_xmm_mem(ctx, v151);
                                                                        let v2783 = constructor_x64_pmaddubsw(ctx, v2781, v2782);
                                                                        let v2784 = constructor_output_xmm(ctx, v2783);
                                                                        let v2785 = Some(v2784);
                                                                        // Rule at src/isa/x64/lower.isle line 4034.
                                                                        return v2785;
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                &Opcode::UwidenHigh => {
                                                    let v147 = C::def_inst(ctx, v59.0);
                                                    if let Some(v148) = v147 {
                                                        let v149 = &C::inst_data_value(ctx, v148);
                                                        if let &InstructionData::Unary {
                                                            opcode: ref v150,
                                                            arg: v151,
                                                        } = v149 {
                                                            if let &Opcode::UwidenLow = v150 {
                                                                if v138 == v151 {
                                                                    let v668 = C::value_type(ctx, v151);
                                                                    if v668 == I8X16 {
                                                                        let v2780 = C::emit_u128_le_const(ctx, 0x1010101010101010101010101010101_u128);
                                                                        let v2793 = &constructor_const_to_xmm_mem(ctx, v2780);
                                                                        let v2789 = constructor_put_in_xmm(ctx, v151);
                                                                        let v2794 = constructor_x64_pmaddubsw(ctx, v2789, v2793);
                                                                        let v2795 = constructor_output_xmm(ctx, v2794);
                                                                        let v2796 = Some(v2795);
                                                                        // Rule at src/isa/x64/lower.isle line 4052.
                                                                        return v2796;
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                _ => {}
                                            }
                                        }
                                    }
                                    let v93 = constructor_put_in_xmm(ctx, v59.0);
                                    let v94 = &C::put_in_xmm_mem(ctx, v59.1);
                                    let v2741 = constructor_x64_phaddw(ctx, v93, v94);
                                    let v2742 = constructor_output_xmm(ctx, v2741);
                                    let v2743 = Some(v2742);
                                    // Rule at src/isa/x64/lower.isle line 3988.
                                    return v2743;
                                }
                                let v59 = C::unpack_value_array_2(ctx, v58);
                                let v93 = constructor_put_in_xmm(ctx, v59.0);
                                let v682 = constructor_put_in_xmm(ctx, v59.1);
                                let v501 = &C::xmm_to_xmm_mem(ctx, v93);
                                let v2745 = constructor_x64_pshuflw(ctx, v501, 0xe8_u8);
                                let v2746 = &C::xmm_to_xmm_mem(ctx, v2745);
                                let v2747 = constructor_x64_pshufhw(ctx, v2746, 0xe8_u8);
                                let v2748 = &C::xmm_to_xmm_mem(ctx, v2747);
                                let v2749 = constructor_x64_pshufd(ctx, v2748, 0xe8_u8);
                                let v2750 = &C::xmm_to_xmm_mem(ctx, v682);
                                let v2751 = constructor_x64_pshuflw(ctx, v2750, 0xe8_u8);
                                let v2752 = &C::xmm_to_xmm_mem(ctx, v2751);
                                let v2753 = constructor_x64_pshufhw(ctx, v2752, 0xe8_u8);
                                let v2754 = &C::xmm_to_xmm_mem(ctx, v2753);
                                let v2755 = constructor_x64_pshufd(ctx, v2754, 0xe8_u8);
                                let v2756 = &C::xmm_to_xmm_mem(ctx, v2755);
                                let v2757 = constructor_x64_punpcklqdq(ctx, v2749, v2756);
                                let v2758 = &C::xmi_imm(ctx, 0x10_u32);
                                let v2759 = constructor_x64_psrad(ctx, v93, v2758);
                                let v2760 = &C::xmi_imm(ctx, 0x10_u32);
                                let v2761 = constructor_x64_psrad(ctx, v682, v2760);
                                let v2762 = &C::xmm_to_xmm_mem(ctx, v2761);
                                let v2763 = constructor_x64_packssdw(ctx, v2759, v2762);
                                let v2764 = &C::xmm_to_xmm_mem(ctx, v2763);
                                let v2765 = constructor_x64_paddw(ctx, v2757, v2764);
                                let v2766 = constructor_output_xmm(ctx, v2765);
                                let v2767 = Some(v2766);
                                // Rule at src/isa/x64/lower.isle line 3992.
                                return v2767;
                            }
                            I32X4 => {
                                let v59 = C::unpack_value_array_2(ctx, v58);
                                let v120 = C::def_inst(ctx, v59.1);
                                if let Some(v121) = v120 {
                                    let v122 = &C::inst_data_value(ctx, v121);
                                    match v122 {
                                        &InstructionData::Binary {
                                            opcode: ref v123,
                                            args: ref v124,
                                        } => {
                                            if let &Opcode::Imul = v123 {
                                                let v147 = C::def_inst(ctx, v59.0);
                                                if let Some(v148) = v147 {
                                                    let v149 = &C::inst_data_value(ctx, v148);
                                                    if let &InstructionData::Binary {
                                                        opcode: ref v365,
                                                        args: ref v366,
                                                    } = v149 {
                                                        if let &Opcode::Imul = v365 {
                                                            let v367 = C::unpack_value_array_2(ctx, v366);
                                                            let v370 = C::def_inst(ctx, v367.1);
                                                            if let Some(v371) = v370 {
                                                                let v372 = &C::inst_data_value(ctx, v371);
                                                                if let &InstructionData::Unary {
                                                                    opcode: ref v2815,
                                                                    arg: v2816,
                                                                } = v372 {
                                                                    if let &Opcode::SwidenLow = v2815 {
                                                                        let v125 = C::unpack_value_array_2(ctx, v124);
                                                                        let v378 = C::def_inst(ctx, v125.1);
                                                                        if let Some(v379) = v378 {
                                                                            let v380 = &C::inst_data_value(ctx, v379);
                                                                            if let &InstructionData::Unary {
                                                                                opcode: ref v2822,
                                                                                arg: v2823,
                                                                            } = v380 {
                                                                                if let &Opcode::SwidenHigh = v2822 {
                                                                                    if v2816 == v2823 {
                                                                                        let v2810 = C::def_inst(ctx, v367.0);
                                                                                        if let Some(v2811) = v2810 {
                                                                                            let v2812 = &C::inst_data_value(ctx, v2811);
                                                                                            if let &InstructionData::Unary {
                                                                                                opcode: ref v2813,
                                                                                                arg: v2814,
                                                                                            } = v2812 {
                                                                                                if let &Opcode::SwidenLow = v2813 {
                                                                                                    let v2817 = C::def_inst(ctx, v125.0);
                                                                                                    if let Some(v2818) = v2817 {
                                                                                                        let v2819 = &C::inst_data_value(ctx, v2818);
                                                                                                        if let &InstructionData::Unary {
                                                                                                            opcode: ref v2820,
                                                                                                            arg: v2821,
                                                                                                        } = v2819 {
                                                                                                            if let &Opcode::SwidenHigh = v2820 {
                                                                                                                if v2814 == v2821 {
                                                                                                                    let v2824 = constructor_put_in_xmm(ctx, v2814);
                                                                                                                    let v2825 = &C::put_in_xmm_mem(ctx, v2816);
                                                                                                                    let v2826 = constructor_x64_pmaddwd(ctx, v2824, v2825);
                                                                                                                    let v2827 = constructor_output_xmm(ctx, v2826);
                                                                                                                    let v2828 = Some(v2827);
                                                                                                                    // Rule at src/isa/x64/lower.isle line 4075.
                                                                                                                    return v2828;
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        &InstructionData::Unary {
                                            opcode: ref v137,
                                            arg: v138,
                                        } => {
                                            match v137 {
                                                &Opcode::SwidenHigh => {
                                                    let v147 = C::def_inst(ctx, v59.0);
                                                    if let Some(v148) = v147 {
                                                        let v149 = &C::inst_data_value(ctx, v148);
                                                        if let &InstructionData::Unary {
                                                            opcode: ref v150,
                                                            arg: v151,
                                                        } = v149 {
                                                            if let &Opcode::SwidenLow = v150 {
                                                                if v138 == v151 {
                                                                    let v668 = C::value_type(ctx, v151);
                                                                    if v668 == I16X8 {
                                                                        let v2787 = C::emit_u128_le_const(ctx, 0x10001000100010001000100010001_u128);
                                                                        let v2788 = &constructor_const_to_xmm_mem(ctx, v2787);
                                                                        let v2789 = constructor_put_in_xmm(ctx, v151);
                                                                        let v2790 = constructor_x64_pmaddwd(ctx, v2789, v2788);
                                                                        let v2791 = constructor_output_xmm(ctx, v2790);
                                                                        let v2792 = Some(v2791);
                                                                        // Rule at src/isa/x64/lower.isle line 4044.
                                                                        return v2792;
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                &Opcode::UwidenHigh => {
                                                    let v147 = C::def_inst(ctx, v59.0);
                                                    if let Some(v148) = v147 {
                                                        let v149 = &C::inst_data_value(ctx, v148);
                                                        if let &InstructionData::Unary {
                                                            opcode: ref v150,
                                                            arg: v151,
                                                        } = v149 {
                                                            if let &Opcode::UwidenLow = v150 {
                                                                if v138 == v151 {
                                                                    let v668 = C::value_type(ctx, v151);
                                                                    if v668 == I16X8 {
                                                                        let v2798 = C::emit_u128_le_const(ctx, 0x80008000800080008000800080008000_u128);
                                                                        let v2799 = &constructor_const_to_xmm_mem(ctx, v2798);
                                                                        let v2789 = constructor_put_in_xmm(ctx, v151);
                                                                        let v2800 = constructor_x64_pxor(ctx, v2789, v2799);
                                                                        let v2801 = C::emit_u128_le_const(ctx, 0x10001000100010001000100010001_u128);
                                                                        let v2802 = &constructor_const_to_xmm_mem(ctx, v2801);
                                                                        let v2803 = constructor_x64_pmaddwd(ctx, v2800, v2802);
                                                                        let v2805 = C::emit_u128_le_const(ctx, 0x10000000100000001000000010000_u128);
                                                                        let v2806 = &constructor_const_to_xmm_mem(ctx, v2805);
                                                                        let v2807 = constructor_x64_paddd(ctx, v2803, v2806);
                                                                        let v2808 = constructor_output_xmm(ctx, v2807);
                                                                        let v2809 = Some(v2808);
                                                                        // Rule at src/isa/x64/lower.isle line 4061.
                                                                        return v2809;
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                _ => {}
                                            }
                                        }
                                        _ => {}
                                    }
                                }
                                let v772 = C::has_ssse3(ctx);
                                if v772 == true {
                                    let v93 = constructor_put_in_xmm(ctx, v59.0);
                                    let v94 = &C::put_in_xmm_mem(ctx, v59.1);
                                    let v2768 = constructor_x64_phaddd(ctx, v93, v94);
                                    let v2769 = constructor_output_xmm(ctx, v2768);
                                    let v2770 = Some(v2769);
                                    // Rule at src/isa/x64/lower.isle line 4018.
                                    return v2770;
                                }
                                let v93 = constructor_put_in_xmm(ctx, v59.0);
                                let v682 = constructor_put_in_xmm(ctx, v59.1);
                                let v1873 = &C::xmm_to_xmm_mem(ctx, v682);
                                let v2772 = constructor_x64_shufps(ctx, v93, v1873, 0x88_u8);
                                let v685 = &C::xmm_to_xmm_mem(ctx, v682);
                                let v2774 = constructor_x64_shufps(ctx, v93, v685, 0xdd_u8);
                                let v2775 = &C::xmm_to_xmm_mem(ctx, v2774);
                                let v2776 = constructor_x64_paddd(ctx, v2772, v2775);
                                let v2777 = constructor_output_xmm(ctx, v2776);
                                let v2778 = Some(v2777);
                                // Rule at src/isa/x64/lower.isle line 4022.
                                return v2778;
                            }
                            _ => {}
                        }
                    }
                }
                &Opcode::X86Pmaddubsw => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        if v3 == I16X8 {
                            let v772 = C::has_ssse3(ctx);
                            if v772 == true {
                                let v59 = C::unpack_value_array_2(ctx, v58);
                                let v1760 = constructor_put_in_xmm(ctx, v59.1);
                                let v282 = &C::put_in_xmm_mem(ctx, v59.0);
                                let v1761 = constructor_x64_pmaddubsw(ctx, v1760, v282);
                                let v1762 = constructor_output_xmm(ctx, v1761);
                                let v1763 = Some(v1762);
                                // Rule at src/isa/x64/lower.isle line 2667.
                                return v1763;
                            }
                        }
                    }
                }
                &Opcode::Iconcat => {
                    let v59 = C::unpack_value_array_2(ctx, v58);
                    let v2894 = C::value_type(ctx, v59.0);
                    if v2894 == I64 {
                        let v3424 = C::put_in_reg(ctx, v59.0);
                        let v3425 = C::put_in_reg(ctx, v59.1);
                        let v3426 = C::value_regs(ctx, v3424, v3425);
                        let v3427 = C::output(ctx, v3426);
                        let v3428 = Some(v3427);
                        // Rule at src/isa/x64/lower.isle line 4986.
                        return v3428;
                    }
                }
                _ => {}
            }
        }
        &InstructionData::BinaryImm8 {
            opcode: ref v3242,
            arg: v3243,
            imm: v3244,
        } => {
            if let &Opcode::Extractlane = v3242 {
                if v3244 == 0x0 {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        let v270 = C::ty_scalar_float(ctx, v3);
                        if let Some(v271) = v270 {
                            let v3245 = constructor_output_value(ctx, v3243);
                            let v3246 = Some(v3245);
                            // Rule at src/isa/x64/lower.isle line 4744.
                            return v3246;
                        }
                    }
                }
                let v3247 = C::value_type(ctx, v3243);
                match v3247 {
                    I8X16 => {
                        let v678 = C::has_sse41(ctx);
                        if v678 == true {
                            let v3256 = constructor_put_in_xmm(ctx, v3243);
                            let v3248 = C::u8_from_uimm8(ctx, v3244);
                            let v3257 = constructor_x64_pextrb(ctx, v3256, v3248);
                            let v3258 = constructor_output_gpr(ctx, v3257);
                            let v3259 = Some(v3258);
                            // Rule at src/isa/x64/lower.isle line 4759.
                            return v3259;
                        }
                        let v3248 = C::u8_from_uimm8(ctx, v3244);
                        let v3260 = C::u8_and(ctx, v3248, 0x1_u8);
                        match v3260 {
                            0x0_u8 => {
                                let v3256 = constructor_put_in_xmm(ctx, v3243);
                                let v3261 = C::u8_wrapping_shr(ctx, v3248, 0x1_u32);
                                let v3262 = constructor_x64_pextrw(ctx, v3256, v3261);
                                let v3266 = constructor_output_gpr(ctx, v3262);
                                let v3267 = Some(v3266);
                                // Rule at src/isa/x64/lower.isle line 4770.
                                return v3267;
                            }
                            0x1_u8 => {
                                let v3256 = constructor_put_in_xmm(ctx, v3243);
                                let v3261 = C::u8_wrapping_shr(ctx, v3248, 0x1_u32);
                                let v3262 = constructor_x64_pextrw(ctx, v3256, v3261);
                                let v3263 = constructor_x64_shrw_mi(ctx, v3262, 0x8_u8);
                                let v3264 = constructor_output_gpr(ctx, v3263);
                                let v3265 = Some(v3264);
                                // Rule at src/isa/x64/lower.isle line 4763.
                                return v3265;
                            }
                            _ => {}
                        }
                    }
                    I16X8 => {
                        let v3256 = constructor_put_in_xmm(ctx, v3243);
                        let v3248 = C::u8_from_uimm8(ctx, v3244);
                        let v3268 = constructor_x64_pextrw(ctx, v3256, v3248);
                        let v3269 = constructor_output_gpr(ctx, v3268);
                        let v3270 = Some(v3269);
                        // Rule at src/isa/x64/lower.isle line 4775.
                        return v3270;
                    }
                    I32X4 => {
                        let v678 = C::has_sse41(ctx);
                        if v678 == true {
                            let v3256 = constructor_put_in_xmm(ctx, v3243);
                            let v3248 = C::u8_from_uimm8(ctx, v3244);
                            let v3271 = constructor_x64_pextrd(ctx, v3256, v3248);
                            let v3272 = constructor_output_gpr(ctx, v3271);
                            let v3273 = Some(v3272);
                            // Rule at src/isa/x64/lower.isle line 4779.
                            return v3273;
                        }
                        if v3244 == 0x0 {
                            let v3256 = constructor_put_in_xmm(ctx, v3243);
                            let v3274 = constructor_x64_movd_to_gpr(ctx, v3256);
                            let v3275 = constructor_output_gpr(ctx, v3274);
                            let v3276 = Some(v3275);
                            // Rule at src/isa/x64/lower.isle line 4782.
                            return v3276;
                        }
                        let v3249 = &C::put_in_xmm_mem(ctx, v3243);
                        let v3248 = C::u8_from_uimm8(ctx, v3244);
                        let v3250 = constructor_x64_pshufd(ctx, v3249, v3248);
                        let v3277 = constructor_x64_movd_to_gpr(ctx, v3250);
                        let v3278 = constructor_output_gpr(ctx, v3277);
                        let v3279 = Some(v3278);
                        // Rule at src/isa/x64/lower.isle line 4784.
                        return v3279;
                    }
                    I64X2 => {
                        let v678 = C::has_sse41(ctx);
                        if v678 == true {
                            let v3256 = constructor_put_in_xmm(ctx, v3243);
                            let v3248 = C::u8_from_uimm8(ctx, v3244);
                            let v3280 = constructor_x64_pextrq(ctx, v3256, v3248);
                            let v3281 = constructor_output_gpr(ctx, v3280);
                            let v3282 = Some(v3281);
                            // Rule at src/isa/x64/lower.isle line 4788.
                            return v3282;
                        }
                        match v3244 {
                            0x0 => {
                                let v3256 = constructor_put_in_xmm(ctx, v3243);
                                let v3283 = constructor_x64_movq_to_gpr(ctx, v3256);
                                let v3284 = constructor_output_gpr(ctx, v3283);
                                let v3285 = Some(v3284);
                                // Rule at src/isa/x64/lower.isle line 4791.
                                return v3285;
                            }
                            0x1 => {
                                let v3249 = &C::put_in_xmm_mem(ctx, v3243);
                                let v3286 = constructor_x64_pshufd(ctx, v3249, 0xe_u8);
                                let v3287 = constructor_x64_movq_to_gpr(ctx, v3286);
                                let v3288 = constructor_output_gpr(ctx, v3287);
                                let v3289 = Some(v3288);
                                // Rule at src/isa/x64/lower.isle line 4793.
                                return v3289;
                            }
                            _ => {}
                        }
                    }
                    F32X4 => {
                        let v3249 = &C::put_in_xmm_mem(ctx, v3243);
                        let v3248 = C::u8_from_uimm8(ctx, v3244);
                        let v3250 = constructor_x64_pshufd(ctx, v3249, v3248);
                        let v3251 = constructor_output_xmm(ctx, v3250);
                        let v3252 = Some(v3251);
                        // Rule at src/isa/x64/lower.isle line 4748.
                        return v3252;
                    }
                    F64X2 => {
                        if v3244 == 0x1 {
                            let v3249 = &C::put_in_xmm_mem(ctx, v3243);
                            let v3253 = constructor_x64_pshufd(ctx, v3249, 0xee_u8);
                            let v3254 = constructor_output_xmm(ctx, v3253);
                            let v3255 = Some(v3254);
                            // Rule at src/isa/x64/lower.isle line 4752.
                            return v3255;
                        }
                    }
                    _ => {}
                }
            }
        }
        &InstructionData::Call {
            opcode: ref v2453,
            args: v2454,
            func_ref: v2455,
        } => {
            match v2453 {
                &Opcode::Call => {
                    let v2457 = C::func_ref_data(ctx, v2455);
                    if let &RelocDistance::Near = &v2457.2 {
                        let v2462 = &C::gen_call_output(ctx, v2457.0);
                        let v2463 = C::abi_sig(ctx, v2457.0);
                        let v2456 = C::value_list_slice(ctx, v2454);
                        let v2464 = &C::put_in_regs_vec(ctx, v2456);
                        let v2465 = C::gen_call_args(ctx, v2463, v2464);
                        let v2466 = C::gen_call_rets(ctx, v2463, v2462);
                        let v2467 = C::try_call_none(ctx);
                        let v2468 = &C::gen_call_info(ctx, v2463, v2457.1, v2465, v2466, v2467, v2457.3);
                        let v2469 = &constructor_call_known(ctx, v2468);
                        let v2470 = constructor_emit_side_effect(ctx, v2469);
                        let v2471 = C::output_vec(ctx, v2462);
                        let v2472 = Some(v2471);
                        // Rule at src/isa/x64/lower.isle line 3519.
                        return v2472;
                    }
                    if v2457.3 == false {
                        let v2462 = &C::gen_call_output(ctx, v2457.0);
                        let v2463 = C::abi_sig(ctx, v2457.0);
                        let v2456 = C::value_list_slice(ctx, v2454);
                        let v2464 = &C::put_in_regs_vec(ctx, v2456);
                        let v2465 = C::gen_call_args(ctx, v2463, v2464);
                        let v2466 = C::gen_call_rets(ctx, v2463, v2462);
                        let v2473 = constructor_load_ext_name(ctx, v2457.1, 0_i64, &v2457.2);
                        let v2474 = C::gpr_to_reg(ctx, v2473);
                        let v2476 = C::try_call_none(ctx);
                        let v2475 = RegMem::Reg {
                            reg: v2474,
                        };
                        let v2477 = &C::gen_call_ind_info(ctx, v2463, &v2475, v2465, v2466, v2476);
                        let v2478 = &constructor_call_unknown(ctx, v2477);
                        let v2479 = constructor_emit_side_effect(ctx, v2478);
                        let v2480 = C::output_vec(ctx, v2462);
                        let v2481 = Some(v2480);
                        // Rule at src/isa/x64/lower.isle line 3529.
                        return v2481;
                    }
                }
                &Opcode::ReturnCall => {
                    let v2457 = C::func_ref_data(ctx, v2455);
                    if v2457.3 == false {
                        if let &RelocDistance::Near = &v2457.2 {
                            let v2503 = C::abi_sig(ctx, v2457.0);
                            let v2456 = C::value_list_slice(ctx, v2454);
                            let v2504 = &C::put_in_regs_vec(ctx, v2456);
                            let v2505 = C::gen_return_call_args(ctx, v2503, v2504);
                            let v2506 = &C::gen_return_call_info(ctx, v2503, v2457.1, v2505);
                            let v2507 = &constructor_return_call_known(ctx, v2506);
                            let v2508 = constructor_side_effect(ctx, v2507);
                            let v2509 = Some(v2508);
                            // Rule at src/isa/x64/lower.isle line 3553.
                            return v2509;
                        }
                        let v2503 = C::abi_sig(ctx, v2457.0);
                        let v2456 = C::value_list_slice(ctx, v2454);
                        let v2504 = &C::put_in_regs_vec(ctx, v2456);
                        let v2505 = C::gen_return_call_args(ctx, v2503, v2504);
                        let v2510 = constructor_load_ext_name(ctx, v2457.1, 0_i64, &v2457.2);
                        let v2511 = C::gpr_to_reg(ctx, v2510);
                        let v2512 = &C::gen_return_call_ind_info(ctx, v2503, v2511, v2505);
                        let v2513 = &constructor_return_call_unknown(ctx, v2512);
                        let v2514 = constructor_side_effect(ctx, v2513);
                        let v2515 = Some(v2514);
                        // Rule at src/isa/x64/lower.isle line 3560.
                        return v2515;
                    }
                }
                _ => {}
            }
        }
        &InstructionData::CallIndirect {
            opcode: ref v2482,
            args: v2483,
            sig_ref: v2484,
        } => {
            match v2482 {
                &Opcode::CallIndirect => {
                    let v2485 = C::value_list_slice(ctx, v2483);
                    let v2486 = C::value_slice_unwrap(ctx, v2485);
                    if let Some(v2487) = v2486 {
                        let v2490 = &C::gen_call_output(ctx, v2484);
                        let v2491 = C::abi_sig(ctx, v2484);
                        let v2492 = C::put_in_reg(ctx, v2487.0);
                        let v2494 = &C::put_in_regs_vec(ctx, v2487.1);
                        let v2495 = C::gen_call_args(ctx, v2491, v2494);
                        let v2496 = C::gen_call_rets(ctx, v2491, v2490);
                        let v2497 = C::try_call_none(ctx);
                        let v2493 = RegMem::Reg {
                            reg: v2492,
                        };
                        let v2498 = &C::gen_call_ind_info(ctx, v2491, &v2493, v2495, v2496, v2497);
                        let v2499 = &constructor_call_unknown(ctx, v2498);
                        let v2500 = constructor_emit_side_effect(ctx, v2499);
                        let v2501 = C::output_vec(ctx, v2490);
                        let v2502 = Some(v2501);
                        // Rule at src/isa/x64/lower.isle line 3540.
                        return v2502;
                    }
                }
                &Opcode::ReturnCallIndirect => {
                    let v2485 = C::value_list_slice(ctx, v2483);
                    let v2486 = C::value_slice_unwrap(ctx, v2485);
                    if let Some(v2487) = v2486 {
                        let v2516 = C::abi_sig(ctx, v2484);
                        let v2517 = C::put_in_reg(ctx, v2487.0);
                        let v2518 = &C::put_in_regs_vec(ctx, v2487.1);
                        let v2519 = C::gen_return_call_args(ctx, v2516, v2518);
                        let v2520 = &C::gen_return_call_ind_info(ctx, v2516, v2517, v2519);
                        let v2521 = &constructor_return_call_unknown(ctx, v2520);
                        let v2522 = constructor_side_effect(ctx, v2521);
                        let v2523 = Some(v2522);
                        // Rule at src/isa/x64/lower.isle line 3568.
                        return v2523;
                    }
                }
                _ => {}
            }
        }
        &InstructionData::CondTrap {
            opcode: ref v1215,
            arg: v1216,
            code: ref v1217,
        } => {
            match v1215 {
                &Opcode::Trapz => {
                    let v1218 = &constructor_is_nonzero_cmp(ctx, v1216);
                    let v1219 = &constructor_cond_invert(ctx, v1218);
                    let v1220 = &constructor_trap_if_cond(ctx, v1219, v1217);
                    let v1221 = constructor_side_effect(ctx, v1220);
                    let v1222 = Some(v1221);
                    // Rule at src/isa/x64/lower.isle line 1902.
                    return v1222;
                }
                &Opcode::Trapnz => {
                    let v1218 = &constructor_is_nonzero_cmp(ctx, v1216);
                    let v1223 = &constructor_trap_if_cond(ctx, v1218, v1217);
                    let v1224 = constructor_side_effect(ctx, v1223);
                    let v1225 = Some(v1224);
                    // Rule at src/isa/x64/lower.isle line 1915.
                    return v1225;
                }
                _ => {}
            }
        }
        &InstructionData::ExceptionHandlerAddress {
            opcode: ref v3496,
            block: ref v3497,
            imm: v3498,
        } => {
            if let &Opcode::GetExceptionHandlerAddress = v3496 {
                let v3499 = C::u64_from_imm64(ctx, v3498);
                let v3500 = C::block_exn_successor_label(ctx, v3497, v3499);
                let v3501 = constructor_x64_label_address(ctx, v3500);
                let v3502 = constructor_output_gpr(ctx, v3501);
                let v3503 = Some(v3502);
                // Rule at src/isa/x64/lower.isle line 5098.
                return v3503;
            }
        }
        &InstructionData::FloatCompare {
            opcode: ref v1416,
            args: ref v1417,
            cond: ref v1418,
        } => {
            if let &Opcode::Fcmp = v1416 {
                match v1418 {
                    &FloatCC::Equal => {
                        let v1419 = C::unpack_value_array_2(ctx, v1417);
                        let v1422 = C::value_type(ctx, v1419.0);
                        let v1429 = C::ty_vec128(ctx, v1422);
                        if let Some(v1430) = v1429 {
                            let v1431 = constructor_put_in_xmm(ctx, v1419.0);
                            let v1432 = &C::put_in_xmm_mem(ctx, v1419.1);
                            let v1434 = constructor_x64_cmpp(ctx, v1430, v1431, v1432, &FcmpImm::Equal);
                            let v1435 = constructor_output_xmm(ctx, v1434);
                            let v1436 = Some(v1435);
                            // Rule at src/isa/x64/lower.isle line 2148.
                            return v1436;
                        }
                    }
                    &FloatCC::GreaterThan => {
                        let v1419 = C::unpack_value_array_2(ctx, v1417);
                        let v1422 = C::value_type(ctx, v1419.0);
                        let v1429 = C::ty_vec128(ctx, v1422);
                        if let Some(v1430) = v1429 {
                            let v1465 = constructor_put_in_xmm(ctx, v1419.1);
                            let v1466 = &C::put_in_xmm_mem(ctx, v1419.0);
                            let v1467 = constructor_x64_cmpp(ctx, v1430, v1465, v1466, &FcmpImm::LessThan);
                            let v1468 = constructor_output_xmm(ctx, v1467);
                            let v1469 = Some(v1468);
                            // Rule at src/isa/x64/lower.isle line 2168.
                            return v1469;
                        }
                    }
                    &FloatCC::GreaterThanOrEqual => {
                        let v1419 = C::unpack_value_array_2(ctx, v1417);
                        let v1422 = C::value_type(ctx, v1419.0);
                        let v1429 = C::ty_vec128(ctx, v1422);
                        if let Some(v1430) = v1429 {
                            let v1465 = constructor_put_in_xmm(ctx, v1419.1);
                            let v1466 = &C::put_in_xmm_mem(ctx, v1419.0);
                            let v1470 = constructor_x64_cmpp(ctx, v1430, v1465, v1466, &FcmpImm::LessThanOrEqual);
                            let v1471 = constructor_output_xmm(ctx, v1470);
                            let v1472 = Some(v1471);
                            // Rule at src/isa/x64/lower.isle line 2170.
                            return v1472;
                        }
                    }
                    &FloatCC::LessThan => {
                        let v1419 = C::unpack_value_array_2(ctx, v1417);
                        let v1422 = C::value_type(ctx, v1419.0);
                        let v1429 = C::ty_vec128(ctx, v1422);
                        if let Some(v1430) = v1429 {
                            let v1431 = constructor_put_in_xmm(ctx, v1419.0);
                            let v1432 = &C::put_in_xmm_mem(ctx, v1419.1);
                            let v1442 = constructor_x64_cmpp(ctx, v1430, v1431, v1432, &FcmpImm::LessThan);
                            let v1443 = constructor_output_xmm(ctx, v1442);
                            let v1444 = Some(v1443);
                            // Rule at src/isa/x64/lower.isle line 2152.
                            return v1444;
                        }
                    }
                    &FloatCC::LessThanOrEqual => {
                        let v1419 = C::unpack_value_array_2(ctx, v1417);
                        let v1422 = C::value_type(ctx, v1419.0);
                        let v1429 = C::ty_vec128(ctx, v1422);
                        if let Some(v1430) = v1429 {
                            let v1431 = constructor_put_in_xmm(ctx, v1419.0);
                            let v1432 = &C::put_in_xmm_mem(ctx, v1419.1);
                            let v1446 = constructor_x64_cmpp(ctx, v1430, v1431, v1432, &FcmpImm::LessThanOrEqual);
                            let v1447 = constructor_output_xmm(ctx, v1446);
                            let v1448 = Some(v1447);
                            // Rule at src/isa/x64/lower.isle line 2154.
                            return v1448;
                        }
                    }
                    &FloatCC::NotEqual => {
                        let v1419 = C::unpack_value_array_2(ctx, v1417);
                        let v1422 = C::value_type(ctx, v1419.0);
                        let v1429 = C::ty_vec128(ctx, v1422);
                        if let Some(v1430) = v1429 {
                            let v1431 = constructor_put_in_xmm(ctx, v1419.0);
                            let v1432 = &C::put_in_xmm_mem(ctx, v1419.1);
                            let v1438 = constructor_x64_cmpp(ctx, v1430, v1431, v1432, &FcmpImm::NotEqual);
                            let v1439 = constructor_output_xmm(ctx, v1438);
                            let v1440 = Some(v1439);
                            // Rule at src/isa/x64/lower.isle line 2150.
                            return v1440;
                        }
                    }
                    &FloatCC::Ordered => {
                        let v1419 = C::unpack_value_array_2(ctx, v1417);
                        let v1422 = C::value_type(ctx, v1419.0);
                        let v1429 = C::ty_vec128(ctx, v1422);
                        if let Some(v1430) = v1429 {
                            let v1431 = constructor_put_in_xmm(ctx, v1419.0);
                            let v1432 = &C::put_in_xmm_mem(ctx, v1419.1);
                            let v1450 = constructor_x64_cmpp(ctx, v1430, v1431, v1432, &FcmpImm::Ordered);
                            let v1451 = constructor_output_xmm(ctx, v1450);
                            let v1452 = Some(v1451);
                            // Rule at src/isa/x64/lower.isle line 2156.
                            return v1452;
                        }
                    }
                    &FloatCC::Unordered => {
                        let v1419 = C::unpack_value_array_2(ctx, v1417);
                        let v1422 = C::value_type(ctx, v1419.0);
                        let v1429 = C::ty_vec128(ctx, v1422);
                        if let Some(v1430) = v1429 {
                            let v1431 = constructor_put_in_xmm(ctx, v1419.0);
                            let v1432 = &C::put_in_xmm_mem(ctx, v1419.1);
                            let v1454 = constructor_x64_cmpp(ctx, v1430, v1431, v1432, &FcmpImm::Unordered);
                            let v1455 = constructor_output_xmm(ctx, v1454);
                            let v1456 = Some(v1455);
                            // Rule at src/isa/x64/lower.isle line 2158.
                            return v1456;
                        }
                    }
                    &FloatCC::UnorderedOrGreaterThan => {
                        let v1419 = C::unpack_value_array_2(ctx, v1417);
                        let v1422 = C::value_type(ctx, v1419.0);
                        let v1429 = C::ty_vec128(ctx, v1422);
                        if let Some(v1430) = v1429 {
                            let v1431 = constructor_put_in_xmm(ctx, v1419.0);
                            let v1432 = &C::put_in_xmm_mem(ctx, v1419.1);
                            let v1458 = constructor_x64_cmpp(ctx, v1430, v1431, v1432, &FcmpImm::UnorderedOrGreaterThan);
                            let v1459 = constructor_output_xmm(ctx, v1458);
                            let v1460 = Some(v1459);
                            // Rule at src/isa/x64/lower.isle line 2160.
                            return v1460;
                        }
                    }
                    &FloatCC::UnorderedOrGreaterThanOrEqual => {
                        let v1419 = C::unpack_value_array_2(ctx, v1417);
                        let v1422 = C::value_type(ctx, v1419.0);
                        let v1429 = C::ty_vec128(ctx, v1422);
                        if let Some(v1430) = v1429 {
                            let v1431 = constructor_put_in_xmm(ctx, v1419.0);
                            let v1432 = &C::put_in_xmm_mem(ctx, v1419.1);
                            let v1462 = constructor_x64_cmpp(ctx, v1430, v1431, v1432, &FcmpImm::UnorderedOrGreaterThanOrEqual);
                            let v1463 = constructor_output_xmm(ctx, v1462);
                            let v1464 = Some(v1463);
                            // Rule at src/isa/x64/lower.isle line 2162.
                            return v1464;
                        }
                    }
                    &FloatCC::UnorderedOrLessThan => {
                        let v1419 = C::unpack_value_array_2(ctx, v1417);
                        let v1422 = C::value_type(ctx, v1419.0);
                        let v1429 = C::ty_vec128(ctx, v1422);
                        if let Some(v1430) = v1429 {
                            let v1465 = constructor_put_in_xmm(ctx, v1419.1);
                            let v1466 = &C::put_in_xmm_mem(ctx, v1419.0);
                            let v1473 = constructor_x64_cmpp(ctx, v1430, v1465, v1466, &FcmpImm::UnorderedOrGreaterThan);
                            let v1474 = constructor_output_xmm(ctx, v1473);
                            let v1475 = Some(v1474);
                            // Rule at src/isa/x64/lower.isle line 2172.
                            return v1475;
                        }
                    }
                    &FloatCC::UnorderedOrLessThanOrEqual => {
                        let v1419 = C::unpack_value_array_2(ctx, v1417);
                        let v1422 = C::value_type(ctx, v1419.0);
                        let v1429 = C::ty_vec128(ctx, v1422);
                        if let Some(v1430) = v1429 {
                            let v1465 = constructor_put_in_xmm(ctx, v1419.1);
                            let v1466 = &C::put_in_xmm_mem(ctx, v1419.0);
                            let v1476 = constructor_x64_cmpp(ctx, v1430, v1465, v1466, &FcmpImm::UnorderedOrGreaterThanOrEqual);
                            let v1477 = constructor_output_xmm(ctx, v1476);
                            let v1478 = Some(v1477);
                            // Rule at src/isa/x64/lower.isle line 2174.
                            return v1478;
                        }
                    }
                    _ => {}
                }
                let v1419 = C::unpack_value_array_2(ctx, v1417);
                let v1422 = C::value_type(ctx, v1419.0);
                let v1423 = C::ty_scalar_float(ctx, v1422);
                if let Some(v1424) = v1423 {
                    let v1425 = &constructor_emit_fcmp(ctx, v1418, v1419.0, v1419.1);
                    let v1426 = constructor_lower_cond_bool(ctx, v1425);
                    let v1427 = constructor_output_gpr(ctx, v1426);
                    let v1428 = Some(v1427);
                    // Rule at src/isa/x64/lower.isle line 2141.
                    return v1428;
                }
            }
        }
        &InstructionData::FuncAddr {
            opcode: ref v2309,
            func_ref: v2310,
        } => {
            if let &Opcode::FuncAddr = v2309 {
                let v2311 = C::func_ref_data(ctx, v2310);
                let v2317 = constructor_load_ext_name(ctx, v2311.1, 0_i64, &v2311.2);
                let v2318 = constructor_output_gpr(ctx, v2317);
                let v2319 = Some(v2318);
                // Rule at src/isa/x64/lower.isle line 3414.
                return v2319;
            }
        }
        &InstructionData::IntAddTrap {
            opcode: ref v1226,
            args: ref v1227,
            code: ref v1228,
        } => {
            if let &Opcode::UaddOverflowTrap = v1226 {
                let v1 = C::first_result(ctx, arg0);
                if let Some(v2) = v1 {
                    let v3 = C::value_type(ctx, v2);
                    let v4 = C::fits_in_64(ctx, v3);
                    if let Some(v5) = v4 {
                        let v1229 = C::unpack_value_array_2(ctx, v1227);
                        let v1247 = &C::sinkable_load(ctx, v1229.0);
                        if let Some(v1248) = v1247 {
                            let v1241 = constructor_put_in_gpr(ctx, v1229.1);
                            let v1249 = &constructor_sink_load_to_gpr_mem_imm(ctx, v1248);
                            let v1250 = &constructor_x64_add_with_flags_paired(ctx, v5, v1241, v1249);
                            let v1235 = &constructor_trap_if(ctx, &CC::B, v1228);
                            let v1251 = constructor_with_flags(ctx, v1250, v1235);
                            let v1252 = C::output(ctx, v1251);
                            let v1253 = Some(v1252);
                            // Rule at src/isa/x64/lower.isle line 1934.
                            return v1253;
                        }
                        let v1239 = &C::simm32_from_value(ctx, v1229.0);
                        if let Some(v1240) = v1239 {
                            let v1241 = constructor_put_in_gpr(ctx, v1229.1);
                            let v1242 = &constructor_x64_add_with_flags_paired(ctx, v5, v1241, v1240);
                            let v1243 = &constructor_trap_if(ctx, &CC::B, v1228);
                            let v1244 = constructor_with_flags(ctx, v1242, v1243);
                            let v1245 = C::output(ctx, v1244);
                            let v1246 = Some(v1245);
                            // Rule at src/isa/x64/lower.isle line 1928.
                            return v1246;
                        }
                        let v1232 = constructor_put_in_gpr(ctx, v1229.0);
                        let v1233 = &constructor_put_in_gpr_mem_imm(ctx, v1229.1);
                        let v1234 = &constructor_x64_add_with_flags_paired(ctx, v5, v1232, v1233);
                        let v1235 = &constructor_trap_if(ctx, &CC::B, v1228);
                        let v1236 = constructor_with_flags(ctx, v1234, v1235);
                        let v1237 = C::output(ctx, v1236);
                        let v1238 = Some(v1237);
                        // Rule at src/isa/x64/lower.isle line 1920.
                        return v1238;
                    }
                }
            }
        }
        &InstructionData::IntCompare {
            opcode: ref v1259,
            args: ref v1260,
            cond: ref v1261,
        } => {
            if let &Opcode::Icmp = v1259 {
                match v1261 {
                    &IntCC::Equal => {
                        let v1262 = C::unpack_value_array_2(ctx, v1260);
                        let v1265 = C::value_type(ctx, v1262.0);
                        let v1315 = C::ty_vec128(ctx, v1265);
                        if let Some(v1316) = v1315 {
                            let v1317 = constructor_put_in_xmm(ctx, v1262.0);
                            let v1318 = &C::put_in_xmm_mem(ctx, v1262.1);
                            let v1319 = constructor_x64_pcmpeq(ctx, v1316, v1317, v1318);
                            let v1320 = constructor_output_xmm(ctx, v1319);
                            let v1321 = Some(v1320);
                            // Rule at src/isa/x64/lower.isle line 1991.
                            return v1321;
                        }
                    }
                    &IntCC::NotEqual => {
                        let v1262 = C::unpack_value_array_2(ctx, v1260);
                        let v1265 = C::value_type(ctx, v1262.0);
                        let v1315 = C::ty_vec128(ctx, v1265);
                        if let Some(v1316) = v1315 {
                            let v1317 = constructor_put_in_xmm(ctx, v1262.0);
                            let v1318 = &C::put_in_xmm_mem(ctx, v1262.1);
                            let v1319 = constructor_x64_pcmpeq(ctx, v1316, v1317, v1318);
                            let v1322 = constructor_vector_all_ones(ctx);
                            let v1323 = &C::xmm_to_xmm_mem(ctx, v1322);
                            let v1324 = constructor_x64_pxor(ctx, v1319, v1323);
                            let v1325 = constructor_output_xmm(ctx, v1324);
                            let v1326 = Some(v1325);
                            // Rule at src/isa/x64/lower.isle line 1996.
                            return v1326;
                        }
                    }
                    &IntCC::SignedGreaterThan => {
                        let v1 = C::first_result(ctx, arg0);
                        if let Some(v2) = v1 {
                            let v3 = C::value_type(ctx, v2);
                            if v3 == I8 {
                                let v1262 = C::unpack_value_array_2(ctx, v1260);
                                let v1283 = C::def_inst(ctx, v1262.0);
                                if let Some(v1284) = v1283 {
                                    let v1285 = &C::inst_data_value(ctx, v1284);
                                    if let &InstructionData::UnaryImm {
                                        opcode: ref v1286,
                                        imm: v1287,
                                    } = v1285 {
                                        if let &Opcode::Iconst = v1286 {
                                            let v1288 = C::u64_from_imm64(ctx, v1287);
                                            if v1288 == 0x0_u64 {
                                                let v1289 = C::value_type(ctx, v1262.1);
                                                match v1289 {
                                                    I32 => {
                                                        let v1290 = constructor_put_in_gpr(ctx, v1262.1);
                                                        let v1306 = constructor_x64_shrl_mi(ctx, v1290, 0x1f_u8);
                                                        let v1307 = constructor_output_gpr(ctx, v1306);
                                                        let v1308 = Some(v1307);
                                                        // Rule at src/isa/x64/lower.isle line 1975.
                                                        return v1308;
                                                    }
                                                    I64 => {
                                                        let v1290 = constructor_put_in_gpr(ctx, v1262.1);
                                                        let v1291 = constructor_x64_shrq_mi(ctx, v1290, 0x3f_u8);
                                                        let v1292 = constructor_output_gpr(ctx, v1291);
                                                        let v1293 = Some(v1292);
                                                        // Rule at src/isa/x64/lower.isle line 1959.
                                                        return v1293;
                                                    }
                                                    _ => {}
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                        let v1262 = C::unpack_value_array_2(ctx, v1260);
                        let v1265 = C::value_type(ctx, v1262.0);
                        let v1315 = C::ty_vec128(ctx, v1265);
                        if let Some(v1316) = v1315 {
                            let v1317 = constructor_put_in_xmm(ctx, v1262.0);
                            let v1318 = &C::put_in_xmm_mem(ctx, v1262.1);
                            let v1327 = constructor_x64_pcmpgt(ctx, v1316, v1317, v1318);
                            let v1328 = constructor_output_xmm(ctx, v1327);
                            let v1329 = Some(v1328);
                            // Rule at src/isa/x64/lower.isle line 2003.
                            return v1329;
                        }
                    }
                    &IntCC::SignedGreaterThanOrEqual => {
                        let v1 = C::first_result(ctx, arg0);
                        if let Some(v2) = v1 {
                            let v3 = C::value_type(ctx, v2);
                            if v3 == I8 {
                                let v1262 = C::unpack_value_array_2(ctx, v1260);
                                let v1265 = C::value_type(ctx, v1262.0);
                                match v1265 {
                                    I32 => {
                                        let v1272 = C::def_inst(ctx, v1262.1);
                                        if let Some(v1273) = v1272 {
                                            let v1274 = &C::inst_data_value(ctx, v1273);
                                            if let &InstructionData::UnaryImm {
                                                opcode: ref v1275,
                                                imm: v1276,
                                            } = v1274 {
                                                if let &Opcode::Iconst = v1275 {
                                                    let v1277 = C::u64_from_imm64(ctx, v1276);
                                                    if v1277 == 0x0_u64 {
                                                        let v1278 = constructor_put_in_gpr(ctx, v1262.0);
                                                        let v1298 = constructor_x64_not(ctx, I64, v1278);
                                                        let v1312 = constructor_x64_shrl_mi(ctx, v1298, 0x1f_u8);
                                                        let v1313 = constructor_output_gpr(ctx, v1312);
                                                        let v1314 = Some(v1313);
                                                        // Rule at src/isa/x64/lower.isle line 1983.
                                                        return v1314;
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    I64 => {
                                        let v1272 = C::def_inst(ctx, v1262.1);
                                        if let Some(v1273) = v1272 {
                                            let v1274 = &C::inst_data_value(ctx, v1273);
                                            if let &InstructionData::UnaryImm {
                                                opcode: ref v1275,
                                                imm: v1276,
                                            } = v1274 {
                                                if let &Opcode::Iconst = v1275 {
                                                    let v1277 = C::u64_from_imm64(ctx, v1276);
                                                    if v1277 == 0x0_u64 {
                                                        let v1278 = constructor_put_in_gpr(ctx, v1262.0);
                                                        let v1298 = constructor_x64_not(ctx, I64, v1278);
                                                        let v1299 = constructor_x64_shrq_mi(ctx, v1298, 0x3f_u8);
                                                        let v1300 = constructor_output_gpr(ctx, v1299);
                                                        let v1301 = Some(v1300);
                                                        // Rule at src/isa/x64/lower.isle line 1967.
                                                        return v1301;
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    _ => {}
                                }
                            }
                        }
                        let v1262 = C::unpack_value_array_2(ctx, v1260);
                        let v1265 = C::value_type(ctx, v1262.0);
                        let v1315 = C::ty_vec128(ctx, v1265);
                        if let Some(v1316) = v1315 {
                            let v1367 = constructor_has_pmaxs(ctx, v1316);
                            if v1367 == true {
                                let v1317 = constructor_put_in_xmm(ctx, v1262.0);
                                let v1347 = constructor_put_in_xmm(ctx, v1262.0);
                                let v1368 = &C::put_in_xmm_mem(ctx, v1262.1);
                                let v1369 = constructor_x64_pmaxs(ctx, v1316, v1347, v1368);
                                let v1370 = &C::xmm_to_xmm_mem(ctx, v1369);
                                let v1371 = constructor_x64_pcmpeq(ctx, v1316, v1317, v1370);
                                let v1372 = constructor_output_xmm(ctx, v1371);
                                let v1373 = Some(v1372);
                                // Rule at src/isa/x64/lower.isle line 2053.
                                return v1373;
                            }
                            let v1330 = constructor_put_in_xmm(ctx, v1262.1);
                            let v1331 = &C::put_in_xmm_mem(ctx, v1262.0);
                            let v1332 = constructor_x64_pcmpgt(ctx, v1316, v1330, v1331);
                            let v1322 = constructor_vector_all_ones(ctx);
                            let v1323 = &C::xmm_to_xmm_mem(ctx, v1322);
                            let v1374 = constructor_x64_pxor(ctx, v1332, v1323);
                            let v1375 = constructor_output_xmm(ctx, v1374);
                            let v1376 = Some(v1375);
                            // Rule at src/isa/x64/lower.isle line 2059.
                            return v1376;
                        }
                    }
                    &IntCC::SignedLessThan => {
                        let v1 = C::first_result(ctx, arg0);
                        if let Some(v2) = v1 {
                            let v3 = C::value_type(ctx, v2);
                            if v3 == I8 {
                                let v1262 = C::unpack_value_array_2(ctx, v1260);
                                let v1265 = C::value_type(ctx, v1262.0);
                                match v1265 {
                                    I32 => {
                                        let v1272 = C::def_inst(ctx, v1262.1);
                                        if let Some(v1273) = v1272 {
                                            let v1274 = &C::inst_data_value(ctx, v1273);
                                            if let &InstructionData::UnaryImm {
                                                opcode: ref v1275,
                                                imm: v1276,
                                            } = v1274 {
                                                if let &Opcode::Iconst = v1275 {
                                                    let v1277 = C::u64_from_imm64(ctx, v1276);
                                                    if v1277 == 0x0_u64 {
                                                        let v1278 = constructor_put_in_gpr(ctx, v1262.0);
                                                        let v1303 = constructor_x64_shrl_mi(ctx, v1278, 0x1f_u8);
                                                        let v1304 = constructor_output_gpr(ctx, v1303);
                                                        let v1305 = Some(v1304);
                                                        // Rule at src/isa/x64/lower.isle line 1971.
                                                        return v1305;
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    I64 => {
                                        let v1272 = C::def_inst(ctx, v1262.1);
                                        if let Some(v1273) = v1272 {
                                            let v1274 = &C::inst_data_value(ctx, v1273);
                                            if let &InstructionData::UnaryImm {
                                                opcode: ref v1275,
                                                imm: v1276,
                                            } = v1274 {
                                                if let &Opcode::Iconst = v1275 {
                                                    let v1277 = C::u64_from_imm64(ctx, v1276);
                                                    if v1277 == 0x0_u64 {
                                                        let v1278 = constructor_put_in_gpr(ctx, v1262.0);
                                                        let v1280 = constructor_x64_shrq_mi(ctx, v1278, 0x3f_u8);
                                                        let v1281 = constructor_output_gpr(ctx, v1280);
                                                        let v1282 = Some(v1281);
                                                        // Rule at src/isa/x64/lower.isle line 1955.
                                                        return v1282;
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    _ => {}
                                }
                            }
                        }
                        let v1262 = C::unpack_value_array_2(ctx, v1260);
                        let v1265 = C::value_type(ctx, v1262.0);
                        let v1315 = C::ty_vec128(ctx, v1265);
                        if let Some(v1316) = v1315 {
                            let v1330 = constructor_put_in_xmm(ctx, v1262.1);
                            let v1331 = &C::put_in_xmm_mem(ctx, v1262.0);
                            let v1332 = constructor_x64_pcmpgt(ctx, v1316, v1330, v1331);
                            let v1333 = constructor_output_xmm(ctx, v1332);
                            let v1334 = Some(v1333);
                            // Rule at src/isa/x64/lower.isle line 2008.
                            return v1334;
                        }
                    }
                    &IntCC::SignedLessThanOrEqual => {
                        let v1 = C::first_result(ctx, arg0);
                        if let Some(v2) = v1 {
                            let v3 = C::value_type(ctx, v2);
                            if v3 == I8 {
                                let v1262 = C::unpack_value_array_2(ctx, v1260);
                                let v1283 = C::def_inst(ctx, v1262.0);
                                if let Some(v1284) = v1283 {
                                    let v1285 = &C::inst_data_value(ctx, v1284);
                                    if let &InstructionData::UnaryImm {
                                        opcode: ref v1286,
                                        imm: v1287,
                                    } = v1285 {
                                        if let &Opcode::Iconst = v1286 {
                                            let v1288 = C::u64_from_imm64(ctx, v1287);
                                            if v1288 == 0x0_u64 {
                                                let v1289 = C::value_type(ctx, v1262.1);
                                                match v1289 {
                                                    I32 => {
                                                        let v1290 = constructor_put_in_gpr(ctx, v1262.1);
                                                        let v1294 = constructor_x64_not(ctx, I64, v1290);
                                                        let v1309 = constructor_x64_shrl_mi(ctx, v1294, 0x1f_u8);
                                                        let v1310 = constructor_output_gpr(ctx, v1309);
                                                        let v1311 = Some(v1310);
                                                        // Rule at src/isa/x64/lower.isle line 1979.
                                                        return v1311;
                                                    }
                                                    I64 => {
                                                        let v1290 = constructor_put_in_gpr(ctx, v1262.1);
                                                        let v1294 = constructor_x64_not(ctx, I64, v1290);
                                                        let v1295 = constructor_x64_shrq_mi(ctx, v1294, 0x3f_u8);
                                                        let v1296 = constructor_output_gpr(ctx, v1295);
                                                        let v1297 = Some(v1296);
                                                        // Rule at src/isa/x64/lower.isle line 1963.
                                                        return v1297;
                                                    }
                                                    _ => {}
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                        let v1262 = C::unpack_value_array_2(ctx, v1260);
                        let v1265 = C::value_type(ctx, v1262.0);
                        let v1315 = C::ty_vec128(ctx, v1265);
                        if let Some(v1316) = v1315 {
                            let v1377 = constructor_has_pmins(ctx, v1316);
                            if v1377 == true {
                                let v1317 = constructor_put_in_xmm(ctx, v1262.0);
                                let v1347 = constructor_put_in_xmm(ctx, v1262.0);
                                let v1368 = &C::put_in_xmm_mem(ctx, v1262.1);
                                let v1378 = constructor_x64_pmins(ctx, v1316, v1347, v1368);
                                let v1379 = &C::xmm_to_xmm_mem(ctx, v1378);
                                let v1380 = constructor_x64_pcmpeq(ctx, v1316, v1317, v1379);
                                let v1381 = constructor_output_xmm(ctx, v1380);
                                let v1382 = Some(v1381);
                                // Rule at src/isa/x64/lower.isle line 2065.
                                return v1382;
                            }
                            let v1317 = constructor_put_in_xmm(ctx, v1262.0);
                            let v1318 = &C::put_in_xmm_mem(ctx, v1262.1);
                            let v1327 = constructor_x64_pcmpgt(ctx, v1316, v1317, v1318);
                            let v1322 = constructor_vector_all_ones(ctx);
                            let v1323 = &C::xmm_to_xmm_mem(ctx, v1322);
                            let v1383 = constructor_x64_pxor(ctx, v1327, v1323);
                            let v1384 = constructor_output_xmm(ctx, v1383);
                            let v1385 = Some(v1384);
                            // Rule at src/isa/x64/lower.isle line 2070.
                            return v1385;
                        }
                    }
                    &IntCC::UnsignedGreaterThan => {
                        let v1262 = C::unpack_value_array_2(ctx, v1260);
                        let v1265 = C::value_type(ctx, v1262.0);
                        let v1315 = C::ty_vec128(ctx, v1265);
                        if let Some(v1316) = v1315 {
                            let v1335 = constructor_has_pmaxu(ctx, v1316);
                            if v1335 == true {
                                let v1317 = constructor_put_in_xmm(ctx, v1262.0);
                                let v1336 = constructor_put_in_xmm(ctx, v1262.1);
                                let v1337 = &C::xmm_to_xmm_mem(ctx, v1336);
                                let v1338 = constructor_x64_pmaxu(ctx, v1316, v1317, v1337);
                                let v1339 = &C::xmm_to_xmm_mem(ctx, v1336);
                                let v1340 = constructor_x64_pcmpeq(ctx, v1316, v1338, v1339);
                                let v1341 = constructor_vector_all_ones(ctx);
                                let v1342 = &C::xmm_to_xmm_mem(ctx, v1341);
                                let v1343 = constructor_x64_pxor(ctx, v1340, v1342);
                                let v1344 = constructor_output_xmm(ctx, v1343);
                                let v1345 = Some(v1344);
                                // Rule at src/isa/x64/lower.isle line 2015.
                                return v1345;
                            }
                            let v1346 = constructor_flip_high_bit_mask(ctx, v1316);
                            let v1347 = constructor_put_in_xmm(ctx, v1262.0);
                            let v1348 = &C::xmm_to_xmm_mem(ctx, v1346);
                            let v1349 = constructor_x64_pxor(ctx, v1347, v1348);
                            let v1350 = constructor_put_in_xmm(ctx, v1262.1);
                            let v1351 = &C::xmm_to_xmm_mem(ctx, v1346);
                            let v1352 = constructor_x64_pxor(ctx, v1350, v1351);
                            let v1353 = &C::xmm_to_xmm_mem(ctx, v1352);
                            let v1354 = constructor_x64_pcmpgt(ctx, v1316, v1349, v1353);
                            let v1355 = constructor_output_xmm(ctx, v1354);
                            let v1356 = Some(v1355);
                            // Rule at src/isa/x64/lower.isle line 2025.
                            return v1356;
                        }
                    }
                    &IntCC::UnsignedGreaterThanOrEqual => {
                        let v1262 = C::unpack_value_array_2(ctx, v1260);
                        let v1265 = C::value_type(ctx, v1262.0);
                        let v1315 = C::ty_vec128(ctx, v1265);
                        if let Some(v1316) = v1315 {
                            let v1335 = constructor_has_pmaxu(ctx, v1316);
                            if v1335 == true {
                                let v1317 = constructor_put_in_xmm(ctx, v1262.0);
                                let v1347 = constructor_put_in_xmm(ctx, v1262.0);
                                let v1368 = &C::put_in_xmm_mem(ctx, v1262.1);
                                let v1386 = constructor_x64_pmaxu(ctx, v1316, v1347, v1368);
                                let v1387 = &C::xmm_to_xmm_mem(ctx, v1386);
                                let v1388 = constructor_x64_pcmpeq(ctx, v1316, v1317, v1387);
                                let v1389 = constructor_output_xmm(ctx, v1388);
                                let v1390 = Some(v1389);
                                // Rule at src/isa/x64/lower.isle line 2075.
                                return v1390;
                            }
                        }
                        if v1265 == I16X8 {
                            let v1330 = constructor_put_in_xmm(ctx, v1262.1);
                            let v1331 = &C::put_in_xmm_mem(ctx, v1262.0);
                            let v1391 = constructor_x64_psubusw(ctx, v1330, v1331);
                            let v1392 = constructor_xmm_zero(ctx, I16X8);
                            let v1393 = &C::xmm_to_xmm_mem(ctx, v1392);
                            let v1394 = constructor_x64_pcmpeqw(ctx, v1391, v1393);
                            let v1395 = constructor_output_xmm(ctx, v1394);
                            let v1396 = Some(v1395);
                            // Rule at src/isa/x64/lower.isle line 2081.
                            return v1396;
                        }
                        if let Some(v1316) = v1315 {
                            let v1346 = constructor_flip_high_bit_mask(ctx, v1316);
                            let v1347 = constructor_put_in_xmm(ctx, v1262.0);
                            let v1348 = &C::xmm_to_xmm_mem(ctx, v1346);
                            let v1349 = constructor_x64_pxor(ctx, v1347, v1348);
                            let v1350 = constructor_put_in_xmm(ctx, v1262.1);
                            let v1351 = &C::xmm_to_xmm_mem(ctx, v1346);
                            let v1352 = constructor_x64_pxor(ctx, v1350, v1351);
                            let v1363 = &C::xmm_to_xmm_mem(ctx, v1349);
                            let v1364 = constructor_x64_pcmpgt(ctx, v1316, v1352, v1363);
                            let v1397 = constructor_vector_all_ones(ctx);
                            let v1398 = &C::xmm_to_xmm_mem(ctx, v1397);
                            let v1399 = constructor_x64_pxor(ctx, v1364, v1398);
                            let v1400 = constructor_output_xmm(ctx, v1399);
                            let v1401 = Some(v1400);
                            // Rule at src/isa/x64/lower.isle line 2087.
                            return v1401;
                        }
                    }
                    &IntCC::UnsignedLessThan => {
                        let v1262 = C::unpack_value_array_2(ctx, v1260);
                        let v1265 = C::value_type(ctx, v1262.0);
                        let v1315 = C::ty_vec128(ctx, v1265);
                        if let Some(v1316) = v1315 {
                            let v1357 = constructor_has_pminu(ctx, v1316);
                            if v1357 == true {
                                let v1317 = constructor_put_in_xmm(ctx, v1262.0);
                                let v1336 = constructor_put_in_xmm(ctx, v1262.1);
                                let v1337 = &C::xmm_to_xmm_mem(ctx, v1336);
                                let v1358 = constructor_x64_pminu(ctx, v1316, v1317, v1337);
                                let v1339 = &C::xmm_to_xmm_mem(ctx, v1336);
                                let v1359 = constructor_x64_pcmpeq(ctx, v1316, v1358, v1339);
                                let v1341 = constructor_vector_all_ones(ctx);
                                let v1342 = &C::xmm_to_xmm_mem(ctx, v1341);
                                let v1360 = constructor_x64_pxor(ctx, v1359, v1342);
                                let v1361 = constructor_output_xmm(ctx, v1360);
                                let v1362 = Some(v1361);
                                // Rule at src/isa/x64/lower.isle line 2033.
                                return v1362;
                            }
                            let v1346 = constructor_flip_high_bit_mask(ctx, v1316);
                            let v1347 = constructor_put_in_xmm(ctx, v1262.0);
                            let v1348 = &C::xmm_to_xmm_mem(ctx, v1346);
                            let v1349 = constructor_x64_pxor(ctx, v1347, v1348);
                            let v1350 = constructor_put_in_xmm(ctx, v1262.1);
                            let v1351 = &C::xmm_to_xmm_mem(ctx, v1346);
                            let v1352 = constructor_x64_pxor(ctx, v1350, v1351);
                            let v1363 = &C::xmm_to_xmm_mem(ctx, v1349);
                            let v1364 = constructor_x64_pcmpgt(ctx, v1316, v1352, v1363);
                            let v1365 = constructor_output_xmm(ctx, v1364);
                            let v1366 = Some(v1365);
                            // Rule at src/isa/x64/lower.isle line 2044.
                            return v1366;
                        }
                    }
                    &IntCC::UnsignedLessThanOrEqual => {
                        let v1262 = C::unpack_value_array_2(ctx, v1260);
                        let v1265 = C::value_type(ctx, v1262.0);
                        let v1315 = C::ty_vec128(ctx, v1265);
                        if let Some(v1316) = v1315 {
                            let v1357 = constructor_has_pminu(ctx, v1316);
                            if v1357 == true {
                                let v1317 = constructor_put_in_xmm(ctx, v1262.0);
                                let v1347 = constructor_put_in_xmm(ctx, v1262.0);
                                let v1368 = &C::put_in_xmm_mem(ctx, v1262.1);
                                let v1402 = constructor_x64_pminu(ctx, v1316, v1347, v1368);
                                let v1403 = &C::xmm_to_xmm_mem(ctx, v1402);
                                let v1404 = constructor_x64_pcmpeq(ctx, v1316, v1317, v1403);
                                let v1405 = constructor_output_xmm(ctx, v1404);
                                let v1406 = Some(v1405);
                                // Rule at src/isa/x64/lower.isle line 2098.
                                return v1406;
                            }
                        }
                        if v1265 == I16X8 {
                            let v1317 = constructor_put_in_xmm(ctx, v1262.0);
                            let v1318 = &C::put_in_xmm_mem(ctx, v1262.1);
                            let v1407 = constructor_x64_psubusw(ctx, v1317, v1318);
                            let v1408 = constructor_xmm_zero(ctx, I8X16);
                            let v1409 = &C::xmm_to_xmm_mem(ctx, v1408);
                            let v1410 = constructor_x64_pcmpeqw(ctx, v1407, v1409);
                            let v1411 = constructor_output_xmm(ctx, v1410);
                            let v1412 = Some(v1411);
                            // Rule at src/isa/x64/lower.isle line 2105.
                            return v1412;
                        }
                        if let Some(v1316) = v1315 {
                            let v1346 = constructor_flip_high_bit_mask(ctx, v1316);
                            let v1347 = constructor_put_in_xmm(ctx, v1262.0);
                            let v1348 = &C::xmm_to_xmm_mem(ctx, v1346);
                            let v1349 = constructor_x64_pxor(ctx, v1347, v1348);
                            let v1350 = constructor_put_in_xmm(ctx, v1262.1);
                            let v1351 = &C::xmm_to_xmm_mem(ctx, v1346);
                            let v1352 = constructor_x64_pxor(ctx, v1350, v1351);
                            let v1353 = &C::xmm_to_xmm_mem(ctx, v1352);
                            let v1354 = constructor_x64_pcmpgt(ctx, v1316, v1349, v1353);
                            let v1397 = constructor_vector_all_ones(ctx);
                            let v1398 = &C::xmm_to_xmm_mem(ctx, v1397);
                            let v1413 = constructor_x64_pxor(ctx, v1354, v1398);
                            let v1414 = constructor_output_xmm(ctx, v1413);
                            let v1415 = Some(v1414);
                            // Rule at src/isa/x64/lower.isle line 2113.
                            return v1415;
                        }
                    }
                    _ => {}
                }
                let v1262 = C::unpack_value_array_2(ctx, v1260);
                let v1265 = C::value_type(ctx, v1262.0);
                if v1265 == I128 {
                    let v1268 = &constructor_emit_cmp(ctx, v1261, v1262.0, v1262.1);
                    let v1269 = constructor_lower_cond_bool(ctx, v1268);
                    let v1270 = constructor_output_gpr(ctx, v1269);
                    let v1271 = Some(v1270);
                    // Rule at src/isa/x64/lower.isle line 1951.
                    return v1271;
                }
                let v1266 = C::fits_in_64(ctx, v1265);
                if let Some(v1267) = v1266 {
                    let v1268 = &constructor_emit_cmp(ctx, v1261, v1262.0, v1262.1);
                    let v1269 = constructor_lower_cond_bool(ctx, v1268);
                    let v1270 = constructor_output_gpr(ctx, v1269);
                    let v1271 = Some(v1270);
                    // Rule at src/isa/x64/lower.isle line 1948.
                    return v1271;
                }
            }
        }
        &InstructionData::Load {
            opcode: ref v2027,
            arg: v2028,
            flags: v2029,
            offset: v2030,
        } => {
            match v2027 {
                &Opcode::Load => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v2031 = C::little_or_native_endian(ctx, v2029);
                        if let Some(v2032) = v2031 {
                            let v3 = C::value_type(ctx, v2);
                            let v2024 = &C::type_register_class(ctx, v3);
                            if let Some(v2025) = v2024 {
                                if let &RegisterClass::Xmm = v2025 {
                                    let v2068 = C::ty_16(ctx, v3);
                                    if let Some(v2069) = v2068 {
                                        let v2070 = constructor_xmm_uninit_value(ctx);
                                        let v2036 = &constructor_to_amode(ctx, v2032, v2028, v2030);
                                        let v2037 = &constructor_synthetic_amode_to_gpr_mem(ctx, v2036);
                                        let v2072 = constructor_x64_pinsrw(ctx, v2070, v2037, 0x0_u8);
                                        let v2073 = constructor_output_xmm(ctx, v2072);
                                        let v2074 = Some(v2073);
                                        // Rule at src/isa/x64/lower.isle line 3079.
                                        return v2074;
                                    }
                                    let v2075 = C::ty_32(ctx, v3);
                                    if let Some(v2076) = v2075 {
                                        let v2043 = &constructor_to_amode(ctx, v2032, v2028, v2030);
                                        let v2077 = constructor_x64_movss_load(ctx, v2043);
                                        let v2078 = constructor_output_xmm(ctx, v2077);
                                        let v2079 = Some(v2078);
                                        // Rule at src/isa/x64/lower.isle line 3081.
                                        return v2079;
                                    }
                                    let v2080 = C::ty_64(ctx, v3);
                                    if let Some(v2081) = v2080 {
                                        let v2043 = &constructor_to_amode(ctx, v2032, v2028, v2030);
                                        let v2082 = constructor_x64_movsd_load(ctx, v2043);
                                        let v2083 = constructor_output_xmm(ctx, v2082);
                                        let v2084 = Some(v2083);
                                        // Rule at src/isa/x64/lower.isle line 3083.
                                        return v2084;
                                    }
                                }
                            }
                            match v3 {
                                F32X4 => {
                                    let v2043 = &constructor_to_amode(ctx, v2032, v2028, v2030);
                                    let v2085 = constructor_x64_movups_load(ctx, v2043);
                                    let v2086 = constructor_output_xmm(ctx, v2085);
                                    let v2087 = Some(v2086);
                                    // Rule at src/isa/x64/lower.isle line 3085.
                                    return v2087;
                                }
                                F64X2 => {
                                    let v2043 = &constructor_to_amode(ctx, v2032, v2028, v2030);
                                    let v2088 = constructor_x64_movupd_load(ctx, v2043);
                                    let v2089 = constructor_output_xmm(ctx, v2088);
                                    let v2090 = Some(v2089);
                                    // Rule at src/isa/x64/lower.isle line 3087.
                                    return v2090;
                                }
                                _ => {}
                            }
                            if let Some(v2025) = v2024 {
                                if let &RegisterClass::Xmm = v2025 {
                                    let v2091 = C::ty_128(ctx, v3);
                                    if let Some(v2092) = v2091 {
                                        let v2043 = &constructor_to_amode(ctx, v2032, v2028, v2030);
                                        let v2093 = &constructor_synthetic_amode_to_xmm_mem(ctx, v2043);
                                        let v2094 = constructor_x64_movdqu_load(ctx, v2093);
                                        let v2095 = constructor_output_xmm(ctx, v2094);
                                        let v2096 = Some(v2095);
                                        // Rule at src/isa/x64/lower.isle line 3089.
                                        return v2096;
                                    }
                                }
                            }
                            let v2041 = C::ty_int_ref_64(ctx, v3);
                            if let Some(v2042) = v2041 {
                                let v2043 = &constructor_to_amode(ctx, v2032, v2028, v2030);
                                let v2044 = constructor_x64_mov(ctx, v2043);
                                let v2045 = constructor_output_reg(ctx, v2044);
                                let v2046 = Some(v2045);
                                // Rule at src/isa/x64/lower.isle line 3057.
                                return v2046;
                            }
                            if v3 == I128 {
                                let v2043 = &constructor_to_amode(ctx, v2032, v2028, v2030);
                                let v2098 = &C::amode_offset(ctx, v2043, 8_i32);
                                let v2099 = constructor_x64_mov(ctx, v2043);
                                let v2100 = constructor_x64_mov(ctx, v2098);
                                let v2101 = C::value_regs(ctx, v2099, v2100);
                                let v2102 = C::output(ctx, v2101);
                                let v2103 = Some(v2102);
                                // Rule at src/isa/x64/lower.isle line 3093.
                                return v2103;
                            }
                            if let Some(v2025) = v2024 {
                                if let &RegisterClass::Gpr {
                                    single_register: v2026,
                                } = v2025 {
                                    let v1737 = C::fits_in_32(ctx, v3);
                                    if let Some(v1738) = v1737 {
                                        let v2033 = C::ty_bits_u16(ctx, v1738);
                                        let v2035 = &C::ext_mode(ctx, v2033, 0x40_u16);
                                        let v2036 = &constructor_to_amode(ctx, v2032, v2028, v2030);
                                        let v2037 = &constructor_synthetic_amode_to_gpr_mem(ctx, v2036);
                                        let v2038 = constructor_x64_movzx(ctx, v2035, v2037);
                                        let v2039 = constructor_output_gpr(ctx, v2038);
                                        let v2040 = Some(v2039);
                                        // Rule at src/isa/x64/lower.isle line 3052.
                                        return v2040;
                                    }
                                }
                            }
                        }
                    }
                }
                &Opcode::Uload8 => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        let v2024 = &C::type_register_class(ctx, v3);
                        if let Some(v2025) = v2024 {
                            if let &RegisterClass::Gpr {
                                single_register: v2026,
                            } = v2025 {
                                let v2031 = C::little_or_native_endian(ctx, v2029);
                                if let Some(v2032) = v2031 {
                                    let v2043 = &constructor_to_amode(ctx, v2032, v2028, v2030);
                                    let v2047 = &constructor_synthetic_amode_to_gpr_mem(ctx, v2043);
                                    let v2048 = constructor_x64_movzx(ctx, &ExtMode::BQ, v2047);
                                    let v2049 = constructor_output_gpr(ctx, v2048);
                                    let v2050 = Some(v2049);
                                    // Rule at src/isa/x64/lower.isle line 3062.
                                    return v2050;
                                }
                            }
                        }
                    }
                }
                &Opcode::Sload8 => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        let v2024 = &C::type_register_class(ctx, v3);
                        if let Some(v2025) = v2024 {
                            if let &RegisterClass::Gpr {
                                single_register: v2026,
                            } = v2025 {
                                let v2031 = C::little_or_native_endian(ctx, v2029);
                                if let Some(v2032) = v2031 {
                                    let v2043 = &constructor_to_amode(ctx, v2032, v2028, v2030);
                                    let v2047 = &constructor_synthetic_amode_to_gpr_mem(ctx, v2043);
                                    let v2051 = constructor_x64_movsx(ctx, &ExtMode::BQ, v2047);
                                    let v2052 = constructor_output_gpr(ctx, v2051);
                                    let v2053 = Some(v2052);
                                    // Rule at src/isa/x64/lower.isle line 3064.
                                    return v2053;
                                }
                            }
                        }
                    }
                }
                &Opcode::Uload16 => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        let v2024 = &C::type_register_class(ctx, v3);
                        if let Some(v2025) = v2024 {
                            if let &RegisterClass::Gpr {
                                single_register: v2026,
                            } = v2025 {
                                let v2031 = C::little_or_native_endian(ctx, v2029);
                                if let Some(v2032) = v2031 {
                                    let v2043 = &constructor_to_amode(ctx, v2032, v2028, v2030);
                                    let v2047 = &constructor_synthetic_amode_to_gpr_mem(ctx, v2043);
                                    let v2055 = constructor_x64_movzx(ctx, &ExtMode::WQ, v2047);
                                    let v2056 = constructor_output_gpr(ctx, v2055);
                                    let v2057 = Some(v2056);
                                    // Rule at src/isa/x64/lower.isle line 3066.
                                    return v2057;
                                }
                            }
                        }
                    }
                }
                &Opcode::Sload16 => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        let v2024 = &C::type_register_class(ctx, v3);
                        if let Some(v2025) = v2024 {
                            if let &RegisterClass::Gpr {
                                single_register: v2026,
                            } = v2025 {
                                let v2031 = C::little_or_native_endian(ctx, v2029);
                                if let Some(v2032) = v2031 {
                                    let v2043 = &constructor_to_amode(ctx, v2032, v2028, v2030);
                                    let v2047 = &constructor_synthetic_amode_to_gpr_mem(ctx, v2043);
                                    let v2058 = constructor_x64_movsx(ctx, &ExtMode::WQ, v2047);
                                    let v2059 = constructor_output_gpr(ctx, v2058);
                                    let v2060 = Some(v2059);
                                    // Rule at src/isa/x64/lower.isle line 3068.
                                    return v2060;
                                }
                            }
                        }
                    }
                }
                &Opcode::Uload32 => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        let v2024 = &C::type_register_class(ctx, v3);
                        if let Some(v2025) = v2024 {
                            if let &RegisterClass::Gpr {
                                single_register: v2026,
                            } = v2025 {
                                let v2031 = C::little_or_native_endian(ctx, v2029);
                                if let Some(v2032) = v2031 {
                                    let v2043 = &constructor_to_amode(ctx, v2032, v2028, v2030);
                                    let v2047 = &constructor_synthetic_amode_to_gpr_mem(ctx, v2043);
                                    let v2062 = constructor_x64_movzx(ctx, &ExtMode::LQ, v2047);
                                    let v2063 = constructor_output_gpr(ctx, v2062);
                                    let v2064 = Some(v2063);
                                    // Rule at src/isa/x64/lower.isle line 3070.
                                    return v2064;
                                }
                            }
                        }
                    }
                }
                &Opcode::Sload32 => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        let v2024 = &C::type_register_class(ctx, v3);
                        if let Some(v2025) = v2024 {
                            if let &RegisterClass::Gpr {
                                single_register: v2026,
                            } = v2025 {
                                let v2031 = C::little_or_native_endian(ctx, v2029);
                                if let Some(v2032) = v2031 {
                                    let v2043 = &constructor_to_amode(ctx, v2032, v2028, v2030);
                                    let v2047 = &constructor_synthetic_amode_to_gpr_mem(ctx, v2043);
                                    let v2065 = constructor_x64_movsx(ctx, &ExtMode::LQ, v2047);
                                    let v2066 = constructor_output_gpr(ctx, v2065);
                                    let v2067 = Some(v2066);
                                    // Rule at src/isa/x64/lower.isle line 3072.
                                    return v2067;
                                }
                            }
                        }
                    }
                }
                &Opcode::Uload8x8 => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        if v3 == I16X8 {
                            let v2031 = C::little_or_native_endian(ctx, v2029);
                            if let Some(v2032) = v2031 {
                                let v678 = C::has_sse41(ctx);
                                if v678 == true {
                                    let v2043 = &constructor_to_amode(ctx, v2032, v2028, v2030);
                                    let v2093 = &constructor_synthetic_amode_to_xmm_mem(ctx, v2043);
                                    let v2107 = constructor_x64_pmovzxbw(ctx, v2093);
                                    let v2108 = constructor_output_xmm(ctx, v2107);
                                    let v2109 = Some(v2108);
                                    // Rule at src/isa/x64/lower.isle line 3106.
                                    return v2109;
                                }
                                let v2043 = &constructor_to_amode(ctx, v2032, v2028, v2030);
                                let v2047 = &constructor_synthetic_amode_to_gpr_mem(ctx, v2043);
                                let v2122 = constructor_x64_movq_to_xmm(ctx, v2047);
                                let v2126 = constructor_lower_uwiden_low(ctx, I16X8, v2122);
                                let v2127 = constructor_output_xmm(ctx, v2126);
                                let v2128 = Some(v2127);
                                // Rule at src/isa/x64/lower.isle line 3124.
                                return v2128;
                            }
                        }
                    }
                }
                &Opcode::Sload8x8 => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        if v3 == I16X8 {
                            let v2031 = C::little_or_native_endian(ctx, v2029);
                            if let Some(v2032) = v2031 {
                                let v678 = C::has_sse41(ctx);
                                if v678 == true {
                                    let v2043 = &constructor_to_amode(ctx, v2032, v2028, v2030);
                                    let v2093 = &constructor_synthetic_amode_to_xmm_mem(ctx, v2043);
                                    let v2104 = constructor_x64_pmovsxbw(ctx, v2093);
                                    let v2105 = constructor_output_xmm(ctx, v2104);
                                    let v2106 = Some(v2105);
                                    // Rule at src/isa/x64/lower.isle line 3103.
                                    return v2106;
                                }
                                let v2043 = &constructor_to_amode(ctx, v2032, v2028, v2030);
                                let v2047 = &constructor_synthetic_amode_to_gpr_mem(ctx, v2043);
                                let v2122 = constructor_x64_movq_to_xmm(ctx, v2047);
                                let v2123 = constructor_lower_swiden_low(ctx, I16X8, v2122);
                                let v2124 = constructor_output_xmm(ctx, v2123);
                                let v2125 = Some(v2124);
                                // Rule at src/isa/x64/lower.isle line 3122.
                                return v2125;
                            }
                        }
                    }
                }
                &Opcode::Uload16x4 => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        if v3 == I32X4 {
                            let v2031 = C::little_or_native_endian(ctx, v2029);
                            if let Some(v2032) = v2031 {
                                let v678 = C::has_sse41(ctx);
                                if v678 == true {
                                    let v2043 = &constructor_to_amode(ctx, v2032, v2028, v2030);
                                    let v2093 = &constructor_synthetic_amode_to_xmm_mem(ctx, v2043);
                                    let v2113 = constructor_x64_pmovzxwd(ctx, v2093);
                                    let v2114 = constructor_output_xmm(ctx, v2113);
                                    let v2115 = Some(v2114);
                                    // Rule at src/isa/x64/lower.isle line 3112.
                                    return v2115;
                                }
                                let v2043 = &constructor_to_amode(ctx, v2032, v2028, v2030);
                                let v2047 = &constructor_synthetic_amode_to_gpr_mem(ctx, v2043);
                                let v2122 = constructor_x64_movq_to_xmm(ctx, v2047);
                                let v2132 = constructor_lower_uwiden_low(ctx, I32X4, v2122);
                                let v2133 = constructor_output_xmm(ctx, v2132);
                                let v2134 = Some(v2133);
                                // Rule at src/isa/x64/lower.isle line 3128.
                                return v2134;
                            }
                        }
                    }
                }
                &Opcode::Sload16x4 => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        if v3 == I32X4 {
                            let v2031 = C::little_or_native_endian(ctx, v2029);
                            if let Some(v2032) = v2031 {
                                let v678 = C::has_sse41(ctx);
                                if v678 == true {
                                    let v2043 = &constructor_to_amode(ctx, v2032, v2028, v2030);
                                    let v2093 = &constructor_synthetic_amode_to_xmm_mem(ctx, v2043);
                                    let v2110 = constructor_x64_pmovsxwd(ctx, v2093);
                                    let v2111 = constructor_output_xmm(ctx, v2110);
                                    let v2112 = Some(v2111);
                                    // Rule at src/isa/x64/lower.isle line 3109.
                                    return v2112;
                                }
                                let v2043 = &constructor_to_amode(ctx, v2032, v2028, v2030);
                                let v2047 = &constructor_synthetic_amode_to_gpr_mem(ctx, v2043);
                                let v2122 = constructor_x64_movq_to_xmm(ctx, v2047);
                                let v2129 = constructor_lower_swiden_low(ctx, I32X4, v2122);
                                let v2130 = constructor_output_xmm(ctx, v2129);
                                let v2131 = Some(v2130);
                                // Rule at src/isa/x64/lower.isle line 3126.
                                return v2131;
                            }
                        }
                    }
                }
                &Opcode::Uload32x2 => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        if v3 == I64X2 {
                            let v2031 = C::little_or_native_endian(ctx, v2029);
                            if let Some(v2032) = v2031 {
                                let v678 = C::has_sse41(ctx);
                                if v678 == true {
                                    let v2043 = &constructor_to_amode(ctx, v2032, v2028, v2030);
                                    let v2093 = &constructor_synthetic_amode_to_xmm_mem(ctx, v2043);
                                    let v2119 = constructor_x64_pmovzxdq(ctx, v2093);
                                    let v2120 = constructor_output_xmm(ctx, v2119);
                                    let v2121 = Some(v2120);
                                    // Rule at src/isa/x64/lower.isle line 3118.
                                    return v2121;
                                }
                                let v2043 = &constructor_to_amode(ctx, v2032, v2028, v2030);
                                let v2047 = &constructor_synthetic_amode_to_gpr_mem(ctx, v2043);
                                let v2122 = constructor_x64_movq_to_xmm(ctx, v2047);
                                let v2138 = constructor_lower_uwiden_low(ctx, I64X2, v2122);
                                let v2139 = constructor_output_xmm(ctx, v2138);
                                let v2140 = Some(v2139);
                                // Rule at src/isa/x64/lower.isle line 3132.
                                return v2140;
                            }
                        }
                    }
                }
                &Opcode::Sload32x2 => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        if v3 == I64X2 {
                            let v2031 = C::little_or_native_endian(ctx, v2029);
                            if let Some(v2032) = v2031 {
                                let v678 = C::has_sse41(ctx);
                                if v678 == true {
                                    let v2043 = &constructor_to_amode(ctx, v2032, v2028, v2030);
                                    let v2093 = &constructor_synthetic_amode_to_xmm_mem(ctx, v2043);
                                    let v2116 = constructor_x64_pmovsxdq(ctx, v2093);
                                    let v2117 = constructor_output_xmm(ctx, v2116);
                                    let v2118 = Some(v2117);
                                    // Rule at src/isa/x64/lower.isle line 3115.
                                    return v2118;
                                }
                                let v2043 = &constructor_to_amode(ctx, v2032, v2028, v2030);
                                let v2047 = &constructor_synthetic_amode_to_gpr_mem(ctx, v2043);
                                let v2122 = constructor_x64_movq_to_xmm(ctx, v2047);
                                let v2135 = constructor_lower_swiden_low(ctx, I64X2, v2122);
                                let v2136 = constructor_output_xmm(ctx, v2135);
                                let v2137 = Some(v2136);
                                // Rule at src/isa/x64/lower.isle line 3130.
                                return v2137;
                            }
                        }
                    }
                }
                _ => {}
            }
        }
        &InstructionData::LoadNoOffset {
            opcode: ref v2330,
            arg: v2331,
            flags: v2332,
        } => {
            match v2330 {
                &Opcode::Bitcast => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        let v2024 = &C::type_register_class(ctx, v3);
                        if let Some(v2025) = v2024 {
                            match v2025 {
                                &RegisterClass::Gpr {
                                    single_register: v2026,
                                } => {
                                    let v2936 = C::value_type(ctx, v2331);
                                    let v2937 = &C::type_register_class(ctx, v2936);
                                    if let Some(v2938) = v2937 {
                                        if let &RegisterClass::Gpr {
                                            single_register: v2944,
                                        } = v2938 {
                                            let v2956 = constructor_output_value(ctx, v2331);
                                            let v2957 = Some(v2956);
                                            // Rule at src/isa/x64/lower.isle line 4288.
                                            return v2957;
                                        }
                                    }
                                }
                                &RegisterClass::Xmm => {
                                    let v2936 = C::value_type(ctx, v2331);
                                    let v2937 = &C::type_register_class(ctx, v2936);
                                    if let Some(v2938) = v2937 {
                                        if let &RegisterClass::Xmm = v2938 {
                                            let v2956 = constructor_output_value(ctx, v2331);
                                            let v2957 = Some(v2956);
                                            // Rule at src/isa/x64/lower.isle line 4293.
                                            return v2957;
                                        }
                                    }
                                    if v2936 == I128 {
                                        let v2952 = C::put_in_regs(ctx, v2331);
                                        let v2953 = constructor_bitcast_gprs_to_xmm(ctx, v2952);
                                        let v2954 = constructor_output_xmm(ctx, v2953);
                                        let v2955 = Some(v2954);
                                        // Rule at src/isa/x64/lower.isle line 4284.
                                        return v2955;
                                    }
                                }
                                _ => {}
                            }
                        }
                        let v2936 = C::value_type(ctx, v2331);
                        let v2937 = &C::type_register_class(ctx, v2936);
                        if let Some(v2938) = v2937 {
                            match v2938 {
                                &RegisterClass::Gpr {
                                    single_register: v2944,
                                } => {
                                    if let Some(v2025) = v2024 {
                                        if let &RegisterClass::Xmm = v2025 {
                                            let v4 = C::fits_in_64(ctx, v3);
                                            if let Some(v5) = v4 {
                                                let v2945 = constructor_put_in_gpr(ctx, v2331);
                                                let v2939 = C::ty_bits(ctx, v5);
                                                let v2946 = constructor_bitcast_gpr_to_xmm(ctx, v2939, v2945);
                                                let v2947 = constructor_output_xmm(ctx, v2946);
                                                let v2948 = Some(v2947);
                                                // Rule at src/isa/x64/lower.isle line 4278.
                                                return v2948;
                                            }
                                        }
                                    }
                                }
                                &RegisterClass::Xmm => {
                                    if v3 == I128 {
                                        let v2940 = constructor_put_in_xmm(ctx, v2331);
                                        let v2949 = constructor_bitcast_xmm_to_gprs(ctx, v2940);
                                        let v2950 = C::output(ctx, v2949);
                                        let v2951 = Some(v2950);
                                        // Rule at src/isa/x64/lower.isle line 4281.
                                        return v2951;
                                    }
                                    if let Some(v2025) = v2024 {
                                        if let &RegisterClass::Gpr {
                                            single_register: v2026,
                                        } = v2025 {
                                            let v4 = C::fits_in_64(ctx, v3);
                                            if let Some(v5) = v4 {
                                                let v2940 = constructor_put_in_xmm(ctx, v2331);
                                                let v2939 = C::ty_bits(ctx, v5);
                                                let v2941 = constructor_bitcast_xmm_to_gpr(ctx, v2939, v2940);
                                                let v2942 = constructor_output_gpr(ctx, v2941);
                                                let v2943 = Some(v2942);
                                                // Rule at src/isa/x64/lower.isle line 4275.
                                                return v2943;
                                            }
                                        }
                                    }
                                }
                                _ => {}
                            }
                        }
                    }
                }
                &Opcode::AtomicLoad => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v2333 = C::little_or_native_endian(ctx, v2332);
                        if let Some(v2334) = v2333 {
                            let v3 = C::value_type(ctx, v2);
                            match v3 {
                                I64 => {
                                    let v70 = C::zero_offset(ctx);
                                    let v2335 = &constructor_to_amode(ctx, v2334, v2331, v70);
                                    let v2336 = constructor_x64_mov(ctx, v2335);
                                    let v2337 = constructor_output_reg(ctx, v2336);
                                    let v2338 = Some(v2337);
                                    // Rule at src/isa/x64/lower.isle line 3430.
                                    return v2338;
                                }
                                I128 => {
                                    let v2347 = C::has_cmpxchg16b(ctx);
                                    if v2347 == true {
                                        let v2348 = constructor_imm(ctx, I64, 0x0_u64);
                                        let v16 = constructor_imm(ctx, I64, 0x0_u64);
                                        let v2349 = C::value_regs(ctx, v2348, v16);
                                        let v2350 = constructor_imm(ctx, I64, 0x0_u64);
                                        let v586 = constructor_imm(ctx, I64, 0x0_u64);
                                        let v2351 = C::value_regs(ctx, v2350, v586);
                                        let v2352 = C::zero_offset(ctx);
                                        let v2353 = &constructor_to_amode(ctx, v2334, v2331, v2352);
                                        let v2354 = constructor_x64_cmpxchg16b(ctx, v2349, v2351, v2353);
                                        let v2355 = C::output(ctx, v2354);
                                        let v2356 = Some(v2355);
                                        // Rule at src/isa/x64/lower.isle line 3435.
                                        return v2356;
                                    }
                                }
                                _ => {}
                            }
                            let v1737 = C::fits_in_32(ctx, v3);
                            if let Some(v1738) = v1737 {
                                let v2339 = C::ty_int(ctx, v3);
                                if let Some(v2340) = v2339 {
                                    let v2033 = C::ty_bits_u16(ctx, v1738);
                                    let v2035 = &C::ext_mode(ctx, v2033, 0x40_u16);
                                    let v2341 = C::zero_offset(ctx);
                                    let v2342 = &constructor_to_amode(ctx, v2334, v2331, v2341);
                                    let v2343 = &constructor_synthetic_amode_to_gpr_mem(ctx, v2342);
                                    let v2344 = constructor_x64_movzx(ctx, v2035, v2343);
                                    let v2345 = constructor_output_gpr(ctx, v2344);
                                    let v2346 = Some(v2345);
                                    // Rule at src/isa/x64/lower.isle line 3432.
                                    return v2346;
                                }
                            }
                        }
                    }
                }
                _ => {}
            }
        }
        &InstructionData::MultiAry {
            opcode: ref v1254,
            args: v1255,
        } => {
            if let &Opcode::Return = v1254 {
                let v1256 = C::value_list_slice(ctx, v1255);
                let v1257 = constructor_lower_return(ctx, v1256);
                let v1258 = Some(v1257);
                // Rule at src/isa/x64/lower.isle line 1943.
                return v1258;
            }
        }
        &InstructionData::NullAry {
            opcode: ref v1756,
        } => {
            match v1756 {
                &Opcode::Debugtrap => {
                    let v1757 = &constructor_x64_int3_zo(ctx);
                    let v1758 = constructor_side_effect(ctx, v1757);
                    let v1759 = Some(v1758);
                    // Rule at src/isa/x64/lower.isle line 2662.
                    return v1759;
                }
                &Opcode::GetPinnedReg => {
                    let v3085 = constructor_read_pinned_gpr(ctx);
                    let v3086 = constructor_output_gpr(ctx, v3085);
                    let v3087 = Some(v3086);
                    // Rule at src/isa/x64/lower.isle line 4540.
                    return v3087;
                }
                &Opcode::GetFramePointer => {
                    let v2531 = constructor_x64_rbp(ctx);
                    let v2532 = constructor_output_reg(ctx, v2531);
                    let v2533 = Some(v2532);
                    // Rule at src/isa/x64/lower.isle line 3619.
                    return v2533;
                }
                &Opcode::GetStackPointer => {
                    let v2534 = constructor_x64_rsp(ctx);
                    let v2535 = constructor_output_reg(ctx, v2534);
                    let v2536 = Some(v2535);
                    // Rule at src/isa/x64/lower.isle line 3622.
                    return v2536;
                }
                &Opcode::GetReturnAddress => {
                    let v2531 = constructor_x64_rbp(ctx);
                    let v69 = C::mem_flags_trusted(ctx);
                    let v2537 = Amode::ImmReg {
                        simm32: 8_i32,
                        base: v2531,
                        flags: v69,
                    };
                    let v2538 = &C::amode_to_synthetic_amode(ctx, &v2537);
                    let v2539 = constructor_x64_load(ctx, I64, v2538, &ExtKind::None);
                    let v2540 = constructor_output_reg(ctx, v2539);
                    let v2541 = Some(v2540);
                    // Rule at src/isa/x64/lower.isle line 3625.
                    return v2541;
                }
                &Opcode::Nop => {
                    let v3504 = C::invalid_reg(ctx);
                    let v3505 = constructor_output_reg(ctx, v3504);
                    let v3506 = Some(v3505);
                    // Rule at src/isa/x64/lower.isle line 5104.
                    return v3506;
                }
                &Opcode::Fence => {
                    let v2306 = &constructor_x64_mfence_zo(ctx);
                    let v2307 = constructor_side_effect(ctx, v2306);
                    let v2308 = Some(v2307);
                    // Rule at src/isa/x64/lower.isle line 3409.
                    return v2308;
                }
                &Opcode::SequencePoint => {
                    let v3507 = &constructor_x64_sequence_point(ctx);
                    let v3508 = constructor_side_effect(ctx, v3507);
                    let v3509 = Some(v3508);
                    // Rule at src/isa/x64/lower.isle line 5109.
                    return v3509;
                }
                _ => {}
            }
        }
        &InstructionData::Shuffle {
            opcode: ref v3100,
            args: ref v3101,
            imm: v3102,
        } => {
            if let &Opcode::Shuffle = v3100 {
                let v678 = C::has_sse41(ctx);
                if v678 == true {
                    let v3106 = C::pblendw_imm(ctx, v3102);
                    if let Some(v3107) = v3106 {
                        let v3103 = C::unpack_value_array_2(ctx, v3101);
                        let v3108 = constructor_put_in_xmm(ctx, v3103.0);
                        let v3109 = &C::put_in_xmm_mem(ctx, v3103.1);
                        let v3110 = constructor_x64_pblendw(ctx, v3108, v3109, v3107);
                        let v3111 = constructor_output_xmm(ctx, v3110);
                        let v3112 = Some(v3111);
                        // Rule at src/isa/x64/lower.isle line 4564.
                        return v3112;
                    }
                }
                let v772 = C::has_ssse3(ctx);
                if v772 == true {
                    let v3113 = C::palignr_imm_from_immediate(ctx, v3102);
                    if let Some(v3114) = v3113 {
                        let v3103 = C::unpack_value_array_2(ctx, v3101);
                        let v3115 = constructor_put_in_xmm(ctx, v3103.1);
                        let v3116 = &C::put_in_xmm_mem(ctx, v3103.0);
                        let v3117 = constructor_x64_palignr(ctx, v3115, v3116, v3114);
                        let v3118 = constructor_output_xmm(ctx, v3117);
                        let v3119 = Some(v3118);
                        // Rule at src/isa/x64/lower.isle line 4575.
                        return v3119;
                    }
                }
                let v3120 = C::pshuflw_lhs_imm(ctx, v3102);
                if let Some(v3121) = v3120 {
                    let v3103 = C::unpack_value_array_2(ctx, v3101);
                    let v3122 = &C::put_in_xmm_mem(ctx, v3103.0);
                    let v3123 = constructor_x64_pshuflw(ctx, v3122, v3121);
                    let v3124 = constructor_output_xmm(ctx, v3123);
                    let v3125 = Some(v3124);
                    // Rule at src/isa/x64/lower.isle line 4587.
                    return v3125;
                }
                let v3126 = C::pshuflw_rhs_imm(ctx, v3102);
                if let Some(v3127) = v3126 {
                    let v3103 = C::unpack_value_array_2(ctx, v3101);
                    let v3128 = &C::put_in_xmm_mem(ctx, v3103.1);
                    let v3129 = constructor_x64_pshuflw(ctx, v3128, v3127);
                    let v3130 = constructor_output_xmm(ctx, v3129);
                    let v3131 = Some(v3130);
                    // Rule at src/isa/x64/lower.isle line 4589.
                    return v3131;
                }
                let v3132 = C::pshufhw_lhs_imm(ctx, v3102);
                if let Some(v3133) = v3132 {
                    let v3103 = C::unpack_value_array_2(ctx, v3101);
                    let v3122 = &C::put_in_xmm_mem(ctx, v3103.0);
                    let v3134 = constructor_x64_pshufhw(ctx, v3122, v3133);
                    let v3135 = constructor_output_xmm(ctx, v3134);
                    let v3136 = Some(v3135);
                    // Rule at src/isa/x64/lower.isle line 4591.
                    return v3136;
                }
                let v3137 = C::pshufhw_rhs_imm(ctx, v3102);
                if let Some(v3138) = v3137 {
                    let v3103 = C::unpack_value_array_2(ctx, v3101);
                    let v3128 = &C::put_in_xmm_mem(ctx, v3103.1);
                    let v3139 = constructor_x64_pshufhw(ctx, v3128, v3138);
                    let v3140 = constructor_output_xmm(ctx, v3139);
                    let v3141 = Some(v3140);
                    // Rule at src/isa/x64/lower.isle line 4593.
                    return v3141;
                }
                let v3142 = C::pshufd_lhs_imm(ctx, v3102);
                if let Some(v3143) = v3142 {
                    let v3103 = C::unpack_value_array_2(ctx, v3101);
                    let v3122 = &C::put_in_xmm_mem(ctx, v3103.0);
                    let v3144 = constructor_x64_pshufd(ctx, v3122, v3143);
                    let v3145 = constructor_output_xmm(ctx, v3144);
                    let v3146 = Some(v3145);
                    // Rule at src/isa/x64/lower.isle line 4610.
                    return v3146;
                }
                let v3147 = C::pshufd_rhs_imm(ctx, v3102);
                if let Some(v3148) = v3147 {
                    let v3103 = C::unpack_value_array_2(ctx, v3101);
                    let v3128 = &C::put_in_xmm_mem(ctx, v3103.1);
                    let v3149 = constructor_x64_pshufd(ctx, v3128, v3148);
                    let v3150 = constructor_output_xmm(ctx, v3149);
                    let v3151 = Some(v3150);
                    // Rule at src/isa/x64/lower.isle line 4612.
                    return v3151;
                }
                let v3152 = C::u128_from_immediate(ctx, v3102);
                if let Some(v3153) = v3152 {
                    match v3153 {
                        0x0_u128 => {
                            if v772 == true {
                                let v3103 = C::unpack_value_array_2(ctx, v3101);
                                let v3108 = constructor_put_in_xmm(ctx, v3103.0);
                                let v778 = constructor_xmm_zero(ctx, I8X16);
                                let v2884 = &C::xmm_to_xmm_mem(ctx, v778);
                                let v3178 = constructor_x64_pshufb(ctx, v3108, v2884);
                                let v3179 = constructor_output_xmm(ctx, v3178);
                                let v3180 = Some(v3179);
                                // Rule at src/isa/x64/lower.isle line 4649.
                                return v3180;
                            }
                        }
                        0x17071606150514041303120211011000_u128 => {
                            let v3103 = C::unpack_value_array_2(ctx, v3101);
                            let v3108 = constructor_put_in_xmm(ctx, v3103.0);
                            let v3109 = &C::put_in_xmm_mem(ctx, v3103.1);
                            let v3157 = constructor_x64_punpcklbw(ctx, v3108, v3109);
                            let v3158 = constructor_output_xmm(ctx, v3157);
                            let v3159 = Some(v3158);
                            // Rule at src/isa/x64/lower.isle line 4623.
                            return v3159;
                        }
                        0x17160706151405041312030211100100_u128 => {
                            let v3103 = C::unpack_value_array_2(ctx, v3101);
                            let v3108 = constructor_put_in_xmm(ctx, v3103.0);
                            let v3109 = &C::put_in_xmm_mem(ctx, v3103.1);
                            let v3163 = constructor_x64_punpcklwd(ctx, v3108, v3109);
                            let v3164 = constructor_output_xmm(ctx, v3163);
                            let v3165 = Some(v3164);
                            // Rule at src/isa/x64/lower.isle line 4629.
                            return v3165;
                        }
                        0x17161514070605041312111003020100_u128 => {
                            let v3103 = C::unpack_value_array_2(ctx, v3101);
                            let v3108 = constructor_put_in_xmm(ctx, v3103.0);
                            let v3109 = &C::put_in_xmm_mem(ctx, v3103.1);
                            let v3169 = constructor_x64_punpckldq(ctx, v3108, v3109);
                            let v3170 = constructor_output_xmm(ctx, v3169);
                            let v3171 = Some(v3170);
                            // Rule at src/isa/x64/lower.isle line 4635.
                            return v3171;
                        }
                        0x17161514131211100706050403020100_u128 => {
                            let v3103 = C::unpack_value_array_2(ctx, v3101);
                            let v3108 = constructor_put_in_xmm(ctx, v3103.0);
                            let v3109 = &C::put_in_xmm_mem(ctx, v3103.1);
                            let v3175 = constructor_x64_punpcklqdq(ctx, v3108, v3109);
                            let v3176 = constructor_output_xmm(ctx, v3175);
                            let v3177 = Some(v3176);
                            // Rule at src/isa/x64/lower.isle line 4641.
                            return v3177;
                        }
                        0x1f0f1e0e1d0d1c0c1b0b1a0a19091808_u128 => {
                            let v3103 = C::unpack_value_array_2(ctx, v3101);
                            let v3108 = constructor_put_in_xmm(ctx, v3103.0);
                            let v3109 = &C::put_in_xmm_mem(ctx, v3103.1);
                            let v3154 = constructor_x64_punpckhbw(ctx, v3108, v3109);
                            let v3155 = constructor_output_xmm(ctx, v3154);
                            let v3156 = Some(v3155);
                            // Rule at src/isa/x64/lower.isle line 4621.
                            return v3156;
                        }
                        0x1f1e0f0e1d1c0d0c1b1a0b0a19180908_u128 => {
                            let v3103 = C::unpack_value_array_2(ctx, v3101);
                            let v3108 = constructor_put_in_xmm(ctx, v3103.0);
                            let v3109 = &C::put_in_xmm_mem(ctx, v3103.1);
                            let v3160 = constructor_x64_punpckhwd(ctx, v3108, v3109);
                            let v3161 = constructor_output_xmm(ctx, v3160);
                            let v3162 = Some(v3161);
                            // Rule at src/isa/x64/lower.isle line 4627.
                            return v3162;
                        }
                        0x1f1e1d1c0f0e0d0c1b1a19180b0a0908_u128 => {
                            let v3103 = C::unpack_value_array_2(ctx, v3101);
                            let v3108 = constructor_put_in_xmm(ctx, v3103.0);
                            let v3109 = &C::put_in_xmm_mem(ctx, v3103.1);
                            let v3166 = constructor_x64_punpckhdq(ctx, v3108, v3109);
                            let v3167 = constructor_output_xmm(ctx, v3166);
                            let v3168 = Some(v3167);
                            // Rule at src/isa/x64/lower.isle line 4633.
                            return v3168;
                        }
                        0x1f1e1d1c1b1a19180f0e0d0c0b0a0908_u128 => {
                            let v3103 = C::unpack_value_array_2(ctx, v3101);
                            let v3108 = constructor_put_in_xmm(ctx, v3103.0);
                            let v3109 = &C::put_in_xmm_mem(ctx, v3103.1);
                            let v3172 = constructor_x64_punpckhqdq(ctx, v3108, v3109);
                            let v3173 = constructor_output_xmm(ctx, v3172);
                            let v3174 = Some(v3173);
                            // Rule at src/isa/x64/lower.isle line 4639.
                            return v3174;
                        }
                        _ => {}
                    }
                }
                let v3181 = C::shufps_imm(ctx, v3102);
                if let Some(v3182) = v3181 {
                    let v3103 = C::unpack_value_array_2(ctx, v3101);
                    let v3108 = constructor_put_in_xmm(ctx, v3103.0);
                    let v3109 = &C::put_in_xmm_mem(ctx, v3103.1);
                    let v3183 = constructor_x64_shufps(ctx, v3108, v3109, v3182);
                    let v3184 = constructor_output_xmm(ctx, v3183);
                    let v3185 = Some(v3184);
                    // Rule at src/isa/x64/lower.isle line 4663.
                    return v3185;
                }
                let v3186 = C::shufps_rev_imm(ctx, v3102);
                if let Some(v3187) = v3186 {
                    let v3103 = C::unpack_value_array_2(ctx, v3101);
                    let v3115 = constructor_put_in_xmm(ctx, v3103.1);
                    let v3116 = &C::put_in_xmm_mem(ctx, v3103.0);
                    let v3188 = constructor_x64_shufps(ctx, v3115, v3116, v3187);
                    let v3189 = constructor_output_xmm(ctx, v3188);
                    let v3190 = Some(v3189);
                    // Rule at src/isa/x64/lower.isle line 4665.
                    return v3190;
                }
                let v3191 = &C::vec_mask_from_immediate(ctx, v3102);
                if let Some(v3192) = v3191 {
                    if v772 == true {
                        let v3103 = C::unpack_value_array_2(ctx, v3101);
                        if v3103.0 == v3103.1 {
                            let v3108 = constructor_put_in_xmm(ctx, v3103.0);
                            let v3193 = C::shuffle_0_31_mask(ctx, v3192);
                            let v3194 = &constructor_const_to_xmm_mem(ctx, v3193);
                            let v3195 = constructor_x64_pshufb(ctx, v3108, v3194);
                            let v3196 = constructor_output_xmm(ctx, v3195);
                            let v3197 = Some(v3196);
                            // Rule at src/isa/x64/lower.isle line 4678.
                            return v3197;
                        }
                    }
                    let v520 = C::has_avx512vl(ctx);
                    if v520 == true {
                        let v3202 = C::has_avx512vbmi(ctx);
                        if v3202 == true {
                            let v3198 = C::perm_from_mask_with_zeros(ctx, v3192);
                            if let Some(v3199) = v3198 {
                                let v3203 = constructor_x64_xmm_load_const(ctx, I8X16, v3199.0);
                                let v3103 = C::unpack_value_array_2(ctx, v3101);
                                let v3204 = constructor_put_in_xmm(ctx, v3103.0);
                                let v3205 = &C::put_in_xmm_mem(ctx, v3103.1);
                                let v3206 = constructor_x64_vpermi2b(ctx, v3203, v3204, v3205);
                                let v3207 = &constructor_const_to_xmm_mem(ctx, v3199.1);
                                let v3208 = constructor_x64_andps(ctx, v3206, v3207);
                                let v3209 = constructor_output_xmm(ctx, v3208);
                                let v3210 = Some(v3209);
                                // Rule at src/isa/x64/lower.isle line 4685.
                                return v3210;
                            }
                            let v3211 = C::perm_from_mask(ctx, v3192);
                            let v3212 = constructor_x64_xmm_load_const(ctx, I8X16, v3211);
                            let v3103 = C::unpack_value_array_2(ctx, v3101);
                            let v3213 = constructor_put_in_xmm(ctx, v3103.0);
                            let v3214 = &C::put_in_xmm_mem(ctx, v3103.1);
                            let v3215 = constructor_x64_vpermi2b(ctx, v3212, v3213, v3214);
                            let v3216 = constructor_output_xmm(ctx, v3215);
                            let v3217 = Some(v3216);
                            // Rule at src/isa/x64/lower.isle line 4692.
                            return v3217;
                        }
                    }
                    let v3103 = C::unpack_value_array_2(ctx, v3101);
                    let v3108 = constructor_put_in_xmm(ctx, v3103.0);
                    let v3218 = C::shuffle_0_15_mask(ctx, v3192);
                    let v3219 = &constructor_const_to_reg_mem(ctx, v3218);
                    let v3220 = constructor_lower_pshufb(ctx, v3108, v3219);
                    let v3221 = constructor_put_in_xmm(ctx, v3103.1);
                    let v3222 = C::shuffle_16_31_mask(ctx, v3192);
                    let v3223 = &constructor_const_to_reg_mem(ctx, v3222);
                    let v3224 = constructor_lower_pshufb(ctx, v3221, v3223);
                    let v3225 = &C::xmm_to_xmm_mem(ctx, v3224);
                    let v3226 = constructor_x64_por(ctx, v3220, v3225);
                    let v3227 = constructor_output_xmm(ctx, v3226);
                    let v3228 = Some(v3227);
                    // Rule at src/isa/x64/lower.isle line 4700.
                    return v3228;
                }
            }
        }
        &InstructionData::StackLoad {
            opcode: ref v2995,
            stack_slot: v2996,
            offset: v2997,
        } => {
            if let &Opcode::StackAddr = v2995 {
                let v2998 = constructor_stack_addr_impl(ctx, v2996, v2997);
                let v2999 = constructor_output_gpr(ctx, v2998);
                let v3000 = Some(v2999);
                // Rule at src/isa/x64/lower.isle line 4391.
                return v3000;
            }
        }
        &InstructionData::Store {
            opcode: ref v2141,
            args: ref v2142,
            flags: v2143,
            offset: v2144,
        } => {
            match v2141 {
                &Opcode::Store => {
                    let v2152 = C::little_or_native_endian(ctx, v2143);
                    if let Some(v2153) = v2152 {
                        let v2145 = C::unpack_value_array_2(ctx, v2142);
                        let v2148 = C::value_type(ctx, v2145.0);
                        let v2170 = C::fits_in_64(ctx, v2148);
                        if let Some(v2171) = v2170 {
                            let v2172 = C::i64_from_iconst(ctx, v2145.0);
                            if let Some(v2173) = v2172 {
                                let v2174 = C::i64_from_i32(ctx, v2173);
                                if let Some(v2175) = v2174 {
                                    let v2154 = &constructor_to_amode(ctx, v2153, v2145.1, v2144);
                                    let v2176 = &constructor_x64_movimm_m(ctx, v2171, v2154, v2175);
                                    let v2177 = constructor_side_effect(ctx, v2176);
                                    let v2178 = Some(v2177);
                                    // Rule at src/isa/x64/lower.isle line 3157.
                                    return v2178;
                                }
                            }
                        }
                        let v2221 = C::def_inst(ctx, v2145.0);
                        if let Some(v2222) = v2221 {
                            let v2223 = C::first_result(ctx, v2222);
                            if let Some(v2224) = v2223 {
                                let v2226 = &C::inst_data_value(ctx, v2222);
                                match v2226 {
                                    &InstructionData::Binary {
                                        opcode: ref v2252,
                                        args: ref v2253,
                                    } => {
                                        match v2252 {
                                            &Opcode::Iadd => {
                                                let v2225 = C::value_type(ctx, v2224);
                                                let v2250 = C::ty_32_or_64(ctx, v2225);
                                                if let Some(v2251) = v2250 {
                                                    let v2254 = C::unpack_value_array_2(ctx, v2253);
                                                    let v2257 = &C::sinkable_load(ctx, v2254.0);
                                                    if let Some(v2258) = v2257 {
                                                        let v2259 = C::def_inst(ctx, v2254.0);
                                                        if let Some(v2260) = v2259 {
                                                            let v2261 = &C::inst_data_value(ctx, v2260);
                                                            if let &InstructionData::Load {
                                                                opcode: ref v2262,
                                                                arg: v2263,
                                                                flags: v2264,
                                                                offset: v2265,
                                                            } = v2261 {
                                                                if let &Opcode::Load = v2262 {
                                                                    if v2144 == v2265 {
                                                                        if v2153 == v2264 {
                                                                            if v2145.1 == v2263 {
                                                                                let v2266 = &constructor_sink_load_to_reg_mem_imm(ctx, v2258);
                                                                                let v2267 = &constructor_to_amode(ctx, v2264, v2263, v2265);
                                                                                let v2268 = &constructor_x64_add_mem(ctx, v2251, v2267, v2254.1);
                                                                                let v2269 = constructor_side_effect(ctx, v2268);
                                                                                let v2270 = Some(v2269);
                                                                                // Rule at src/isa/x64/lower.isle line 3282.
                                                                                return v2270;
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                    let v2271 = &C::sinkable_load(ctx, v2254.1);
                                                    if let Some(v2272) = v2271 {
                                                        let v2273 = C::def_inst(ctx, v2254.1);
                                                        if let Some(v2274) = v2273 {
                                                            let v2275 = &C::inst_data_value(ctx, v2274);
                                                            if let &InstructionData::Load {
                                                                opcode: ref v2276,
                                                                arg: v2277,
                                                                flags: v2278,
                                                                offset: v2279,
                                                            } = v2275 {
                                                                if let &Opcode::Load = v2276 {
                                                                    if v2144 == v2279 {
                                                                        if v2153 == v2278 {
                                                                            if v2145.1 == v2277 {
                                                                                let v2280 = &constructor_sink_load_to_reg_mem_imm(ctx, v2272);
                                                                                let v2281 = &constructor_to_amode(ctx, v2278, v2277, v2279);
                                                                                let v2282 = &constructor_x64_add_mem(ctx, v2251, v2281, v2254.0);
                                                                                let v2283 = constructor_side_effect(ctx, v2282);
                                                                                let v2284 = Some(v2283);
                                                                                // Rule at src/isa/x64/lower.isle line 3296.
                                                                                return v2284;
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                            &Opcode::Isub => {
                                                let v2225 = C::value_type(ctx, v2224);
                                                let v2250 = C::ty_32_or_64(ctx, v2225);
                                                if let Some(v2251) = v2250 {
                                                    let v2254 = C::unpack_value_array_2(ctx, v2253);
                                                    let v2257 = &C::sinkable_load(ctx, v2254.0);
                                                    if let Some(v2258) = v2257 {
                                                        let v2259 = C::def_inst(ctx, v2254.0);
                                                        if let Some(v2260) = v2259 {
                                                            let v2261 = &C::inst_data_value(ctx, v2260);
                                                            if let &InstructionData::Load {
                                                                opcode: ref v2262,
                                                                arg: v2263,
                                                                flags: v2264,
                                                                offset: v2265,
                                                            } = v2261 {
                                                                if let &Opcode::Load = v2262 {
                                                                    if v2144 == v2265 {
                                                                        if v2153 == v2264 {
                                                                            if v2145.1 == v2263 {
                                                                                let v2266 = &constructor_sink_load_to_reg_mem_imm(ctx, v2258);
                                                                                let v2267 = &constructor_to_amode(ctx, v2264, v2263, v2265);
                                                                                let v2285 = &constructor_x64_sub_mem(ctx, v2251, v2267, v2254.1);
                                                                                let v2286 = constructor_side_effect(ctx, v2285);
                                                                                let v2287 = Some(v2286);
                                                                                // Rule at src/isa/x64/lower.isle line 3310.
                                                                                return v2287;
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                            &Opcode::Band => {
                                                let v2225 = C::value_type(ctx, v2224);
                                                let v2250 = C::ty_32_or_64(ctx, v2225);
                                                if let Some(v2251) = v2250 {
                                                    let v2254 = C::unpack_value_array_2(ctx, v2253);
                                                    let v2257 = &C::sinkable_load(ctx, v2254.0);
                                                    if let Some(v2258) = v2257 {
                                                        let v2259 = C::def_inst(ctx, v2254.0);
                                                        if let Some(v2260) = v2259 {
                                                            let v2261 = &C::inst_data_value(ctx, v2260);
                                                            if let &InstructionData::Load {
                                                                opcode: ref v2262,
                                                                arg: v2263,
                                                                flags: v2264,
                                                                offset: v2265,
                                                            } = v2261 {
                                                                if let &Opcode::Load = v2262 {
                                                                    if v2144 == v2265 {
                                                                        if v2153 == v2264 {
                                                                            if v2145.1 == v2263 {
                                                                                let v2266 = &constructor_sink_load_to_reg_mem_imm(ctx, v2258);
                                                                                let v2267 = &constructor_to_amode(ctx, v2264, v2263, v2265);
                                                                                let v2288 = &constructor_x64_and_mem(ctx, v2251, v2267, v2254.1);
                                                                                let v2289 = constructor_side_effect(ctx, v2288);
                                                                                let v2290 = Some(v2289);
                                                                                // Rule at src/isa/x64/lower.isle line 3324.
                                                                                return v2290;
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                    let v2271 = &C::sinkable_load(ctx, v2254.1);
                                                    if let Some(v2272) = v2271 {
                                                        let v2273 = C::def_inst(ctx, v2254.1);
                                                        if let Some(v2274) = v2273 {
                                                            let v2275 = &C::inst_data_value(ctx, v2274);
                                                            if let &InstructionData::Load {
                                                                opcode: ref v2276,
                                                                arg: v2277,
                                                                flags: v2278,
                                                                offset: v2279,
                                                            } = v2275 {
                                                                if let &Opcode::Load = v2276 {
                                                                    if v2144 == v2279 {
                                                                        if v2153 == v2278 {
                                                                            if v2145.1 == v2277 {
                                                                                let v2280 = &constructor_sink_load_to_reg_mem_imm(ctx, v2272);
                                                                                let v2281 = &constructor_to_amode(ctx, v2278, v2277, v2279);
                                                                                let v2291 = &constructor_x64_and_mem(ctx, v2251, v2281, v2254.0);
                                                                                let v2292 = constructor_side_effect(ctx, v2291);
                                                                                let v2293 = Some(v2292);
                                                                                // Rule at src/isa/x64/lower.isle line 3338.
                                                                                return v2293;
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                            &Opcode::Bor => {
                                                let v2225 = C::value_type(ctx, v2224);
                                                let v2250 = C::ty_32_or_64(ctx, v2225);
                                                if let Some(v2251) = v2250 {
                                                    let v2254 = C::unpack_value_array_2(ctx, v2253);
                                                    let v2257 = &C::sinkable_load(ctx, v2254.0);
                                                    if let Some(v2258) = v2257 {
                                                        let v2259 = C::def_inst(ctx, v2254.0);
                                                        if let Some(v2260) = v2259 {
                                                            let v2261 = &C::inst_data_value(ctx, v2260);
                                                            if let &InstructionData::Load {
                                                                opcode: ref v2262,
                                                                arg: v2263,
                                                                flags: v2264,
                                                                offset: v2265,
                                                            } = v2261 {
                                                                if let &Opcode::Load = v2262 {
                                                                    if v2144 == v2265 {
                                                                        if v2153 == v2264 {
                                                                            if v2145.1 == v2263 {
                                                                                let v2266 = &constructor_sink_load_to_reg_mem_imm(ctx, v2258);
                                                                                let v2267 = &constructor_to_amode(ctx, v2264, v2263, v2265);
                                                                                let v2294 = &constructor_x64_or_mem(ctx, v2251, v2267, v2254.1);
                                                                                let v2295 = constructor_side_effect(ctx, v2294);
                                                                                let v2296 = Some(v2295);
                                                                                // Rule at src/isa/x64/lower.isle line 3352.
                                                                                return v2296;
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                    let v2271 = &C::sinkable_load(ctx, v2254.1);
                                                    if let Some(v2272) = v2271 {
                                                        let v2273 = C::def_inst(ctx, v2254.1);
                                                        if let Some(v2274) = v2273 {
                                                            let v2275 = &C::inst_data_value(ctx, v2274);
                                                            if let &InstructionData::Load {
                                                                opcode: ref v2276,
                                                                arg: v2277,
                                                                flags: v2278,
                                                                offset: v2279,
                                                            } = v2275 {
                                                                if let &Opcode::Load = v2276 {
                                                                    if v2144 == v2279 {
                                                                        if v2153 == v2278 {
                                                                            if v2145.1 == v2277 {
                                                                                let v2280 = &constructor_sink_load_to_reg_mem_imm(ctx, v2272);
                                                                                let v2281 = &constructor_to_amode(ctx, v2278, v2277, v2279);
                                                                                let v2297 = &constructor_x64_or_mem(ctx, v2251, v2281, v2254.0);
                                                                                let v2298 = constructor_side_effect(ctx, v2297);
                                                                                let v2299 = Some(v2298);
                                                                                // Rule at src/isa/x64/lower.isle line 3366.
                                                                                return v2299;
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                            &Opcode::Bxor => {
                                                let v2225 = C::value_type(ctx, v2224);
                                                let v2250 = C::ty_32_or_64(ctx, v2225);
                                                if let Some(v2251) = v2250 {
                                                    let v2254 = C::unpack_value_array_2(ctx, v2253);
                                                    let v2257 = &C::sinkable_load(ctx, v2254.0);
                                                    if let Some(v2258) = v2257 {
                                                        let v2259 = C::def_inst(ctx, v2254.0);
                                                        if let Some(v2260) = v2259 {
                                                            let v2261 = &C::inst_data_value(ctx, v2260);
                                                            if let &InstructionData::Load {
                                                                opcode: ref v2262,
                                                                arg: v2263,
                                                                flags: v2264,
                                                                offset: v2265,
                                                            } = v2261 {
                                                                if let &Opcode::Load = v2262 {
                                                                    if v2144 == v2265 {
                                                                        if v2153 == v2264 {
                                                                            if v2145.1 == v2263 {
                                                                                let v2266 = &constructor_sink_load_to_reg_mem_imm(ctx, v2258);
                                                                                let v2267 = &constructor_to_amode(ctx, v2264, v2263, v2265);
                                                                                let v2300 = &constructor_x64_xor_mem(ctx, v2251, v2267, v2254.1);
                                                                                let v2301 = constructor_side_effect(ctx, v2300);
                                                                                let v2302 = Some(v2301);
                                                                                // Rule at src/isa/x64/lower.isle line 3380.
                                                                                return v2302;
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                    let v2271 = &C::sinkable_load(ctx, v2254.1);
                                                    if let Some(v2272) = v2271 {
                                                        let v2273 = C::def_inst(ctx, v2254.1);
                                                        if let Some(v2274) = v2273 {
                                                            let v2275 = &C::inst_data_value(ctx, v2274);
                                                            if let &InstructionData::Load {
                                                                opcode: ref v2276,
                                                                arg: v2277,
                                                                flags: v2278,
                                                                offset: v2279,
                                                            } = v2275 {
                                                                if let &Opcode::Load = v2276 {
                                                                    if v2144 == v2279 {
                                                                        if v2153 == v2278 {
                                                                            if v2145.1 == v2277 {
                                                                                let v2280 = &constructor_sink_load_to_reg_mem_imm(ctx, v2272);
                                                                                let v2281 = &constructor_to_amode(ctx, v2278, v2277, v2279);
                                                                                let v2303 = &constructor_x64_xor_mem(ctx, v2251, v2281, v2254.0);
                                                                                let v2304 = constructor_side_effect(ctx, v2303);
                                                                                let v2305 = Some(v2304);
                                                                                // Rule at src/isa/x64/lower.isle line 3394.
                                                                                return v2305;
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                            _ => {}
                                        }
                                    }
                                    &InstructionData::BinaryImm8 {
                                        opcode: ref v2227,
                                        arg: v2228,
                                        imm: v2229,
                                    } => {
                                        if let &Opcode::Extractlane = v2227 {
                                            let v2225 = C::value_type(ctx, v2224);
                                            match v2225 {
                                                I8 => {
                                                    let v678 = C::has_sse41(ctx);
                                                    if v678 == true {
                                                        let v2154 = &constructor_to_amode(ctx, v2153, v2145.1, v2144);
                                                        let v2231 = constructor_put_in_xmm(ctx, v2228);
                                                        let v2230 = C::u8_from_uimm8(ctx, v2229);
                                                        let v2238 = &constructor_x64_pextrb_store(ctx, v2154, v2231, v2230);
                                                        let v2239 = constructor_side_effect(ctx, v2238);
                                                        let v2240 = Some(v2239);
                                                        // Rule at src/isa/x64/lower.isle line 3250.
                                                        return v2240;
                                                    }
                                                }
                                                I16 => {
                                                    let v678 = C::has_sse41(ctx);
                                                    if v678 == true {
                                                        let v2154 = &constructor_to_amode(ctx, v2153, v2145.1, v2144);
                                                        let v2231 = constructor_put_in_xmm(ctx, v2228);
                                                        let v2230 = C::u8_from_uimm8(ctx, v2229);
                                                        let v2241 = &constructor_x64_pextrw_store(ctx, v2154, v2231, v2230);
                                                        let v2242 = constructor_side_effect(ctx, v2241);
                                                        let v2243 = Some(v2242);
                                                        // Rule at src/isa/x64/lower.isle line 3257.
                                                        return v2243;
                                                    }
                                                }
                                                I32 => {
                                                    let v678 = C::has_sse41(ctx);
                                                    if v678 == true {
                                                        let v2154 = &constructor_to_amode(ctx, v2153, v2145.1, v2144);
                                                        let v2231 = constructor_put_in_xmm(ctx, v2228);
                                                        let v2230 = C::u8_from_uimm8(ctx, v2229);
                                                        let v2244 = &constructor_x64_pextrd_store(ctx, v2154, v2231, v2230);
                                                        let v2245 = constructor_side_effect(ctx, v2244);
                                                        let v2246 = Some(v2245);
                                                        // Rule at src/isa/x64/lower.isle line 3264.
                                                        return v2246;
                                                    }
                                                }
                                                I64 => {
                                                    let v678 = C::has_sse41(ctx);
                                                    if v678 == true {
                                                        let v2154 = &constructor_to_amode(ctx, v2153, v2145.1, v2144);
                                                        let v2231 = constructor_put_in_xmm(ctx, v2228);
                                                        let v2230 = C::u8_from_uimm8(ctx, v2229);
                                                        let v2247 = &constructor_x64_pextrq_store(ctx, v2154, v2231, v2230);
                                                        let v2248 = constructor_side_effect(ctx, v2247);
                                                        let v2249 = Some(v2248);
                                                        // Rule at src/isa/x64/lower.isle line 3271.
                                                        return v2249;
                                                    }
                                                }
                                                F32 => {
                                                    let v2230 = C::u8_from_uimm8(ctx, v2229);
                                                    if v2230 == 0x0_u8 {
                                                        let v2154 = &constructor_to_amode(ctx, v2153, v2145.1, v2144);
                                                        let v2231 = constructor_put_in_xmm(ctx, v2228);
                                                        let v2232 = &constructor_x64_movss_store(ctx, v2154, v2231);
                                                        let v2233 = constructor_side_effect(ctx, v2232);
                                                        let v2234 = Some(v2233);
                                                        // Rule at src/isa/x64/lower.isle line 3238.
                                                        return v2234;
                                                    }
                                                }
                                                F64 => {
                                                    let v2230 = C::u8_from_uimm8(ctx, v2229);
                                                    if v2230 == 0x0_u8 {
                                                        let v2154 = &constructor_to_amode(ctx, v2153, v2145.1, v2144);
                                                        let v2231 = constructor_put_in_xmm(ctx, v2228);
                                                        let v2235 = &constructor_x64_movsd_store(ctx, v2154, v2231);
                                                        let v2236 = constructor_side_effect(ctx, v2235);
                                                        let v2237 = Some(v2236);
                                                        // Rule at src/isa/x64/lower.isle line 3244.
                                                        return v2237;
                                                    }
                                                }
                                                _ => {}
                                            }
                                        }
                                    }
                                    _ => {}
                                }
                            }
                        }
                        match v2148 {
                            I128 => {
                                let v2211 = C::put_in_regs(ctx, v2145.0);
                                let v2212 = constructor_value_regs_get_gpr(ctx, v2211, 0x0_usize);
                                let v2213 = constructor_value_regs_get_gpr(ctx, v2211, 0x1_usize);
                                let v2214 = &constructor_to_amode(ctx, v2153, v2145.1, v2144);
                                let v2215 = &C::amode_offset(ctx, v2214, 8_i32);
                                let v2216 = &constructor_x64_movrm(ctx, I64, v2214, v2212);
                                let v2217 = &constructor_x64_movrm(ctx, I64, v2215, v2213);
                                let v2218 = &constructor_side_effect_concat(ctx, v2216, v2217);
                                let v2219 = constructor_side_effect(ctx, v2218);
                                let v2220 = Some(v2219);
                                // Rule at src/isa/x64/lower.isle line 3219.
                                return v2220;
                            }
                            F32X4 => {
                                let v2154 = &constructor_to_amode(ctx, v2153, v2145.1, v2144);
                                let v2182 = constructor_put_in_xmm(ctx, v2145.0);
                                let v2200 = &constructor_x64_movups_store(ctx, v2154, v2182);
                                let v2201 = constructor_side_effect(ctx, v2200);
                                let v2202 = Some(v2201);
                                // Rule at src/isa/x64/lower.isle line 3195.
                                return v2202;
                            }
                            F64X2 => {
                                let v2154 = &constructor_to_amode(ctx, v2153, v2145.1, v2144);
                                let v2182 = constructor_put_in_xmm(ctx, v2145.0);
                                let v2203 = &constructor_x64_movupd_store(ctx, v2154, v2182);
                                let v2204 = constructor_side_effect(ctx, v2203);
                                let v2205 = Some(v2204);
                                // Rule at src/isa/x64/lower.isle line 3203.
                                return v2205;
                            }
                            _ => {}
                        }
                        let v2149 = &C::type_register_class(ctx, v2148);
                        if let Some(v2150) = v2149 {
                            match v2150 {
                                &RegisterClass::Gpr {
                                    single_register: v2151,
                                } => {
                                    let v2154 = &constructor_to_amode(ctx, v2153, v2145.1, v2144);
                                    let v2155 = constructor_put_in_gpr(ctx, v2145.0);
                                    let v2156 = &constructor_x64_movrm(ctx, v2148, v2154, v2155);
                                    let v2157 = constructor_side_effect(ctx, v2156);
                                    let v2158 = Some(v2157);
                                    // Rule at src/isa/x64/lower.isle line 3138.
                                    return v2158;
                                }
                                &RegisterClass::Xmm => {
                                    let v2179 = C::ty_16(ctx, v2148);
                                    if let Some(v2180) = v2179 {
                                        let v678 = C::has_sse41(ctx);
                                        if v678 == true {
                                            let v2154 = &constructor_to_amode(ctx, v2153, v2145.1, v2144);
                                            let v2182 = constructor_put_in_xmm(ctx, v2145.0);
                                            let v2187 = &constructor_x64_pextrw_store(ctx, v2154, v2182, 0x0_u8);
                                            let v2188 = constructor_side_effect(ctx, v2187);
                                            let v2189 = Some(v2188);
                                            // Rule at src/isa/x64/lower.isle line 3170.
                                            return v2189;
                                        }
                                        let v2154 = &constructor_to_amode(ctx, v2153, v2145.1, v2144);
                                        let v2182 = constructor_put_in_xmm(ctx, v2145.0);
                                        let v2183 = constructor_bitcast_xmm_to_gpr(ctx, 0x10_u8, v2182);
                                        let v2184 = &constructor_x64_movrm(ctx, I16, v2154, v2183);
                                        let v2185 = constructor_side_effect(ctx, v2184);
                                        let v2186 = Some(v2185);
                                        // Rule at src/isa/x64/lower.isle line 3163.
                                        return v2186;
                                    }
                                    let v2190 = C::ty_32(ctx, v2148);
                                    if let Some(v2191) = v2190 {
                                        let v2154 = &constructor_to_amode(ctx, v2153, v2145.1, v2144);
                                        let v2182 = constructor_put_in_xmm(ctx, v2145.0);
                                        let v2192 = &constructor_x64_movss_store(ctx, v2154, v2182);
                                        let v2193 = constructor_side_effect(ctx, v2192);
                                        let v2194 = Some(v2193);
                                        // Rule at src/isa/x64/lower.isle line 3179.
                                        return v2194;
                                    }
                                    let v2195 = C::ty_64(ctx, v2148);
                                    if let Some(v2196) = v2195 {
                                        let v2154 = &constructor_to_amode(ctx, v2153, v2145.1, v2144);
                                        let v2182 = constructor_put_in_xmm(ctx, v2145.0);
                                        let v2197 = &constructor_x64_movsd_store(ctx, v2154, v2182);
                                        let v2198 = constructor_side_effect(ctx, v2197);
                                        let v2199 = Some(v2198);
                                        // Rule at src/isa/x64/lower.isle line 3187.
                                        return v2199;
                                    }
                                    let v2206 = C::ty_128(ctx, v2148);
                                    if let Some(v2207) = v2206 {
                                        let v2154 = &constructor_to_amode(ctx, v2153, v2145.1, v2144);
                                        let v2182 = constructor_put_in_xmm(ctx, v2145.0);
                                        let v2208 = &constructor_x64_movdqu_store(ctx, v2154, v2182);
                                        let v2209 = constructor_side_effect(ctx, v2208);
                                        let v2210 = Some(v2209);
                                        // Rule at src/isa/x64/lower.isle line 3211.
                                        return v2210;
                                    }
                                }
                                _ => {}
                            }
                        }
                    }
                }
                &Opcode::Istore8 => {
                    let v2152 = C::little_or_native_endian(ctx, v2143);
                    if let Some(v2153) = v2152 {
                        let v2145 = C::unpack_value_array_2(ctx, v2142);
                        let v2154 = &constructor_to_amode(ctx, v2153, v2145.1, v2144);
                        let v2155 = constructor_put_in_gpr(ctx, v2145.0);
                        let v2160 = &constructor_x64_movrm(ctx, I8, v2154, v2155);
                        let v2161 = constructor_side_effect(ctx, v2160);
                        let v2162 = Some(v2161);
                        // Rule at src/isa/x64/lower.isle line 3146.
                        return v2162;
                    }
                }
                &Opcode::Istore16 => {
                    let v2152 = C::little_or_native_endian(ctx, v2143);
                    if let Some(v2153) = v2152 {
                        let v2145 = C::unpack_value_array_2(ctx, v2142);
                        let v2154 = &constructor_to_amode(ctx, v2153, v2145.1, v2144);
                        let v2155 = constructor_put_in_gpr(ctx, v2145.0);
                        let v2164 = &constructor_x64_movrm(ctx, I16, v2154, v2155);
                        let v2165 = constructor_side_effect(ctx, v2164);
                        let v2166 = Some(v2165);
                        // Rule at src/isa/x64/lower.isle line 3149.
                        return v2166;
                    }
                }
                &Opcode::Istore32 => {
                    let v2152 = C::little_or_native_endian(ctx, v2143);
                    if let Some(v2153) = v2152 {
                        let v2145 = C::unpack_value_array_2(ctx, v2142);
                        let v2154 = &constructor_to_amode(ctx, v2153, v2145.1, v2144);
                        let v2155 = constructor_put_in_gpr(ctx, v2145.0);
                        let v2167 = &constructor_x64_movrm(ctx, I32, v2154, v2155);
                        let v2168 = constructor_side_effect(ctx, v2167);
                        let v2169 = Some(v2168);
                        // Rule at src/isa/x64/lower.isle line 3152.
                        return v2169;
                    }
                }
                _ => {}
            }
        }
        &InstructionData::StoreNoOffset {
            opcode: ref v2357,
            args: ref v2358,
            flags: v2359,
        } => {
            if let &Opcode::AtomicStore = v2357 {
                let v2368 = C::little_or_native_endian(ctx, v2359);
                if let Some(v2369) = v2368 {
                    let v2347 = C::has_cmpxchg16b(ctx);
                    if v2347 == true {
                        let v2360 = C::unpack_value_array_2(ctx, v2358);
                        let v2363 = C::value_type(ctx, v2360.0);
                        if v2363 == I128 {
                            let v70 = C::zero_offset(ctx);
                            let v2370 = &constructor_to_amode(ctx, v2369, v2360.1, v70);
                            let v2377 = C::put_in_regs(ctx, v2360.0);
                            let v2378 = &constructor_x64_atomic_128_store_seq(ctx, v2370, v2377);
                            let v2379 = constructor_side_effect(ctx, v2378);
                            let v2380 = Some(v2379);
                            // Rule at src/isa/x64/lower.isle line 3450.
                            return v2380;
                        }
                    }
                    let v2360 = C::unpack_value_array_2(ctx, v2358);
                    let v2363 = C::value_type(ctx, v2360.0);
                    let v2364 = C::fits_in_64(ctx, v2363);
                    if let Some(v2365) = v2364 {
                        let v2366 = C::ty_int(ctx, v2363);
                        if let Some(v2367) = v2366 {
                            let v70 = C::zero_offset(ctx);
                            let v2370 = &constructor_to_amode(ctx, v2369, v2360.1, v70);
                            let v2371 = constructor_put_in_gpr(ctx, v2360.0);
                            let v2372 = &constructor_x64_movrm(ctx, v2365, v2370, v2371);
                            let v2373 = &constructor_x64_mfence_zo(ctx);
                            let v2374 = &constructor_side_effect_concat(ctx, v2372, v2373);
                            let v2375 = constructor_side_effect(ctx, v2374);
                            let v2376 = Some(v2375);
                            // Rule at src/isa/x64/lower.isle line 3443.
                            return v2376;
                        }
                    }
                }
            }
        }
        &InstructionData::Ternary {
            opcode: ref v923,
            args: ref v924,
        } => {
            match v923 {
                &Opcode::StackSwitch => {
                    let v2524 = &C::stack_switch_model(ctx);
                    if let Some(v2525) = v2524 {
                        if let &StackSwitchModel::Basic = v2525 {
                            let v925 = C::unpack_value_array_3(ctx, v924);
                            let v989 = constructor_put_in_gpr(ctx, v925.0);
                            let v2526 = constructor_put_in_gpr(ctx, v925.1);
                            let v2527 = constructor_put_in_gpr(ctx, v925.2);
                            let v2528 = constructor_x64_stack_switch_basic(ctx, v989, v2526, v2527);
                            let v2529 = constructor_output_gpr(ctx, v2528);
                            let v2530 = Some(v2529);
                            // Rule at src/isa/x64/lower.isle line 3610.
                            return v2530;
                        }
                    }
                }
                &Opcode::Select => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        match v3 {
                            F32 => {
                                let v925 = C::unpack_value_array_3(ctx, v924);
                                let v1482 = C::maybe_uextend(ctx, v925.0);
                                if let Some(v1483) = v1482 {
                                    let v1484 = C::def_inst(ctx, v1483);
                                    if let Some(v1485) = v1484 {
                                        let v1486 = &C::inst_data_value(ctx, v1485);
                                        if let &InstructionData::FloatCompare {
                                            opcode: ref v1487,
                                            args: ref v1488,
                                            cond: ref v1489,
                                        } = v1486 {
                                            if let &Opcode::Fcmp = v1487 {
                                                if let &FloatCC::LessThan = v1489 {
                                                    let v1490 = C::unpack_value_array_2(ctx, v1488);
                                                    if v925.1 == v1490.1 {
                                                        if v925.2 == v1490.0 {
                                                            let v1501 = constructor_put_in_xmm(ctx, v1490.1);
                                                            let v1502 = &C::put_in_xmm_mem(ctx, v1490.0);
                                                            let v1503 = constructor_x64_maxss(ctx, v1501, v1502);
                                                            let v1504 = constructor_output_xmm(ctx, v1503);
                                                            let v1505 = Some(v1504);
                                                            // Rule at src/isa/x64/lower.isle line 2255.
                                                            return v1505;
                                                        }
                                                    }
                                                    if v925.1 == v1490.0 {
                                                        if v925.2 == v1490.1 {
                                                            let v1493 = constructor_put_in_xmm(ctx, v1490.0);
                                                            let v1494 = &C::put_in_xmm_mem(ctx, v1490.1);
                                                            let v1495 = constructor_x64_minss(ctx, v1493, v1494);
                                                            let v1496 = constructor_output_xmm(ctx, v1495);
                                                            let v1497 = Some(v1496);
                                                            // Rule at src/isa/x64/lower.isle line 2251.
                                                            return v1497;
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            F64 => {
                                let v925 = C::unpack_value_array_3(ctx, v924);
                                let v1482 = C::maybe_uextend(ctx, v925.0);
                                if let Some(v1483) = v1482 {
                                    let v1484 = C::def_inst(ctx, v1483);
                                    if let Some(v1485) = v1484 {
                                        let v1486 = &C::inst_data_value(ctx, v1485);
                                        if let &InstructionData::FloatCompare {
                                            opcode: ref v1487,
                                            args: ref v1488,
                                            cond: ref v1489,
                                        } = v1486 {
                                            if let &Opcode::Fcmp = v1487 {
                                                if let &FloatCC::LessThan = v1489 {
                                                    let v1490 = C::unpack_value_array_2(ctx, v1488);
                                                    if v925.1 == v1490.1 {
                                                        if v925.2 == v1490.0 {
                                                            let v1501 = constructor_put_in_xmm(ctx, v1490.1);
                                                            let v1502 = &C::put_in_xmm_mem(ctx, v1490.0);
                                                            let v1506 = constructor_x64_maxsd(ctx, v1501, v1502);
                                                            let v1507 = constructor_output_xmm(ctx, v1506);
                                                            let v1508 = Some(v1507);
                                                            // Rule at src/isa/x64/lower.isle line 2257.
                                                            return v1508;
                                                        }
                                                    }
                                                    if v925.1 == v1490.0 {
                                                        if v925.2 == v1490.1 {
                                                            let v1493 = constructor_put_in_xmm(ctx, v1490.0);
                                                            let v1494 = &C::put_in_xmm_mem(ctx, v1490.1);
                                                            let v1498 = constructor_x64_minsd(ctx, v1493, v1494);
                                                            let v1499 = constructor_output_xmm(ctx, v1498);
                                                            let v1500 = Some(v1499);
                                                            // Rule at src/isa/x64/lower.isle line 2253.
                                                            return v1500;
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            _ => {}
                        }
                    }
                    let v925 = C::unpack_value_array_3(ctx, v924);
                    let v1479 = &constructor_is_nonzero_cmp(ctx, v925.0);
                    let v1480 = constructor_lower_select(ctx, v1479, v925.1, v925.2);
                    let v1481 = Some(v1480);
                    // Rule at src/isa/x64/lower.isle line 2183.
                    return v1481;
                }
                &Opcode::SelectSpectreGuard => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        let v2024 = &C::type_register_class(ctx, v3);
                        if let Some(v2025) = v2024 {
                            if let &RegisterClass::Gpr {
                                single_register: v2026,
                            } = v2025 {
                                if v2026 == true {
                                    let v925 = C::unpack_value_array_3(ctx, v924);
                                    let v1479 = &constructor_is_nonzero_cmp(ctx, v925.0);
                                    let v2526 = constructor_put_in_gpr(ctx, v925.1);
                                    let v2527 = constructor_put_in_gpr(ctx, v925.2);
                                    let v2542 = constructor_lower_select_spectre_gpr(ctx, v3, v1479, v2526, v2527);
                                    let v2543 = constructor_output_gpr(ctx, v2542);
                                    let v2544 = Some(v2543);
                                    // Rule at src/isa/x64/lower.isle line 3659.
                                    return v2544;
                                }
                            }
                        }
                    }
                    let v925 = C::unpack_value_array_3(ctx, v924);
                    let v1479 = &constructor_is_nonzero_cmp(ctx, v925.0);
                    let v1480 = constructor_lower_select(ctx, v1479, v925.1, v925.2);
                    let v1481 = Some(v1480);
                    // Rule at src/isa/x64/lower.isle line 3653.
                    return v1481;
                }
                &Opcode::Bitselect => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        let v270 = C::ty_scalar_float(ctx, v3);
                        if let Some(v271) = v270 {
                            let v925 = C::unpack_value_array_3(ctx, v924);
                            let v929 = constructor_put_in_xmm(ctx, v925.0);
                            let v942 = &C::put_in_xmm_mem(ctx, v925.1);
                            let v1000 = constructor_sse_and(ctx, v271, v929, v942);
                            let v1001 = constructor_put_in_xmm(ctx, v925.0);
                            let v1002 = constructor_vector_all_ones(ctx);
                            let v1003 = &C::xmm_to_xmm_mem(ctx, v1002);
                            let v1004 = constructor_x64_xor_vector(ctx, v271, v1001, v1003);
                            let v1005 = &C::put_in_xmm_mem(ctx, v925.2);
                            let v1006 = constructor_sse_and(ctx, v271, v1004, v1005);
                            let v1007 = &C::xmm_to_xmm_mem(ctx, v1006);
                            let v1008 = constructor_sse_or(ctx, v271, v1000, v1007);
                            let v1009 = constructor_output_xmm(ctx, v1008);
                            let v1010 = Some(v1009);
                            // Rule at src/isa/x64/lower.isle line 1563.
                            return v1010;
                        }
                        let v987 = C::ty_int_ref_scalar_64_extract(ctx, v3);
                        if let Some(v988) = v987 {
                            let v925 = C::unpack_value_array_3(ctx, v924);
                            let v989 = constructor_put_in_gpr(ctx, v925.0);
                            let v990 = &constructor_put_in_gpr_mem_imm(ctx, v925.1);
                            let v991 = constructor_x64_and(ctx, v988, v989, v990);
                            let v992 = constructor_put_in_gpr(ctx, v925.0);
                            let v993 = constructor_x64_not(ctx, v988, v992);
                            let v994 = &constructor_put_in_gpr_mem_imm(ctx, v925.2);
                            let v995 = constructor_x64_and(ctx, v988, v993, v994);
                            let v996 = &C::gpr_to_gpr_mem_imm(ctx, v995);
                            let v997 = constructor_x64_or(ctx, v988, v991, v996);
                            let v998 = constructor_output_gpr(ctx, v997);
                            let v999 = Some(v998);
                            // Rule at src/isa/x64/lower.isle line 1558.
                            return v999;
                        }
                        match v3 {
                            I128 => {
                                let v925 = C::unpack_value_array_3(ctx, v924);
                                let v978 = C::put_in_regs(ctx, v925.0);
                                let v979 = C::put_in_regs(ctx, v925.1);
                                let v980 = constructor_and_i128(ctx, v978, v979);
                                let v981 = constructor_not_i128(ctx, v925.0);
                                let v982 = C::put_in_regs(ctx, v925.2);
                                let v983 = constructor_and_i128(ctx, v981, v982);
                                let v984 = constructor_or_i128(ctx, v980, v983);
                                let v985 = C::output(ctx, v984);
                                let v986 = Some(v985);
                                // Rule at src/isa/x64/lower.isle line 1553.
                                return v986;
                            }
                            F32X4 => {
                                let v925 = C::unpack_value_array_3(ctx, v924);
                                let v947 = C::def_inst(ctx, v925.0);
                                if let Some(v948) = v947 {
                                    let v949 = &C::inst_data_value(ctx, v948);
                                    if let &InstructionData::LoadNoOffset {
                                        opcode: ref v950,
                                        arg: v951,
                                        flags: v952,
                                    } = v949 {
                                        if let &Opcode::Bitcast = v950 {
                                            let v953 = C::def_inst(ctx, v951);
                                            if let Some(v954) = v953 {
                                                let v955 = &C::inst_data_value(ctx, v954);
                                                if let &InstructionData::FloatCompare {
                                                    opcode: ref v956,
                                                    args: ref v957,
                                                    cond: ref v958,
                                                } = v955 {
                                                    if let &Opcode::Fcmp = v956 {
                                                        if let &FloatCC::LessThan = v958 {
                                                            let v959 = C::unpack_value_array_2(ctx, v957);
                                                            if v925.1 == v959.1 {
                                                                if v925.2 == v959.0 {
                                                                    let v970 = constructor_put_in_xmm(ctx, v959.1);
                                                                    let v971 = &C::put_in_xmm_mem(ctx, v959.0);
                                                                    let v972 = constructor_x64_maxps(ctx, v970, v971);
                                                                    let v973 = constructor_output_xmm(ctx, v972);
                                                                    let v974 = Some(v973);
                                                                    // Rule at src/isa/x64/lower.isle line 1546.
                                                                    return v974;
                                                                }
                                                            }
                                                            if v925.1 == v959.0 {
                                                                if v925.2 == v959.1 {
                                                                    let v962 = constructor_put_in_xmm(ctx, v959.0);
                                                                    let v963 = &C::put_in_xmm_mem(ctx, v959.1);
                                                                    let v964 = constructor_x64_minps(ctx, v962, v963);
                                                                    let v965 = constructor_output_xmm(ctx, v964);
                                                                    let v966 = Some(v965);
                                                                    // Rule at src/isa/x64/lower.isle line 1541.
                                                                    return v966;
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            F64X2 => {
                                let v925 = C::unpack_value_array_3(ctx, v924);
                                let v947 = C::def_inst(ctx, v925.0);
                                if let Some(v948) = v947 {
                                    let v949 = &C::inst_data_value(ctx, v948);
                                    if let &InstructionData::LoadNoOffset {
                                        opcode: ref v950,
                                        arg: v951,
                                        flags: v952,
                                    } = v949 {
                                        if let &Opcode::Bitcast = v950 {
                                            let v953 = C::def_inst(ctx, v951);
                                            if let Some(v954) = v953 {
                                                let v955 = &C::inst_data_value(ctx, v954);
                                                if let &InstructionData::FloatCompare {
                                                    opcode: ref v956,
                                                    args: ref v957,
                                                    cond: ref v958,
                                                } = v955 {
                                                    if let &Opcode::Fcmp = v956 {
                                                        if let &FloatCC::LessThan = v958 {
                                                            let v959 = C::unpack_value_array_2(ctx, v957);
                                                            if v925.1 == v959.1 {
                                                                if v925.2 == v959.0 {
                                                                    let v970 = constructor_put_in_xmm(ctx, v959.1);
                                                                    let v971 = &C::put_in_xmm_mem(ctx, v959.0);
                                                                    let v975 = constructor_x64_maxpd(ctx, v970, v971);
                                                                    let v976 = constructor_output_xmm(ctx, v975);
                                                                    let v977 = Some(v976);
                                                                    // Rule at src/isa/x64/lower.isle line 1548.
                                                                    return v977;
                                                                }
                                                            }
                                                            if v925.1 == v959.0 {
                                                                if v925.2 == v959.1 {
                                                                    let v962 = constructor_put_in_xmm(ctx, v959.0);
                                                                    let v963 = &C::put_in_xmm_mem(ctx, v959.1);
                                                                    let v967 = constructor_x64_minpd(ctx, v962, v963);
                                                                    let v968 = constructor_output_xmm(ctx, v967);
                                                                    let v969 = Some(v968);
                                                                    // Rule at src/isa/x64/lower.isle line 1543.
                                                                    return v969;
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            _ => {}
                        }
                        let v89 = C::multi_lane(ctx, v3);
                        if let Some(v90) = v89 {
                            let v678 = C::has_sse41(ctx);
                            if v678 == true {
                                let v925 = C::unpack_value_array_3(ctx, v924);
                                let v939 = constructor_all_ones_or_all_zeros(ctx, v925.0);
                                if let Some(v940) = v939 {
                                    let v941 = constructor_put_in_xmm(ctx, v925.2);
                                    let v942 = &C::put_in_xmm_mem(ctx, v925.1);
                                    let v943 = constructor_put_in_xmm(ctx, v925.0);
                                    let v944 = constructor_x64_pblendvb(ctx, v941, v942, v943);
                                    let v945 = constructor_output_xmm(ctx, v944);
                                    let v946 = Some(v945);
                                    // Rule at src/isa/x64/lower.isle line 1519.
                                    return v946;
                                }
                            }
                            let v925 = C::unpack_value_array_3(ctx, v924);
                            let v929 = constructor_put_in_xmm(ctx, v925.0);
                            let v930 = constructor_put_in_xmm(ctx, v925.1);
                            let v931 = &C::xmm_to_xmm_mem(ctx, v929);
                            let v932 = constructor_sse_and(ctx, v3, v930, v931);
                            let v933 = &C::put_in_xmm_mem(ctx, v925.2);
                            let v934 = constructor_sse_and_not(ctx, v3, v929, v933);
                            let v935 = &C::xmm_to_xmm_mem(ctx, v932);
                            let v936 = constructor_sse_or(ctx, v3, v934, v935);
                            let v937 = constructor_output_xmm(ctx, v936);
                            let v938 = Some(v937);
                            // Rule at src/isa/x64/lower.isle line 1505.
                            return v938;
                        }
                    }
                }
                &Opcode::Blendv => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        match v3 {
                            I8X16 => {
                                let v678 = C::has_sse41(ctx);
                                if v678 == true {
                                    let v925 = C::unpack_value_array_3(ctx, v924);
                                    let v941 = constructor_put_in_xmm(ctx, v925.2);
                                    let v942 = &C::put_in_xmm_mem(ctx, v925.1);
                                    let v943 = constructor_put_in_xmm(ctx, v925.0);
                                    let v944 = constructor_x64_pblendvb(ctx, v941, v942, v943);
                                    let v945 = constructor_output_xmm(ctx, v944);
                                    let v946 = Some(v945);
                                    // Rule at src/isa/x64/lower.isle line 1571.
                                    return v946;
                                }
                            }
                            I32X4 => {
                                let v678 = C::has_sse41(ctx);
                                if v678 == true {
                                    let v925 = C::unpack_value_array_3(ctx, v924);
                                    let v941 = constructor_put_in_xmm(ctx, v925.2);
                                    let v942 = &C::put_in_xmm_mem(ctx, v925.1);
                                    let v943 = constructor_put_in_xmm(ctx, v925.0);
                                    let v1011 = constructor_x64_blendvps(ctx, v941, v942, v943);
                                    let v1012 = constructor_output_xmm(ctx, v1011);
                                    let v1013 = Some(v1012);
                                    // Rule at src/isa/x64/lower.isle line 1576.
                                    return v1013;
                                }
                            }
                            I64X2 => {
                                let v678 = C::has_sse41(ctx);
                                if v678 == true {
                                    let v925 = C::unpack_value_array_3(ctx, v924);
                                    let v941 = constructor_put_in_xmm(ctx, v925.2);
                                    let v942 = &C::put_in_xmm_mem(ctx, v925.1);
                                    let v943 = constructor_put_in_xmm(ctx, v925.0);
                                    let v1014 = constructor_x64_blendvpd(ctx, v941, v942, v943);
                                    let v1015 = constructor_output_xmm(ctx, v1014);
                                    let v1016 = Some(v1015);
                                    // Rule at src/isa/x64/lower.isle line 1581.
                                    return v1016;
                                }
                            }
                            _ => {}
                        }
                    }
                }
                &Opcode::Fma => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v2012 = C::use_fma(ctx);
                        if v2012 == true {
                            let v925 = C::unpack_value_array_3(ctx, v924);
                            let v2016 = C::def_inst(ctx, v925.2);
                            if let Some(v2017) = v2016 {
                                let v2018 = &C::inst_data_value(ctx, v2017);
                                if let &InstructionData::Unary {
                                    opcode: ref v2019,
                                    arg: v2020,
                                } = v2018 {
                                    if let &Opcode::Fneg = v2019 {
                                        let v3 = C::value_type(ctx, v2);
                                        let v2021 = constructor_fmsub(ctx, v3, v925.0, v925.1, v2020);
                                        let v2022 = constructor_output_xmm(ctx, v2021);
                                        let v2023 = Some(v2022);
                                        // Rule at src/isa/x64/lower.isle line 3017.
                                        return v2023;
                                    }
                                }
                            }
                            let v3 = C::value_type(ctx, v2);
                            let v2013 = constructor_fmadd(ctx, v3, v925.0, v925.1, v925.2);
                            let v2014 = constructor_output_xmm(ctx, v2013);
                            let v2015 = Some(v2014);
                            // Rule at src/isa/x64/lower.isle line 2990.
                            return v2015;
                        }
                        let v3 = C::value_type(ctx, v2);
                        match v3 {
                            F32 => {
                                let v925 = C::unpack_value_array_3(ctx, v924);
                                let v1943 = C::put_in_reg(ctx, v925.0);
                                let v1944 = C::put_in_reg(ctx, v925.1);
                                let v1945 = C::put_in_reg(ctx, v925.2);
                                let v1946 = C::libcall_3(ctx, &LibCall::FmaF32, v1943, v1944, v1945);
                                let v1947 = constructor_output_reg(ctx, v1946);
                                let v1948 = Some(v1947);
                                // Rule at src/isa/x64/lower.isle line 2945.
                                return v1948;
                            }
                            F64 => {
                                let v925 = C::unpack_value_array_3(ctx, v924);
                                let v1943 = C::put_in_reg(ctx, v925.0);
                                let v1944 = C::put_in_reg(ctx, v925.1);
                                let v1945 = C::put_in_reg(ctx, v925.2);
                                let v1950 = C::libcall_3(ctx, &LibCall::FmaF64, v1943, v1944, v1945);
                                let v1951 = constructor_output_reg(ctx, v1950);
                                let v1952 = Some(v1951);
                                // Rule at src/isa/x64/lower.isle line 2947.
                                return v1952;
                            }
                            F32X4 => {
                                let v925 = C::unpack_value_array_3(ctx, v924);
                                let v929 = constructor_put_in_xmm(ctx, v925.0);
                                let v930 = constructor_put_in_xmm(ctx, v925.1);
                                let v1953 = constructor_put_in_xmm(ctx, v925.2);
                                let v1954 = C::xmm_to_reg(ctx, v929);
                                let v1955 = C::xmm_to_reg(ctx, v930);
                                let v1956 = C::xmm_to_reg(ctx, v1953);
                                let v1957 = C::libcall_3(ctx, &LibCall::FmaF32, v1954, v1955, v1956);
                                let v1958 = C::xmm_new(ctx, v1957);
                                let v1959 = &C::xmm_to_xmm_mem(ctx, v929);
                                let v1960 = constructor_x64_pshufd(ctx, v1959, 0x1_u8);
                                let v1961 = C::xmm_to_reg(ctx, v1960);
                                let v1962 = &C::xmm_to_xmm_mem(ctx, v930);
                                let v1963 = constructor_x64_pshufd(ctx, v1962, 0x1_u8);
                                let v1964 = C::xmm_to_reg(ctx, v1963);
                                let v1965 = &C::xmm_to_xmm_mem(ctx, v1953);
                                let v1966 = constructor_x64_pshufd(ctx, v1965, 0x1_u8);
                                let v1967 = C::xmm_to_reg(ctx, v1966);
                                let v1968 = C::libcall_3(ctx, &LibCall::FmaF32, v1961, v1964, v1967);
                                let v1969 = C::xmm_new(ctx, v1968);
                                let v1970 = &C::xmm_to_xmm_mem(ctx, v929);
                                let v1972 = constructor_x64_pshufd(ctx, v1970, 0x2_u8);
                                let v1973 = C::xmm_to_reg(ctx, v1972);
                                let v1974 = &C::xmm_to_xmm_mem(ctx, v930);
                                let v1975 = constructor_x64_pshufd(ctx, v1974, 0x2_u8);
                                let v1976 = C::xmm_to_reg(ctx, v1975);
                                let v1977 = &C::xmm_to_xmm_mem(ctx, v1953);
                                let v1978 = constructor_x64_pshufd(ctx, v1977, 0x2_u8);
                                let v1979 = C::xmm_to_reg(ctx, v1978);
                                let v1980 = C::libcall_3(ctx, &LibCall::FmaF32, v1973, v1976, v1979);
                                let v1981 = C::xmm_new(ctx, v1980);
                                let v1982 = &C::xmm_to_xmm_mem(ctx, v929);
                                let v1983 = constructor_x64_pshufd(ctx, v1982, 0x3_u8);
                                let v1984 = C::xmm_to_reg(ctx, v1983);
                                let v1985 = &C::xmm_to_xmm_mem(ctx, v930);
                                let v1986 = constructor_x64_pshufd(ctx, v1985, 0x3_u8);
                                let v1987 = C::xmm_to_reg(ctx, v1986);
                                let v1988 = &C::xmm_to_xmm_mem(ctx, v1953);
                                let v1989 = constructor_x64_pshufd(ctx, v1988, 0x3_u8);
                                let v1990 = C::xmm_to_reg(ctx, v1989);
                                let v1991 = C::libcall_3(ctx, &LibCall::FmaF32, v1984, v1987, v1990);
                                let v1992 = C::xmm_new(ctx, v1991);
                                let v1993 = constructor_f32x4_insertlane(ctx, v1958, v1969, 0x1_u8);
                                let v1994 = constructor_f32x4_insertlane(ctx, v1993, v1981, 0x2_u8);
                                let v1995 = constructor_f32x4_insertlane(ctx, v1994, v1992, 0x3_u8);
                                let v1996 = constructor_output_xmm(ctx, v1995);
                                let v1997 = Some(v1996);
                                // Rule at src/isa/x64/lower.isle line 2950.
                                return v1997;
                            }
                            F64X2 => {
                                let v925 = C::unpack_value_array_3(ctx, v924);
                                let v929 = constructor_put_in_xmm(ctx, v925.0);
                                let v930 = constructor_put_in_xmm(ctx, v925.1);
                                let v1953 = constructor_put_in_xmm(ctx, v925.2);
                                let v1954 = C::xmm_to_reg(ctx, v929);
                                let v1955 = C::xmm_to_reg(ctx, v930);
                                let v1956 = C::xmm_to_reg(ctx, v1953);
                                let v1998 = C::libcall_3(ctx, &LibCall::FmaF64, v1954, v1955, v1956);
                                let v1999 = C::xmm_new(ctx, v1998);
                                let v1959 = &C::xmm_to_xmm_mem(ctx, v929);
                                let v2001 = constructor_x64_pshufd(ctx, v1959, 0xee_u8);
                                let v2002 = C::xmm_to_reg(ctx, v2001);
                                let v1962 = &C::xmm_to_xmm_mem(ctx, v930);
                                let v2003 = constructor_x64_pshufd(ctx, v1962, 0xee_u8);
                                let v2004 = C::xmm_to_reg(ctx, v2003);
                                let v1965 = &C::xmm_to_xmm_mem(ctx, v1953);
                                let v2005 = constructor_x64_pshufd(ctx, v1965, 0xee_u8);
                                let v2006 = C::xmm_to_reg(ctx, v2005);
                                let v2007 = C::libcall_3(ctx, &LibCall::FmaF64, v2002, v2004, v2006);
                                let v2008 = C::xmm_new(ctx, v2007);
                                let v2009 = constructor_x64_movlhps(ctx, v1999, v2008);
                                let v2010 = constructor_output_xmm(ctx, v2009);
                                let v2011 = Some(v2010);
                                // Rule at src/isa/x64/lower.isle line 2974.
                                return v2011;
                            }
                            _ => {}
                        }
                    }
                }
                _ => {}
            }
        }
        &InstructionData::TernaryImm8 {
            opcode: ref v1017,
            args: ref v1018,
            imm: v1019,
        } => {
            if let &Opcode::Insertlane = v1017 {
                let v678 = C::has_sse41(ctx);
                if v678 == true {
                    let v1024 = C::u8_from_uimm8(ctx, v1019);
                    if v1024 == 0x1_u8 {
                        let v1020 = C::unpack_value_array_2(ctx, v1018);
                        let v1106 = C::def_inst(ctx, v1020.0);
                        if let Some(v1107) = v1106 {
                            let v1108 = C::first_result(ctx, v1107);
                            if let Some(v1109) = v1108 {
                                let v1110 = C::value_type(ctx, v1109);
                                if v1110 == I64X2 {
                                    let v1111 = &C::inst_data_value(ctx, v1107);
                                    if let &InstructionData::Unary {
                                        opcode: ref v1112,
                                        arg: v1113,
                                    } = v1111 {
                                        if let &Opcode::Splat = v1112 {
                                            let v1115 = constructor_put_in_gpr(ctx, v1113);
                                            let v1116 = constructor_bitcast_gpr_to_xmm(ctx, 0x40_u8, v1115);
                                            let v1117 = &constructor_put_in_gpr_mem(ctx, v1020.1);
                                            let v1119 = constructor_x64_pinsrq(ctx, v1116, v1117, 0x1_u8);
                                            let v1120 = constructor_output_xmm(ctx, v1119);
                                            let v1121 = Some(v1120);
                                            // Rule at src/isa/x64/lower.isle line 1683.
                                            return v1121;
                                        }
                                    }
                                }
                            }
                        }
                    }
                    let v1020 = C::unpack_value_array_2(ctx, v1018);
                    let v1023 = C::value_type(ctx, v1020.0);
                    match v1023 {
                        I8X16 => {
                            let v1030 = &C::sinkable_load_exact(ctx, v1020.1);
                            if let Some(v1031) = v1030 {
                                let v1025 = constructor_put_in_xmm(ctx, v1020.0);
                                let v1032 = &constructor_sink_load_to_gpr_mem(ctx, v1031);
                                let v1033 = constructor_x64_pinsrb(ctx, v1025, v1032, v1024);
                                let v1034 = constructor_output_xmm(ctx, v1033);
                                let v1035 = Some(v1034);
                                // Rule at src/isa/x64/lower.isle line 1591.
                                return v1035;
                            }
                            let v1025 = constructor_put_in_xmm(ctx, v1020.0);
                            let v1026 = &constructor_put_in_gpr_mem(ctx, v1020.1);
                            let v1027 = constructor_x64_pinsrb(ctx, v1025, v1026, v1024);
                            let v1028 = constructor_output_xmm(ctx, v1027);
                            let v1029 = Some(v1028);
                            // Rule at src/isa/x64/lower.isle line 1588.
                            return v1029;
                        }
                        I32X4 => {
                            let v1025 = constructor_put_in_xmm(ctx, v1020.0);
                            let v1026 = &constructor_put_in_gpr_mem(ctx, v1020.1);
                            let v1064 = constructor_x64_pinsrd(ctx, v1025, v1026, v1024);
                            let v1065 = constructor_output_xmm(ctx, v1064);
                            let v1066 = Some(v1065);
                            // Rule at src/isa/x64/lower.isle line 1643.
                            return v1066;
                        }
                        I64X2 => {
                            let v1025 = constructor_put_in_xmm(ctx, v1020.0);
                            let v1026 = &constructor_put_in_gpr_mem(ctx, v1020.1);
                            let v1095 = constructor_x64_pinsrq(ctx, v1025, v1026, v1024);
                            let v1096 = constructor_output_xmm(ctx, v1095);
                            let v1097 = Some(v1096);
                            // Rule at src/isa/x64/lower.isle line 1672.
                            return v1097;
                        }
                        F32X4 => {
                            let v1122 = &C::sinkable_load(ctx, v1020.1);
                            if let Some(v1123) = v1122 {
                                let v1025 = constructor_put_in_xmm(ctx, v1020.0);
                                let v1124 = &constructor_sink_load_to_xmm_mem(ctx, v1123);
                                let v1125 = C::sse_insertps_lane_imm(ctx, v1024);
                                let v1126 = constructor_x64_insertps(ctx, v1025, v1124, v1125);
                                let v1127 = constructor_output_xmm(ctx, v1126);
                                let v1128 = Some(v1127);
                                // Rule at src/isa/x64/lower.isle line 1689.
                                return v1128;
                            }
                        }
                        _ => {}
                    }
                }
                let v1020 = C::unpack_value_array_2(ctx, v1018);
                let v1023 = C::value_type(ctx, v1020.0);
                match v1023 {
                    I8X16 => {
                        let v1025 = constructor_put_in_xmm(ctx, v1020.0);
                        let v1024 = C::u8_from_uimm8(ctx, v1019);
                        let v1036 = C::insert_i8x16_lane_hole(ctx, v1024);
                        let v1037 = &constructor_const_to_xmm_mem(ctx, v1036);
                        let v1038 = constructor_x64_pand(ctx, v1025, v1037);
                        let v1040 = &constructor_put_in_gpr_mem(ctx, v1020.1);
                        let v1041 = constructor_x64_movzx(ctx, &ExtMode::BL, v1040);
                        let v1043 = C::u8_and(ctx, v1024, 0x3_u8);
                        let v1045 = C::u8_wrapping_shl(ctx, v1043, 0x3_u32);
                        let v1046 = constructor_x64_shll_mi(ctx, v1041, v1045);
                        let v1047 = &C::gpr_to_gpr_mem(ctx, v1046);
                        let v1048 = constructor_x64_movd_to_xmm(ctx, v1047);
                        let v1049 = &C::xmm_to_xmm_mem(ctx, v1048);
                        let v1051 = C::u8_wrapping_shr(ctx, v1024, 0x2_u32);
                        let v1052 = constructor_insert_i8x16_lane_pshufd_imm(ctx, v1051);
                        let v1053 = constructor_x64_pshufd(ctx, v1049, v1052);
                        let v1054 = &C::xmm_to_xmm_mem(ctx, v1053);
                        let v1055 = constructor_x64_por(ctx, v1038, v1054);
                        let v1056 = constructor_output_xmm(ctx, v1055);
                        let v1057 = Some(v1056);
                        // Rule at src/isa/x64/lower.isle line 1619.
                        return v1057;
                    }
                    I16X8 => {
                        let v1030 = &C::sinkable_load_exact(ctx, v1020.1);
                        if let Some(v1031) = v1030 {
                            let v1025 = constructor_put_in_xmm(ctx, v1020.0);
                            let v1032 = &constructor_sink_load_to_gpr_mem(ctx, v1031);
                            let v1024 = C::u8_from_uimm8(ctx, v1019);
                            let v1061 = constructor_x64_pinsrw(ctx, v1025, v1032, v1024);
                            let v1062 = constructor_output_xmm(ctx, v1061);
                            let v1063 = Some(v1062);
                            // Rule at src/isa/x64/lower.isle line 1639.
                            return v1063;
                        }
                        let v1025 = constructor_put_in_xmm(ctx, v1020.0);
                        let v1026 = &constructor_put_in_gpr_mem(ctx, v1020.1);
                        let v1024 = C::u8_from_uimm8(ctx, v1019);
                        let v1058 = constructor_x64_pinsrw(ctx, v1025, v1026, v1024);
                        let v1059 = constructor_output_xmm(ctx, v1058);
                        let v1060 = Some(v1059);
                        // Rule at src/isa/x64/lower.isle line 1637.
                        return v1060;
                    }
                    I32X4 => {
                        let v1024 = C::u8_from_uimm8(ctx, v1019);
                        match v1024 {
                            0x0_u8 => {
                                let v1025 = constructor_put_in_xmm(ctx, v1020.0);
                                let v1026 = &constructor_put_in_gpr_mem(ctx, v1020.1);
                                let v1067 = constructor_x64_movd_to_xmm(ctx, v1026);
                                let v1068 = constructor_x64_movss_regmove(ctx, v1025, v1067);
                                let v1069 = constructor_output_xmm(ctx, v1068);
                                let v1070 = Some(v1069);
                                // Rule at src/isa/x64/lower.isle line 1647.
                                return v1070;
                            }
                            0x1_u8 => {
                                let v1071 = &constructor_put_in_gpr_mem(ctx, v1020.1);
                                let v1072 = constructor_x64_movd_to_xmm(ctx, v1071);
                                let v1073 = constructor_put_in_xmm(ctx, v1020.0);
                                let v1074 = &C::xmm_to_xmm_mem(ctx, v1073);
                                let v1075 = constructor_x64_punpcklqdq(ctx, v1072, v1074);
                                let v1076 = &C::xmm_to_xmm_mem(ctx, v1073);
                                let v1078 = constructor_x64_shufps(ctx, v1075, v1076, 0xe2_u8);
                                let v1079 = constructor_output_xmm(ctx, v1078);
                                let v1080 = Some(v1079);
                                // Rule at src/isa/x64/lower.isle line 1652.
                                return v1080;
                            }
                            0x2_u8 => {
                                let v1071 = &constructor_put_in_gpr_mem(ctx, v1020.1);
                                let v1072 = constructor_x64_movd_to_xmm(ctx, v1071);
                                let v1073 = constructor_put_in_xmm(ctx, v1020.0);
                                let v1074 = &C::xmm_to_xmm_mem(ctx, v1073);
                                let v1082 = constructor_x64_shufps(ctx, v1072, v1074, 0x30_u8);
                                let v1083 = &C::xmm_to_xmm_mem(ctx, v1082);
                                let v1085 = constructor_x64_shufps(ctx, v1073, v1083, 0x84_u8);
                                let v1086 = constructor_output_xmm(ctx, v1085);
                                let v1087 = Some(v1086);
                                // Rule at src/isa/x64/lower.isle line 1659.
                                return v1087;
                            }
                            0x3_u8 => {
                                let v1071 = &constructor_put_in_gpr_mem(ctx, v1020.1);
                                let v1072 = constructor_x64_movd_to_xmm(ctx, v1071);
                                let v1073 = constructor_put_in_xmm(ctx, v1020.0);
                                let v1074 = &C::xmm_to_xmm_mem(ctx, v1073);
                                let v1089 = constructor_x64_shufps(ctx, v1072, v1074, 0xe4_u8);
                                let v1090 = &C::xmm_to_xmm_mem(ctx, v1089);
                                let v1092 = constructor_x64_shufps(ctx, v1073, v1090, 0x24_u8);
                                let v1093 = constructor_output_xmm(ctx, v1092);
                                let v1094 = Some(v1093);
                                // Rule at src/isa/x64/lower.isle line 1666.
                                return v1094;
                            }
                            _ => {}
                        }
                    }
                    I64X2 => {
                        let v1024 = C::u8_from_uimm8(ctx, v1019);
                        match v1024 {
                            0x0_u8 => {
                                let v1025 = constructor_put_in_xmm(ctx, v1020.0);
                                let v1026 = &constructor_put_in_gpr_mem(ctx, v1020.1);
                                let v1098 = constructor_x64_movq_to_xmm(ctx, v1026);
                                let v1099 = constructor_x64_movsd_regmove(ctx, v1025, v1098);
                                let v1100 = constructor_output_xmm(ctx, v1099);
                                let v1101 = Some(v1100);
                                // Rule at src/isa/x64/lower.isle line 1675.
                                return v1101;
                            }
                            0x1_u8 => {
                                let v1025 = constructor_put_in_xmm(ctx, v1020.0);
                                let v1026 = &constructor_put_in_gpr_mem(ctx, v1020.1);
                                let v1098 = constructor_x64_movq_to_xmm(ctx, v1026);
                                let v1102 = &C::xmm_to_xmm_mem(ctx, v1098);
                                let v1103 = constructor_x64_punpcklqdq(ctx, v1025, v1102);
                                let v1104 = constructor_output_xmm(ctx, v1103);
                                let v1105 = Some(v1104);
                                // Rule at src/isa/x64/lower.isle line 1677.
                                return v1105;
                            }
                            _ => {}
                        }
                    }
                    F32X4 => {
                        let v1025 = constructor_put_in_xmm(ctx, v1020.0);
                        let v1129 = constructor_put_in_xmm(ctx, v1020.1);
                        let v1024 = C::u8_from_uimm8(ctx, v1019);
                        let v1130 = constructor_f32x4_insertlane(ctx, v1025, v1129, v1024);
                        let v1131 = constructor_output_xmm(ctx, v1130);
                        let v1132 = Some(v1131);
                        // Rule at src/isa/x64/lower.isle line 1692.
                        return v1132;
                    }
                    F64X2 => {
                        let v1024 = C::u8_from_uimm8(ctx, v1019);
                        match v1024 {
                            0x0_u8 => {
                                let v1025 = constructor_put_in_xmm(ctx, v1020.0);
                                let v1129 = constructor_put_in_xmm(ctx, v1020.1);
                                let v1133 = constructor_x64_movsd_regmove(ctx, v1025, v1129);
                                let v1134 = constructor_output_xmm(ctx, v1133);
                                let v1135 = Some(v1134);
                                // Rule at src/isa/x64/lower.isle line 1737.
                                return v1135;
                            }
                            0x1_u8 => {
                                let v1025 = constructor_put_in_xmm(ctx, v1020.0);
                                let v1129 = constructor_put_in_xmm(ctx, v1020.1);
                                let v1136 = constructor_x64_movlhps(ctx, v1025, v1129);
                                let v1137 = constructor_output_xmm(ctx, v1136);
                                let v1138 = Some(v1137);
                                // Rule at src/isa/x64/lower.isle line 1745.
                                return v1138;
                            }
                            _ => {}
                        }
                    }
                    _ => {}
                }
            }
        }
        &InstructionData::Trap {
            opcode: ref v1210,
            code: ref v1211,
        } => {
            if let &Opcode::Trap = v1210 {
                let v1212 = &constructor_x64_ud2_zo(ctx, v1211);
                let v1213 = constructor_side_effect(ctx, v1212);
                let v1214 = Some(v1213);
                // Rule at src/isa/x64/lower.isle line 1897.
                return v1214;
            }
        }
        &InstructionData::Unary {
            opcode: ref v576,
            arg: v577,
        } => {
            match v576 {
                &Opcode::Splat => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        let v89 = C::multi_lane(ctx, v3);
                        if let Some(v90) = v89 {
                            match v90.0 {
                                0x20_u32 => {
                                    if v90.1 == 0x4_u32 {
                                        let v3301 = &C::sinkable_load(ctx, v577);
                                        if let Some(v3302) = v3301 {
                                            let v3380 = C::has_avx(ctx);
                                            if v3380 == true {
                                                let v3381 = &constructor_sink_load_to_xmm_mem(ctx, v3302);
                                                let v3382 = constructor_x64_vbroadcastss(ctx, v3381);
                                                let v3383 = constructor_output_xmm(ctx, v3382);
                                                let v3384 = Some(v3383);
                                                // Rule at src/isa/x64/lower.isle line 4897.
                                                return v3384;
                                            }
                                            let v3305 = &C::sink_load(ctx, v3302);
                                            let v3306 = constructor_x64_movss_load(ctx, v3305);
                                            let v3376 = &C::xmm_to_xmm_mem(ctx, v3306);
                                            let v3377 = constructor_x64_shufps(ctx, v3306, v3376, 0x0_u8);
                                            let v3378 = constructor_output_xmm(ctx, v3377);
                                            let v3379 = Some(v3378);
                                            // Rule at src/isa/x64/lower.isle line 4894.
                                            return v3379;
                                        }
                                    }
                                }
                                0x40_u32 => {
                                    if v90.1 == 0x2_u32 {
                                        let v3301 = &C::sinkable_load(ctx, v577);
                                        if let Some(v3302) = v3301 {
                                            let v3394 = C::has_sse3(ctx);
                                            if v3394 == true {
                                                let v3381 = &constructor_sink_load_to_xmm_mem(ctx, v3302);
                                                let v3395 = constructor_x64_movddup(ctx, v3381);
                                                let v3396 = constructor_output_xmm(ctx, v3395);
                                                let v3397 = Some(v3396);
                                                // Rule at src/isa/x64/lower.isle line 4908.
                                                return v3397;
                                            }
                                        }
                                    }
                                }
                                _ => {}
                            }
                        }
                        match v3 {
                            I8X16 => {
                                let v3335 = &C::sinkable_load_exact(ctx, v577);
                                if let Some(v3336) = v3335 {
                                    let v3330 = C::use_avx2(ctx);
                                    if v3330 == true {
                                        let v3342 = &constructor_sink_load_to_xmm_mem(ctx, v3336);
                                        let v3343 = constructor_x64_vpbroadcastb(ctx, v3342);
                                        let v3344 = constructor_output_xmm(ctx, v3343);
                                        let v3345 = Some(v3344);
                                        // Rule at src/isa/x64/lower.isle line 4845.
                                        return v3345;
                                    }
                                    let v678 = C::has_sse41(ctx);
                                    if v678 == true {
                                        let v772 = C::has_ssse3(ctx);
                                        if v772 == true {
                                            let v2070 = constructor_xmm_uninit_value(ctx);
                                            let v3337 = &constructor_sink_load_to_gpr_mem(ctx, v3336);
                                            let v3338 = constructor_x64_pinsrb(ctx, v2070, v3337, 0x0_u8);
                                            let v1408 = constructor_xmm_zero(ctx, I8X16);
                                            let v1409 = &C::xmm_to_xmm_mem(ctx, v1408);
                                            let v3339 = constructor_x64_pshufb(ctx, v3338, v1409);
                                            let v3340 = constructor_output_xmm(ctx, v3339);
                                            let v3341 = Some(v3340);
                                            // Rule at src/isa/x64/lower.isle line 4841.
                                            return v3341;
                                        }
                                    }
                                }
                                let v3330 = C::use_avx2(ctx);
                                if v3330 == true {
                                    let v578 = constructor_put_in_gpr(ctx, v577);
                                    let v3324 = constructor_bitcast_gpr_to_xmm(ctx, 0x20_u8, v578);
                                    let v3331 = &C::xmm_to_xmm_mem(ctx, v3324);
                                    let v3332 = constructor_x64_vpbroadcastb(ctx, v3331);
                                    let v3333 = constructor_output_xmm(ctx, v3332);
                                    let v3334 = Some(v3333);
                                    // Rule at src/isa/x64/lower.isle line 4838.
                                    return v3334;
                                }
                                let v772 = C::has_ssse3(ctx);
                                if v772 == true {
                                    let v578 = constructor_put_in_gpr(ctx, v577);
                                    let v3324 = constructor_bitcast_gpr_to_xmm(ctx, 0x20_u8, v578);
                                    let v3325 = constructor_xmm_zero(ctx, I8X16);
                                    let v3326 = &C::xmm_to_xmm_mem(ctx, v3325);
                                    let v3327 = constructor_x64_pshufb(ctx, v3324, v3326);
                                    let v3328 = constructor_output_xmm(ctx, v3327);
                                    let v3329 = Some(v3328);
                                    // Rule at src/isa/x64/lower.isle line 4835.
                                    return v3329;
                                }
                                let v1606 = &constructor_put_in_gpr_mem(ctx, v577);
                                let v3314 = constructor_x64_movd_to_xmm(ctx, v1606);
                                let v3315 = &C::xmm_to_xmm_mem(ctx, v3314);
                                let v3316 = constructor_x64_punpcklbw(ctx, v3314, v3315);
                                let v3317 = &C::xmm_to_xmm_mem(ctx, v3316);
                                let v3318 = constructor_x64_pshuflw(ctx, v3317, 0x0_u8);
                                let v3319 = &C::xmm_to_xmm_mem(ctx, v3318);
                                let v3320 = constructor_x64_pshufd(ctx, v3319, 0x0_u8);
                                let v3321 = constructor_output_xmm(ctx, v3320);
                                let v3322 = Some(v3321);
                                // Rule at src/isa/x64/lower.isle line 4832.
                                return v3322;
                            }
                            I16X8 => {
                                let v3335 = &C::sinkable_load_exact(ctx, v577);
                                if let Some(v3336) = v3335 {
                                    let v3330 = C::use_avx2(ctx);
                                    if v3330 == true {
                                        let v3342 = &constructor_sink_load_to_xmm_mem(ctx, v3336);
                                        let v3361 = constructor_x64_vpbroadcastw(ctx, v3342);
                                        let v3362 = constructor_output_xmm(ctx, v3361);
                                        let v3363 = Some(v3362);
                                        // Rule at src/isa/x64/lower.isle line 4861.
                                        return v3363;
                                    }
                                    let v2070 = constructor_xmm_uninit_value(ctx);
                                    let v3337 = &constructor_sink_load_to_gpr_mem(ctx, v3336);
                                    let v3354 = constructor_x64_pinsrw(ctx, v2070, v3337, 0x0_u8);
                                    let v3355 = &C::xmm_to_xmm_mem(ctx, v3354);
                                    let v3356 = constructor_x64_pshuflw(ctx, v3355, 0x0_u8);
                                    let v3357 = &C::xmm_to_xmm_mem(ctx, v3356);
                                    let v3358 = constructor_x64_pshufd(ctx, v3357, 0x0_u8);
                                    let v3359 = constructor_output_xmm(ctx, v3358);
                                    let v3360 = Some(v3359);
                                    // Rule at src/isa/x64/lower.isle line 4859.
                                    return v3360;
                                }
                                let v3330 = C::use_avx2(ctx);
                                if v3330 == true {
                                    let v578 = constructor_put_in_gpr(ctx, v577);
                                    let v3324 = constructor_bitcast_gpr_to_xmm(ctx, 0x20_u8, v578);
                                    let v3331 = &C::xmm_to_xmm_mem(ctx, v3324);
                                    let v3351 = constructor_x64_vpbroadcastw(ctx, v3331);
                                    let v3352 = constructor_output_xmm(ctx, v3351);
                                    let v3353 = Some(v3352);
                                    // Rule at src/isa/x64/lower.isle line 4856.
                                    return v3353;
                                }
                                let v578 = constructor_put_in_gpr(ctx, v577);
                                let v3324 = constructor_bitcast_gpr_to_xmm(ctx, 0x20_u8, v578);
                                let v3331 = &C::xmm_to_xmm_mem(ctx, v3324);
                                let v3346 = constructor_x64_pshuflw(ctx, v3331, 0x0_u8);
                                let v3347 = &C::xmm_to_xmm_mem(ctx, v3346);
                                let v3348 = constructor_x64_pshufd(ctx, v3347, 0x0_u8);
                                let v3349 = constructor_output_xmm(ctx, v3348);
                                let v3350 = Some(v3349);
                                // Rule at src/isa/x64/lower.isle line 4854.
                                return v3350;
                            }
                            I32X4 => {
                                let v3330 = C::use_avx2(ctx);
                                if v3330 == true {
                                    let v578 = constructor_put_in_gpr(ctx, v577);
                                    let v3324 = constructor_bitcast_gpr_to_xmm(ctx, 0x20_u8, v578);
                                    let v3331 = &C::xmm_to_xmm_mem(ctx, v3324);
                                    let v3367 = constructor_x64_vpbroadcastd(ctx, v3331);
                                    let v3368 = constructor_output_xmm(ctx, v3367);
                                    let v3369 = Some(v3368);
                                    // Rule at src/isa/x64/lower.isle line 4871.
                                    return v3369;
                                }
                                let v578 = constructor_put_in_gpr(ctx, v577);
                                let v3324 = constructor_bitcast_gpr_to_xmm(ctx, 0x20_u8, v578);
                                let v3331 = &C::xmm_to_xmm_mem(ctx, v3324);
                                let v3364 = constructor_x64_pshufd(ctx, v3331, 0x0_u8);
                                let v3365 = constructor_output_xmm(ctx, v3364);
                                let v3366 = Some(v3365);
                                // Rule at src/isa/x64/lower.isle line 4869.
                                return v3366;
                            }
                            I64X2 => {
                                let v578 = constructor_put_in_gpr(ctx, v577);
                                let v3385 = constructor_bitcast_gpr_to_xmm(ctx, 0x40_u8, v578);
                                let v3386 = &C::xmm_to_xmm_mem(ctx, v3385);
                                let v3388 = constructor_x64_pshufd(ctx, v3386, 0x44_u8);
                                let v3389 = constructor_output_xmm(ctx, v3388);
                                let v3390 = Some(v3389);
                                // Rule at src/isa/x64/lower.isle line 4904.
                                return v3390;
                            }
                            F32X4 => {
                                let v3330 = C::use_avx2(ctx);
                                if v3330 == true {
                                    let v773 = &C::put_in_xmm_mem(ctx, v577);
                                    let v3373 = constructor_x64_vbroadcastss(ctx, v773);
                                    let v3374 = constructor_output_xmm(ctx, v3373);
                                    let v3375 = Some(v3374);
                                    // Rule at src/isa/x64/lower.isle line 4881.
                                    return v3375;
                                }
                                let v777 = constructor_put_in_xmm(ctx, v577);
                                let v3290 = constructor_put_in_xmm(ctx, v577);
                                let v595 = &C::put_in_xmm_mem(ctx, v577);
                                let v3370 = constructor_x64_shufps(ctx, v3290, v595, 0x0_u8);
                                let v3371 = constructor_output_xmm(ctx, v3370);
                                let v3372 = Some(v3371);
                                // Rule at src/isa/x64/lower.isle line 4878.
                                return v3372;
                            }
                            F64X2 => {
                                let v777 = constructor_put_in_xmm(ctx, v577);
                                let v1857 = &C::xmm_to_xmm_mem(ctx, v777);
                                let v3391 = constructor_x64_pshufd(ctx, v1857, 0x44_u8);
                                let v3392 = constructor_output_xmm(ctx, v3391);
                                let v3393 = Some(v3392);
                                // Rule at src/isa/x64/lower.isle line 4906.
                                return v3393;
                            }
                            _ => {}
                        }
                    }
                }
                &Opcode::SetPinnedReg => {
                    let v578 = constructor_put_in_gpr(ctx, v577);
                    let v3088 = &constructor_write_pinned_gpr(ctx, v578);
                    let v3089 = constructor_side_effect(ctx, v3088);
                    let v3090 = Some(v3089);
                    // Rule at src/isa/x64/lower.isle line 4545.
                    return v3090;
                }
                &Opcode::VanyTrue => {
                    let v3398 = &constructor_is_vany_true(ctx, v577);
                    let v3399 = constructor_lower_cond_bool(ctx, v3398);
                    let v3400 = constructor_output_gpr(ctx, v3399);
                    let v3401 = Some(v3400);
                    // Rule at src/isa/x64/lower.isle line 4914.
                    return v3401;
                }
                &Opcode::VallTrue => {
                    let v3402 = &constructor_is_vall_true(ctx, v577);
                    let v3403 = constructor_lower_cond_bool(ctx, v3402);
                    let v3404 = constructor_output_gpr(ctx, v3403);
                    let v3405 = Some(v3404);
                    // Rule at src/isa/x64/lower.isle line 4934.
                    return v3405;
                }
                &Opcode::VhighBits => {
                    let v906 = C::value_type(ctx, v577);
                    let v3406 = C::multi_lane(ctx, v906);
                    if let Some(v3407) = v3406 {
                        match v3407.0 {
                            0x8_u32 => {
                                if v3407.1 == 0x10_u32 {
                                    let v777 = constructor_put_in_xmm(ctx, v577);
                                    let v3410 = constructor_x64_pmovmskb(ctx, v777);
                                    let v3411 = constructor_output_gpr(ctx, v3410);
                                    let v3412 = Some(v3411);
                                    // Rule at src/isa/x64/lower.isle line 4963.
                                    return v3412;
                                }
                            }
                            0x10_u32 => {
                                if v3407.1 == 0x8_u32 {
                                    let v777 = constructor_put_in_xmm(ctx, v577);
                                    let v1857 = &C::xmm_to_xmm_mem(ctx, v777);
                                    let v3419 = constructor_x64_packsswb(ctx, v777, v1857);
                                    let v3420 = constructor_x64_pmovmskb(ctx, v3419);
                                    let v3421 = constructor_x64_shrq_mi(ctx, v3420, 0x8_u8);
                                    let v3422 = constructor_output_gpr(ctx, v3421);
                                    let v3423 = Some(v3422);
                                    // Rule at src/isa/x64/lower.isle line 4978.
                                    return v3423;
                                }
                            }
                            0x20_u32 => {
                                if v3407.1 == 0x4_u32 {
                                    let v777 = constructor_put_in_xmm(ctx, v577);
                                    let v3413 = constructor_x64_movmskps(ctx, v777);
                                    let v3414 = constructor_output_gpr(ctx, v3413);
                                    let v3415 = Some(v3414);
                                    // Rule at src/isa/x64/lower.isle line 4966.
                                    return v3415;
                                }
                            }
                            0x40_u32 => {
                                if v3407.1 == 0x2_u32 {
                                    let v777 = constructor_put_in_xmm(ctx, v577);
                                    let v3416 = constructor_x64_movmskpd(ctx, v777);
                                    let v3417 = constructor_output_gpr(ctx, v3416);
                                    let v3418 = Some(v3417);
                                    // Rule at src/isa/x64/lower.isle line 4969.
                                    return v3418;
                                }
                            }
                            _ => {}
                        }
                    }
                }
                &Opcode::Ineg => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        match v3 {
                            I8X16 => {
                                let v593 = constructor_imm(ctx, I8X16, 0x0_u64);
                                let v594 = C::xmm_new(ctx, v593);
                                let v595 = &C::put_in_xmm_mem(ctx, v577);
                                let v596 = constructor_x64_psubb(ctx, v594, v595);
                                let v597 = constructor_output_xmm(ctx, v596);
                                let v598 = Some(v597);
                                // Rule at src/isa/x64/lower.isle line 1012.
                                return v598;
                            }
                            I16X8 => {
                                let v600 = constructor_imm(ctx, I16X8, 0x0_u64);
                                let v601 = C::xmm_new(ctx, v600);
                                let v595 = &C::put_in_xmm_mem(ctx, v577);
                                let v602 = constructor_x64_psubw(ctx, v601, v595);
                                let v603 = constructor_output_xmm(ctx, v602);
                                let v604 = Some(v603);
                                // Rule at src/isa/x64/lower.isle line 1015.
                                return v604;
                            }
                            I32X4 => {
                                let v606 = constructor_imm(ctx, I32X4, 0x0_u64);
                                let v607 = C::xmm_new(ctx, v606);
                                let v595 = &C::put_in_xmm_mem(ctx, v577);
                                let v608 = constructor_x64_psubd(ctx, v607, v595);
                                let v609 = constructor_output_xmm(ctx, v608);
                                let v610 = Some(v609);
                                // Rule at src/isa/x64/lower.isle line 1018.
                                return v610;
                            }
                            I64X2 => {
                                let v612 = constructor_imm(ctx, I64X2, 0x0_u64);
                                let v613 = C::xmm_new(ctx, v612);
                                let v595 = &C::put_in_xmm_mem(ctx, v577);
                                let v614 = constructor_x64_psubq(ctx, v613, v595);
                                let v615 = constructor_output_xmm(ctx, v614);
                                let v616 = Some(v615);
                                // Rule at src/isa/x64/lower.isle line 1021.
                                return v616;
                            }
                            _ => {}
                        }
                        let v4 = C::fits_in_64(ctx, v3);
                        if let Some(v5) = v4 {
                            let v578 = constructor_put_in_gpr(ctx, v577);
                            let v579 = constructor_x64_neg(ctx, v5, v578);
                            let v580 = constructor_output_gpr(ctx, v579);
                            let v581 = Some(v580);
                            // Rule at src/isa/x64/lower.isle line 998.
                            return v581;
                        }
                        if v3 == I128 {
                            let v582 = C::put_in_regs(ctx, v577);
                            let v583 = constructor_value_regs_get_gpr(ctx, v582, 0x0_usize);
                            let v584 = constructor_value_regs_get_gpr(ctx, v582, 0x1_usize);
                            let v585 = &constructor_x64_neg_paired(ctx, I64, v583);
                            let v586 = constructor_imm(ctx, I64, 0x0_u64);
                            let v587 = C::gpr_new(ctx, v586);
                            let v588 = &C::gpr_to_gpr_mem_imm(ctx, v584);
                            let v589 = &constructor_x64_sbb_paired(ctx, I64, v587, v588);
                            let v590 = constructor_with_flags(ctx, v585, v589);
                            let v591 = C::output(ctx, v590);
                            let v592 = Some(v591);
                            // Rule at src/isa/x64/lower.isle line 1001.
                            return v592;
                        }
                    }
                }
                &Opcode::Iabs => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        match v3 {
                            I128 => {
                                let v582 = C::put_in_regs(ctx, v577);
                                let v583 = constructor_value_regs_get_gpr(ctx, v582, 0x0_usize);
                                let v584 = constructor_value_regs_get_gpr(ctx, v582, 0x1_usize);
                                let v585 = &constructor_x64_neg_paired(ctx, I64, v583);
                                let v586 = constructor_imm(ctx, I64, 0x0_u64);
                                let v839 = &constructor_reg_to_gpr_mem_imm(ctx, v586);
                                let v840 = &constructor_x64_adc_paired(ctx, I64, v584, v839);
                                let v841 = constructor_with_flags(ctx, v585, v840);
                                let v842 = C::value_regs_get(ctx, v841, 0x1_usize);
                                let v843 = C::gpr_new(ctx, v842);
                                let v844 = &constructor_x64_neg_paired(ctx, I64, v843);
                                let v845 = &constructor_produces_flags_ignore(ctx, v844);
                                let v846 = &C::gpr_to_gpr_mem(ctx, v583);
                                let v847 = C::value_regs_get(ctx, v841, 0x0_usize);
                                let v848 = C::gpr_new(ctx, v847);
                                let v849 = &constructor_cmove(ctx, I64, &CC::S, v846, v848);
                                let v850 = &C::gpr_to_gpr_mem(ctx, v584);
                                let v851 = constructor_produces_flags_get_reg(ctx, v844);
                                let v852 = C::gpr_new(ctx, v851);
                                let v853 = &constructor_cmove(ctx, I64, &CC::S, v850, v852);
                                let v854 = &constructor_consumes_flags_concat(ctx, v849, v853);
                                let v855 = constructor_with_flags(ctx, v845, v854);
                                let v856 = C::output(ctx, v855);
                                let v857 = Some(v856);
                                // Rule at src/isa/x64/lower.isle line 1372.
                                return v857;
                            }
                            I8X16 => {
                                let v772 = C::has_ssse3(ctx);
                                if v772 == true {
                                    let v773 = &C::put_in_xmm_mem(ctx, v577);
                                    let v774 = constructor_x64_pabsb_a_or_avx(ctx, v773);
                                    let v775 = constructor_output_xmm(ctx, v774);
                                    let v776 = Some(v775);
                                    // Rule at src/isa/x64/lower.isle line 1288.
                                    return v776;
                                }
                                let v777 = constructor_put_in_xmm(ctx, v577);
                                let v778 = constructor_xmm_zero(ctx, I8X16);
                                let v779 = &C::xmm_to_xmm_mem(ctx, v777);
                                let v780 = constructor_x64_psubb(ctx, v778, v779);
                                let v781 = &constructor_xmm_to_xmm_mem_aligned(ctx, v780);
                                let v782 = constructor_x64_pminub_a(ctx, v777, v781);
                                let v783 = constructor_output_xmm(ctx, v782);
                                let v784 = Some(v783);
                                // Rule at src/isa/x64/lower.isle line 1295.
                                return v784;
                            }
                            I16X8 => {
                                let v772 = C::has_ssse3(ctx);
                                if v772 == true {
                                    let v773 = &C::put_in_xmm_mem(ctx, v577);
                                    let v785 = constructor_x64_pabsw_a_or_avx(ctx, v773);
                                    let v786 = constructor_output_xmm(ctx, v785);
                                    let v787 = Some(v786);
                                    // Rule at src/isa/x64/lower.isle line 1302.
                                    return v787;
                                }
                                let v777 = constructor_put_in_xmm(ctx, v577);
                                let v788 = constructor_xmm_zero(ctx, I16X8);
                                let v779 = &C::xmm_to_xmm_mem(ctx, v777);
                                let v789 = constructor_x64_psubw(ctx, v788, v779);
                                let v790 = &constructor_xmm_to_xmm_mem_aligned(ctx, v789);
                                let v791 = constructor_x64_pmaxsw_a(ctx, v777, v790);
                                let v792 = constructor_output_xmm(ctx, v791);
                                let v793 = Some(v792);
                                // Rule at src/isa/x64/lower.isle line 1306.
                                return v793;
                            }
                            I32X4 => {
                                let v772 = C::has_ssse3(ctx);
                                if v772 == true {
                                    let v773 = &C::put_in_xmm_mem(ctx, v577);
                                    let v794 = constructor_x64_pabsd_a_or_avx(ctx, v773);
                                    let v795 = constructor_output_xmm(ctx, v794);
                                    let v796 = Some(v795);
                                    // Rule at src/isa/x64/lower.isle line 1313.
                                    return v796;
                                }
                                let v777 = constructor_put_in_xmm(ctx, v577);
                                let v798 = &C::xmi_imm(ctx, 0x1f_u32);
                                let v799 = constructor_x64_psrad(ctx, v777, v798);
                                let v800 = &C::xmm_to_xmm_mem(ctx, v799);
                                let v801 = constructor_x64_pxor(ctx, v777, v800);
                                let v802 = &C::xmm_to_xmm_mem(ctx, v799);
                                let v803 = constructor_x64_psubd(ctx, v801, v802);
                                let v804 = constructor_output_xmm(ctx, v803);
                                let v805 = Some(v804);
                                // Rule at src/isa/x64/lower.isle line 1323.
                                return v805;
                            }
                            I64X2 => {
                                let v520 = C::has_avx512vl(ctx);
                                if v520 == true {
                                    let v521 = C::has_avx512f(ctx);
                                    if v521 == true {
                                        let v773 = &C::put_in_xmm_mem(ctx, v577);
                                        let v806 = constructor_x64_vpabsq(ctx, v773);
                                        let v807 = constructor_output_xmm(ctx, v806);
                                        let v808 = Some(v807);
                                        // Rule at src/isa/x64/lower.isle line 1332.
                                        return v808;
                                    }
                                }
                                let v678 = C::has_sse41(ctx);
                                if v678 == true {
                                    let v777 = constructor_put_in_xmm(ctx, v577);
                                    let v809 = constructor_imm(ctx, I64X2, 0x0_u64);
                                    let v810 = C::xmm_new(ctx, v809);
                                    let v811 = &C::xmm_to_xmm_mem(ctx, v777);
                                    let v812 = constructor_x64_psubq(ctx, v810, v811);
                                    let v813 = &C::xmm_to_xmm_mem(ctx, v777);
                                    let v814 = constructor_x64_blendvpd(ctx, v812, v813, v812);
                                    let v815 = constructor_output_xmm(ctx, v814);
                                    let v816 = Some(v815);
                                    // Rule at src/isa/x64/lower.isle line 1341.
                                    return v816;
                                }
                                let v777 = constructor_put_in_xmm(ctx, v577);
                                let v817 = RegMemImm::Imm {
                                    simm32: 0x1f_u32,
                                };
                                let v818 = &C::xmm_mem_imm_new(ctx, &v817);
                                let v819 = constructor_x64_psrad(ctx, v777, v818);
                                let v820 = &C::xmm_to_xmm_mem(ctx, v819);
                                let v822 = constructor_x64_pshufd(ctx, v820, 0xf5_u8);
                                let v823 = &C::xmm_to_xmm_mem(ctx, v822);
                                let v824 = constructor_x64_pxor(ctx, v777, v823);
                                let v825 = &C::xmm_to_xmm_mem(ctx, v822);
                                let v826 = constructor_x64_psubq(ctx, v824, v825);
                                let v827 = constructor_output_xmm(ctx, v826);
                                let v828 = Some(v827);
                                // Rule at src/isa/x64/lower.isle line 1350.
                                return v828;
                            }
                            _ => {}
                        }
                        let v4 = C::fits_in_64(ctx, v3);
                        if let Some(v5) = v4 {
                            let v578 = constructor_put_in_gpr(ctx, v577);
                            let v829 = &constructor_x64_neg_paired(ctx, v5, v578);
                            let v830 = constructor_produces_flags_get_reg(ctx, v829);
                            let v831 = C::gpr_new(ctx, v830);
                            let v833 = &C::gpr_to_gpr_mem(ctx, v578);
                            let v834 = &constructor_cmove(ctx, v5, &CC::S, v833, v831);
                            let v835 = &constructor_produces_flags_ignore(ctx, v829);
                            let v836 = constructor_with_flags_reg(ctx, v835, v834);
                            let v837 = constructor_output_reg(ctx, v836);
                            let v838 = Some(v837);
                            // Rule at src/isa/x64/lower.isle line 1359.
                            return v838;
                        }
                    }
                }
                &Opcode::Bnot => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        if v3 == I128 {
                            let v913 = constructor_not_i128(ctx, v577);
                            let v914 = C::output(ctx, v913);
                            let v915 = Some(v914);
                            // Rule at src/isa/x64/lower.isle line 1490.
                            return v915;
                        }
                        let v89 = C::multi_lane(ctx, v3);
                        if let Some(v90) = v89 {
                            let v777 = constructor_put_in_xmm(ctx, v577);
                            let v870 = constructor_vector_all_ones(ctx);
                            let v916 = &C::xmm_to_xmm_mem(ctx, v870);
                            let v920 = constructor_x64_xor_vector(ctx, v3, v777, v916);
                            let v921 = constructor_output_xmm(ctx, v920);
                            let v922 = Some(v921);
                            // Rule at src/isa/x64/lower.isle line 1500.
                            return v922;
                        }
                        let v257 = C::ty_int_ref_scalar_64(ctx, v3);
                        if let Some(v258) = v257 {
                            let v578 = constructor_put_in_gpr(ctx, v577);
                            let v910 = constructor_x64_not(ctx, v3, v578);
                            let v911 = constructor_output_gpr(ctx, v910);
                            let v912 = Some(v911);
                            // Rule at src/isa/x64/lower.isle line 1475.
                            return v912;
                        }
                        let v270 = C::ty_scalar_float(ctx, v3);
                        if let Some(v271) = v270 {
                            let v777 = constructor_put_in_xmm(ctx, v577);
                            let v870 = constructor_vector_all_ones(ctx);
                            let v916 = &C::xmm_to_xmm_mem(ctx, v870);
                            let v917 = constructor_x64_xor_vector(ctx, v271, v777, v916);
                            let v918 = constructor_output_xmm(ctx, v917);
                            let v919 = Some(v918);
                            // Rule at src/isa/x64/lower.isle line 1495.
                            return v919;
                        }
                    }
                }
                &Opcode::Bitrev => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        match v3 {
                            I8 => {
                                let v578 = constructor_put_in_gpr(ctx, v577);
                                let v1694 = constructor_do_bitrev8(ctx, I32, v578);
                                let v1695 = constructor_output_gpr(ctx, v1694);
                                let v1696 = Some(v1695);
                                // Rule at src/isa/x64/lower.isle line 2520.
                                return v1696;
                            }
                            I16 => {
                                let v578 = constructor_put_in_gpr(ctx, v577);
                                let v1697 = constructor_do_bitrev16(ctx, I32, v578);
                                let v1698 = constructor_output_gpr(ctx, v1697);
                                let v1699 = Some(v1698);
                                // Rule at src/isa/x64/lower.isle line 2523.
                                return v1699;
                            }
                            I32 => {
                                let v578 = constructor_put_in_gpr(ctx, v577);
                                let v1700 = constructor_do_bitrev32(ctx, I32, v578);
                                let v1701 = constructor_output_gpr(ctx, v1700);
                                let v1702 = Some(v1701);
                                // Rule at src/isa/x64/lower.isle line 2526.
                                return v1702;
                            }
                            I64 => {
                                let v578 = constructor_put_in_gpr(ctx, v577);
                                let v1703 = constructor_do_bitrev64(ctx, I64, v578);
                                let v1704 = constructor_output_gpr(ctx, v1703);
                                let v1705 = Some(v1704);
                                // Rule at src/isa/x64/lower.isle line 2529.
                                return v1705;
                            }
                            I128 => {
                                let v582 = C::put_in_regs(ctx, v577);
                                let v1525 = constructor_value_regs_get_gpr(ctx, v582, 0x1_usize);
                                let v1706 = constructor_do_bitrev64(ctx, I64, v1525);
                                let v1707 = C::gpr_to_reg(ctx, v1706);
                                let v1616 = C::put_in_regs(ctx, v577);
                                let v1708 = constructor_value_regs_get_gpr(ctx, v1616, 0x0_usize);
                                let v1709 = constructor_do_bitrev64(ctx, I64, v1708);
                                let v1710 = C::gpr_to_reg(ctx, v1709);
                                let v1711 = C::value_regs(ctx, v1707, v1710);
                                let v1712 = C::output(ctx, v1711);
                                let v1713 = Some(v1712);
                                // Rule at src/isa/x64/lower.isle line 2532.
                                return v1713;
                            }
                            _ => {}
                        }
                    }
                }
                &Opcode::Clz => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        let v67 = C::ty_32_or_64(ctx, v3);
                        if let Some(v68) = v67 {
                            let v578 = constructor_put_in_gpr(ctx, v577);
                            let v1509 = constructor_do_clz(ctx, v68, v68, v578);
                            let v1510 = constructor_output_gpr(ctx, v1509);
                            let v1511 = Some(v1510);
                            // Rule at src/isa/x64/lower.isle line 2262.
                            return v1511;
                        }
                        let v1512 = C::ty_8_or_16(ctx, v3);
                        if let Some(v1513) = v1512 {
                            let v1514 = constructor_extend_to_gpr(ctx, v577, I64, &ExtendKind::Zero);
                            let v1515 = constructor_do_clz(ctx, I64, I64, v1514);
                            let v1517 = C::ty_bits(ctx, v1513);
                            let v1518 = C::u8_into_u32(ctx, v1517);
                            let v1519 = C::u32_wrapping_sub(ctx, 0x40_u32, v1518);
                            let v1520 = RegMemImm::Imm {
                                simm32: v1519,
                            };
                            let v1521 = &C::gpr_mem_imm_new(ctx, &v1520);
                            let v1522 = constructor_x64_sub(ctx, I64, v1515, v1521);
                            let v1523 = constructor_output_gpr(ctx, v1522);
                            let v1524 = Some(v1523);
                            // Rule at src/isa/x64/lower.isle line 2265.
                            return v1524;
                        }
                        if v3 == I128 {
                            let v582 = C::put_in_regs(ctx, v577);
                            let v1525 = constructor_value_regs_get_gpr(ctx, v582, 0x1_usize);
                            let v1526 = constructor_do_clz(ctx, I64, I64, v1525);
                            let v1527 = C::put_in_regs(ctx, v577);
                            let v1528 = constructor_value_regs_get_gpr(ctx, v1527, 0x0_usize);
                            let v1529 = constructor_do_clz(ctx, I64, I64, v1528);
                            let v1530 = RegMemImm::Imm {
                                simm32: 0x40_u32,
                            };
                            let v1531 = &C::gpr_mem_imm_new(ctx, &v1530);
                            let v1532 = constructor_x64_add(ctx, I64, v1529, v1531);
                            let v1533 = &C::gpr_to_gpr_mem(ctx, v1526);
                            let v1535 = &constructor_x64_cmpq_mi_sxb(ctx, v1533, 64_i8);
                            let v1537 = &C::gpr_to_gpr_mem(ctx, v1526);
                            let v1538 = &constructor_cmove(ctx, I64, &CC::NZ, v1537, v1532);
                            let v1539 = constructor_with_flags_reg(ctx, v1535, v1538);
                            let v1540 = C::gpr_new(ctx, v1539);
                            let v1541 = C::gpr_to_reg(ctx, v1540);
                            let v1542 = constructor_imm(ctx, I64, 0x0_u64);
                            let v1543 = C::value_regs(ctx, v1541, v1542);
                            let v1544 = C::output(ctx, v1543);
                            let v1545 = Some(v1544);
                            // Rule at src/isa/x64/lower.isle line 2271.
                            return v1545;
                        }
                    }
                }
                &Opcode::Cls => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        let v67 = C::ty_32_or_64(ctx, v3);
                        if let Some(v68) = v67 {
                            let v578 = constructor_put_in_gpr(ctx, v577);
                            let v1573 = constructor_do_cls(ctx, v68, v578);
                            let v1574 = constructor_output_gpr(ctx, v1573);
                            let v1575 = Some(v1574);
                            // Rule at src/isa/x64/lower.isle line 2336.
                            return v1575;
                        }
                        let v1512 = C::ty_8_or_16(ctx, v3);
                        if let Some(v1513) = v1512 {
                            let v1576 = constructor_extend_to_gpr(ctx, v577, I32, &ExtendKind::Sign);
                            let v1577 = constructor_do_cls(ctx, I32, v1576);
                            let v1517 = C::ty_bits(ctx, v1513);
                            let v1518 = C::u8_into_u32(ctx, v1517);
                            let v1578 = C::u32_wrapping_sub(ctx, 0x20_u32, v1518);
                            let v1579 = RegMemImm::Imm {
                                simm32: v1578,
                            };
                            let v1580 = &C::gpr_mem_imm_new(ctx, &v1579);
                            let v1581 = constructor_x64_sub(ctx, I32, v1577, v1580);
                            let v1582 = constructor_output_gpr(ctx, v1581);
                            let v1583 = Some(v1582);
                            // Rule at src/isa/x64/lower.isle line 2339.
                            return v1583;
                        }
                        if v3 == I128 {
                            let v582 = C::put_in_regs(ctx, v577);
                            let v1525 = constructor_value_regs_get_gpr(ctx, v582, 0x1_usize);
                            let v1584 = constructor_do_cls(ctx, I64, v1525);
                            let v1527 = C::put_in_regs(ctx, v577);
                            let v1559 = constructor_value_regs_get_gpr(ctx, v1527, 0x1_usize);
                            let v1585 = constructor_x64_sarq_mi(ctx, v1559, 0x3f_u8);
                            let v1586 = C::put_in_regs(ctx, v577);
                            let v1587 = constructor_value_regs_get_gpr(ctx, v1586, 0x0_usize);
                            let v1588 = &C::gpr_to_gpr_mem_imm(ctx, v1585);
                            let v1589 = constructor_x64_xor(ctx, I64, v1587, v1588);
                            let v1590 = constructor_do_clz(ctx, I64, I64, v1589);
                            let v548 = RegMemImm::Imm {
                                simm32: 0x3f_u32,
                            };
                            let v1591 = &C::gpr_mem_imm_new(ctx, &v548);
                            let v1592 = constructor_x64_add(ctx, I64, v1590, v1591);
                            let v1593 = &C::gpr_to_gpr_mem(ctx, v1584);
                            let v1595 = &constructor_x64_cmpq_mi_sxb(ctx, v1593, 63_i8);
                            let v1596 = &C::gpr_to_gpr_mem(ctx, v1584);
                            let v1597 = &constructor_cmove(ctx, I64, &CC::NZ, v1596, v1592);
                            let v1598 = constructor_with_flags_reg(ctx, v1595, v1597);
                            let v1599 = C::gpr_new(ctx, v1598);
                            let v1600 = C::gpr_to_reg(ctx, v1599);
                            let v1601 = constructor_imm(ctx, I64, 0x0_u64);
                            let v1602 = C::value_regs(ctx, v1600, v1601);
                            let v1603 = C::output(ctx, v1602);
                            let v1604 = Some(v1603);
                            // Rule at src/isa/x64/lower.isle line 2344.
                            return v1604;
                        }
                    }
                }
                &Opcode::Ctz => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        let v67 = C::ty_32_or_64(ctx, v3);
                        if let Some(v68) = v67 {
                            let v578 = constructor_put_in_gpr(ctx, v577);
                            let v1546 = constructor_do_ctz(ctx, v68, v68, v578);
                            let v1547 = constructor_output_gpr(ctx, v1546);
                            let v1548 = Some(v1547);
                            // Rule at src/isa/x64/lower.isle line 2302.
                            return v1548;
                        }
                        let v1512 = C::ty_8_or_16(ctx, v3);
                        if let Some(v1513) = v1512 {
                            let v1550 = constructor_extend_to_gpr(ctx, v577, I32, &ExtendKind::Zero);
                            let v1517 = C::ty_bits(ctx, v1513);
                            let v1518 = C::u8_into_u32(ctx, v1517);
                            let v1551 = C::u32_wrapping_shl(ctx, 0x1_u32, v1518);
                            let v1552 = RegMemImm::Imm {
                                simm32: v1551,
                            };
                            let v1553 = &C::gpr_mem_imm_new(ctx, &v1552);
                            let v1554 = constructor_x64_or(ctx, I32, v1550, v1553);
                            let v1555 = constructor_do_ctz(ctx, I32, v1513, v1554);
                            let v1556 = constructor_output_gpr(ctx, v1555);
                            let v1557 = Some(v1556);
                            // Rule at src/isa/x64/lower.isle line 2305.
                            return v1557;
                        }
                        if v3 == I128 {
                            let v582 = C::put_in_regs(ctx, v577);
                            let v583 = constructor_value_regs_get_gpr(ctx, v582, 0x0_usize);
                            let v1558 = constructor_do_ctz(ctx, I64, I64, v583);
                            let v1527 = C::put_in_regs(ctx, v577);
                            let v1559 = constructor_value_regs_get_gpr(ctx, v1527, 0x1_usize);
                            let v1560 = constructor_do_ctz(ctx, I64, I64, v1559);
                            let v1530 = RegMemImm::Imm {
                                simm32: 0x40_u32,
                            };
                            let v1531 = &C::gpr_mem_imm_new(ctx, &v1530);
                            let v1561 = constructor_x64_add(ctx, I64, v1560, v1531);
                            let v1562 = &C::gpr_to_gpr_mem(ctx, v1558);
                            let v1563 = &constructor_x64_cmpq_mi_sxb(ctx, v1562, 64_i8);
                            let v1565 = &C::gpr_to_gpr_mem(ctx, v1561);
                            let v1566 = &constructor_cmove(ctx, I64, &CC::Z, v1565, v1558);
                            let v1567 = constructor_with_flags_reg(ctx, v1563, v1566);
                            let v1568 = C::gpr_new(ctx, v1567);
                            let v1569 = C::gpr_to_reg(ctx, v1568);
                            let v1542 = constructor_imm(ctx, I64, 0x0_u64);
                            let v1570 = C::value_regs(ctx, v1569, v1542);
                            let v1571 = C::output(ctx, v1570);
                            let v1572 = Some(v1571);
                            // Rule at src/isa/x64/lower.isle line 2310.
                            return v1572;
                        }
                    }
                }
                &Opcode::Bswap => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        match v3 {
                            I16 => {
                                let v578 = constructor_put_in_gpr(ctx, v577);
                                let v1714 = constructor_x64_rolw_mi(ctx, v578, 0x8_u8);
                                let v1715 = constructor_output_gpr(ctx, v1714);
                                let v1716 = Some(v1715);
                                // Rule at src/isa/x64/lower.isle line 2599.
                                return v1716;
                            }
                            I32 => {
                                let v578 = constructor_put_in_gpr(ctx, v577);
                                let v1717 = constructor_x64_bswap(ctx, I32, v578);
                                let v1718 = constructor_output_gpr(ctx, v1717);
                                let v1719 = Some(v1718);
                                // Rule at src/isa/x64/lower.isle line 2602.
                                return v1719;
                            }
                            I64 => {
                                let v578 = constructor_put_in_gpr(ctx, v577);
                                let v1720 = constructor_x64_bswap(ctx, I64, v578);
                                let v1721 = constructor_output_gpr(ctx, v1720);
                                let v1722 = Some(v1721);
                                // Rule at src/isa/x64/lower.isle line 2605.
                                return v1722;
                            }
                            I128 => {
                                let v582 = C::put_in_regs(ctx, v577);
                                let v1525 = constructor_value_regs_get_gpr(ctx, v582, 0x1_usize);
                                let v1723 = constructor_x64_bswap(ctx, I64, v1525);
                                let v1724 = C::gpr_to_reg(ctx, v1723);
                                let v1616 = C::put_in_regs(ctx, v577);
                                let v1708 = constructor_value_regs_get_gpr(ctx, v1616, 0x0_usize);
                                let v1725 = constructor_x64_bswap(ctx, I64, v1708);
                                let v1726 = C::gpr_to_reg(ctx, v1725);
                                let v1727 = C::value_regs(ctx, v1724, v1726);
                                let v1728 = C::output(ctx, v1727);
                                let v1729 = Some(v1728);
                                // Rule at src/isa/x64/lower.isle line 2608.
                                return v1729;
                            }
                            _ => {}
                        }
                    }
                }
                &Opcode::Popcnt => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v1605 = C::use_popcnt(ctx);
                        if v1605 == true {
                            let v3 = C::value_type(ctx, v2);
                            let v67 = C::ty_32_or_64(ctx, v3);
                            if let Some(v68) = v67 {
                                let v1606 = &constructor_put_in_gpr_mem(ctx, v577);
                                let v1607 = constructor_x64_popcnt(ctx, v68, v1606);
                                let v1608 = constructor_output_gpr(ctx, v1607);
                                let v1609 = Some(v1608);
                                // Rule at src/isa/x64/lower.isle line 2371.
                                return v1609;
                            }
                            let v1512 = C::ty_8_or_16(ctx, v3);
                            if let Some(v1513) = v1512 {
                                let v1550 = constructor_extend_to_gpr(ctx, v577, I32, &ExtendKind::Zero);
                                let v1610 = &C::gpr_to_gpr_mem(ctx, v1550);
                                let v1611 = constructor_x64_popcnt(ctx, I32, v1610);
                                let v1612 = constructor_output_gpr(ctx, v1611);
                                let v1613 = Some(v1612);
                                // Rule at src/isa/x64/lower.isle line 2375.
                                return v1613;
                            }
                        }
                        let v3 = C::value_type(ctx, v2);
                        match v3 {
                            I128 => {
                                if v1605 == true {
                                    let v582 = C::put_in_regs(ctx, v577);
                                    let v583 = constructor_value_regs_get_gpr(ctx, v582, 0x0_usize);
                                    let v1614 = &C::gpr_to_gpr_mem(ctx, v583);
                                    let v1615 = constructor_x64_popcnt(ctx, I64, v1614);
                                    let v1616 = C::put_in_regs(ctx, v577);
                                    let v1617 = constructor_value_regs_get_gpr(ctx, v1616, 0x1_usize);
                                    let v1618 = &C::gpr_to_gpr_mem(ctx, v1617);
                                    let v1619 = constructor_x64_popcnt(ctx, I64, v1618);
                                    let v1620 = &C::gpr_to_gpr_mem_imm(ctx, v1619);
                                    let v1621 = constructor_x64_add(ctx, I64, v1615, v1620);
                                    let v1622 = C::gpr_to_reg(ctx, v1621);
                                    let v1623 = constructor_imm(ctx, I64, 0x0_u64);
                                    let v1624 = C::value_regs(ctx, v1622, v1623);
                                    let v1625 = C::output(ctx, v1624);
                                    let v1626 = Some(v1625);
                                    // Rule at src/isa/x64/lower.isle line 2379.
                                    return v1626;
                                }
                                let v582 = C::put_in_regs(ctx, v577);
                                let v583 = constructor_value_regs_get_gpr(ctx, v582, 0x0_usize);
                                let v1633 = constructor_do_popcnt(ctx, I64, v583);
                                let v1527 = C::put_in_regs(ctx, v577);
                                let v1559 = constructor_value_regs_get_gpr(ctx, v1527, 0x1_usize);
                                let v1634 = constructor_do_popcnt(ctx, I64, v1559);
                                let v1635 = &C::gpr_to_gpr_mem_imm(ctx, v1634);
                                let v1636 = constructor_x64_add(ctx, I64, v1633, v1635);
                                let v1637 = C::gpr_to_reg(ctx, v1636);
                                let v1638 = constructor_imm(ctx, I64, 0x0_u64);
                                let v1639 = C::value_regs(ctx, v1637, v1638);
                                let v1640 = C::output(ctx, v1639);
                                let v1641 = Some(v1640);
                                // Rule at src/isa/x64/lower.isle line 2395.
                                return v1641;
                            }
                            I8X16 => {
                                let v520 = C::has_avx512vl(ctx);
                                if v520 == true {
                                    let v1642 = C::has_avx512bitalg(ctx);
                                    if v1642 == true {
                                        let v773 = &C::put_in_xmm_mem(ctx, v577);
                                        let v1643 = constructor_x64_vpopcntb(ctx, v773);
                                        let v1644 = constructor_output_xmm(ctx, v1643);
                                        let v1645 = Some(v1644);
                                        // Rule at src/isa/x64/lower.isle line 2464.
                                        return v1645;
                                    }
                                }
                                let v772 = C::has_ssse3(ctx);
                                if v772 == true {
                                    let v1647 = C::emit_u128_le_const(ctx, 0xf0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f_u128);
                                    let v1648 = &constructor_const_to_xmm_mem(ctx, v1647);
                                    let v1649 = constructor_put_in_xmm(ctx, v577);
                                    let v1650 = constructor_sse_and(ctx, I8X16, v1649, v1648);
                                    let v1651 = constructor_put_in_xmm(ctx, v577);
                                    let v1653 = &C::xmi_imm(ctx, 0x4_u32);
                                    let v1654 = constructor_x64_psrlw(ctx, v1651, v1653);
                                    let v1655 = constructor_sse_and(ctx, I8X16, v1654, v1648);
                                    let v1657 = C::emit_u128_le_const(ctx, 0x4030302030202010302020102010100_u128);
                                    let v1658 = constructor_x64_xmm_load_const(ctx, I8X16, v1657);
                                    let v1659 = &C::xmm_to_xmm_mem(ctx, v1650);
                                    let v1660 = constructor_x64_pshufb(ctx, v1658, v1659);
                                    let v1661 = &C::xmm_to_xmm_mem(ctx, v1655);
                                    let v1662 = constructor_x64_pshufb(ctx, v1658, v1661);
                                    let v1663 = &C::xmm_to_xmm_mem(ctx, v1662);
                                    let v1664 = constructor_x64_paddb(ctx, v1660, v1663);
                                    let v1665 = constructor_output_xmm(ctx, v1664);
                                    let v1666 = Some(v1665);
                                    // Rule at src/isa/x64/lower.isle line 2490.
                                    return v1666;
                                }
                                let v1668 = C::emit_u128_le_const(ctx, 0x77777777777777777777777777777777_u128);
                                let v1669 = &constructor_const_to_xmm_mem(ctx, v1668);
                                let v1649 = constructor_put_in_xmm(ctx, v577);
                                let v1670 = &C::xmi_imm(ctx, 0x1_u32);
                                let v1671 = constructor_x64_psrlq(ctx, v1649, v1670);
                                let v1672 = constructor_x64_pand(ctx, v1671, v1669);
                                let v1673 = &C::xmm_to_xmm_mem(ctx, v1672);
                                let v1674 = constructor_x64_psubb(ctx, v1649, v1673);
                                let v1675 = &C::xmi_imm(ctx, 0x1_u32);
                                let v1676 = constructor_x64_psrlq(ctx, v1672, v1675);
                                let v1677 = constructor_x64_pand(ctx, v1676, v1669);
                                let v1678 = &C::xmm_to_xmm_mem(ctx, v1677);
                                let v1679 = constructor_x64_psubb(ctx, v1674, v1678);
                                let v1680 = &C::xmi_imm(ctx, 0x1_u32);
                                let v1681 = constructor_x64_psrlq(ctx, v1677, v1680);
                                let v1682 = constructor_x64_pand(ctx, v1681, v1669);
                                let v1683 = &C::xmm_to_xmm_mem(ctx, v1682);
                                let v1684 = constructor_x64_psubb(ctx, v1679, v1683);
                                let v1685 = &C::xmi_imm(ctx, 0x4_u32);
                                let v1686 = constructor_x64_psrlw(ctx, v1684, v1685);
                                let v1687 = &C::xmm_to_xmm_mem(ctx, v1686);
                                let v1688 = constructor_x64_paddb(ctx, v1684, v1687);
                                let v1689 = C::emit_u128_le_const(ctx, 0xf0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f_u128);
                                let v1690 = &constructor_const_to_xmm_mem(ctx, v1689);
                                let v1691 = constructor_x64_pand(ctx, v1688, v1690);
                                let v1692 = constructor_output_xmm(ctx, v1691);
                                let v1693 = Some(v1692);
                                // Rule at src/isa/x64/lower.isle line 2506.
                                return v1693;
                            }
                            _ => {}
                        }
                        let v67 = C::ty_32_or_64(ctx, v3);
                        if let Some(v68) = v67 {
                            let v578 = constructor_put_in_gpr(ctx, v577);
                            let v1627 = constructor_do_popcnt(ctx, v68, v578);
                            let v1628 = constructor_output_gpr(ctx, v1627);
                            let v1629 = Some(v1628);
                            // Rule at src/isa/x64/lower.isle line 2385.
                            return v1629;
                        }
                        let v1512 = C::ty_8_or_16(ctx, v3);
                        if let Some(v1513) = v1512 {
                            let v1550 = constructor_extend_to_gpr(ctx, v577, I32, &ExtendKind::Zero);
                            let v1630 = constructor_do_popcnt(ctx, I32, v1550);
                            let v1631 = constructor_output_gpr(ctx, v1630);
                            let v1632 = Some(v1631);
                            // Rule at src/isa/x64/lower.isle line 2390.
                            return v1632;
                        }
                    }
                }
                &Opcode::Sqrt => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        match v3 {
                            F32 => {
                                let v1838 = constructor_xmm_zero(ctx, F32X4);
                                let v1839 = &C::put_in_xmm_mem(ctx, v577);
                                let v1840 = constructor_x64_sqrtss(ctx, v1838, v1839);
                                let v1841 = constructor_output_xmm(ctx, v1840);
                                let v1842 = Some(v1841);
                                // Rule at src/isa/x64/lower.isle line 2738.
                                return v1842;
                            }
                            F64 => {
                                let v1844 = constructor_xmm_zero(ctx, F64X2);
                                let v1839 = &C::put_in_xmm_mem(ctx, v577);
                                let v1845 = constructor_x64_sqrtsd(ctx, v1844, v1839);
                                let v1846 = constructor_output_xmm(ctx, v1845);
                                let v1847 = Some(v1846);
                                // Rule at src/isa/x64/lower.isle line 2740.
                                return v1847;
                            }
                            F32X4 => {
                                let v773 = &C::put_in_xmm_mem(ctx, v577);
                                let v1848 = constructor_x64_sqrtps(ctx, v773);
                                let v1849 = constructor_output_xmm(ctx, v1848);
                                let v1850 = Some(v1849);
                                // Rule at src/isa/x64/lower.isle line 2742.
                                return v1850;
                            }
                            F64X2 => {
                                let v773 = &C::put_in_xmm_mem(ctx, v577);
                                let v1851 = constructor_x64_sqrtpd(ctx, v773);
                                let v1852 = constructor_output_xmm(ctx, v1851);
                                let v1853 = Some(v1852);
                                // Rule at src/isa/x64/lower.isle line 2744.
                                return v1853;
                            }
                            _ => {}
                        }
                    }
                }
                &Opcode::Fneg => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        match v3 {
                            F32 => {
                                let v777 = constructor_put_in_xmm(ctx, v577);
                                let v883 = constructor_imm(ctx, F32, 0x80000000_u64);
                                let v884 = &constructor_reg_to_xmm_mem(ctx, v883);
                                let v885 = constructor_x64_xorps(ctx, v777, v884);
                                let v886 = constructor_output_xmm(ctx, v885);
                                let v887 = Some(v886);
                                // Rule at src/isa/x64/lower.isle line 1412.
                                return v887;
                            }
                            F64 => {
                                let v777 = constructor_put_in_xmm(ctx, v577);
                                let v889 = constructor_imm(ctx, F64, 0x8000000000000000_u64);
                                let v890 = &constructor_reg_to_xmm_mem(ctx, v889);
                                let v891 = constructor_x64_xorpd(ctx, v777, v890);
                                let v892 = constructor_output_xmm(ctx, v891);
                                let v893 = Some(v892);
                                // Rule at src/isa/x64/lower.isle line 1415.
                                return v893;
                            }
                            F32X4 => {
                                let v777 = constructor_put_in_xmm(ctx, v577);
                                let v870 = constructor_vector_all_ones(ctx);
                                let v894 = &C::xmi_imm(ctx, 0x1f_u32);
                                let v895 = constructor_x64_pslld(ctx, v870, v894);
                                let v896 = &C::xmm_to_xmm_mem(ctx, v895);
                                let v897 = constructor_x64_xorps(ctx, v777, v896);
                                let v898 = constructor_output_xmm(ctx, v897);
                                let v899 = Some(v898);
                                // Rule at src/isa/x64/lower.isle line 1418.
                                return v899;
                            }
                            F64X2 => {
                                let v777 = constructor_put_in_xmm(ctx, v577);
                                let v870 = constructor_vector_all_ones(ctx);
                                let v900 = &C::xmi_imm(ctx, 0x3f_u32);
                                let v901 = constructor_x64_psllq(ctx, v870, v900);
                                let v902 = &C::xmm_to_xmm_mem(ctx, v901);
                                let v903 = constructor_x64_xorpd(ctx, v777, v902);
                                let v904 = constructor_output_xmm(ctx, v903);
                                let v905 = Some(v904);
                                // Rule at src/isa/x64/lower.isle line 1422.
                                return v905;
                            }
                            _ => {}
                        }
                    }
                }
                &Opcode::Fabs => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        match v3 {
                            F32 => {
                                let v777 = constructor_put_in_xmm(ctx, v577);
                                let v859 = constructor_imm(ctx, F32, 0x7fffffff_u64);
                                let v860 = &constructor_reg_to_xmm_mem(ctx, v859);
                                let v861 = constructor_x64_andps(ctx, v777, v860);
                                let v862 = constructor_output_xmm(ctx, v861);
                                let v863 = Some(v862);
                                // Rule at src/isa/x64/lower.isle line 1394.
                                return v863;
                            }
                            F64 => {
                                let v777 = constructor_put_in_xmm(ctx, v577);
                                let v865 = constructor_imm(ctx, F64, 0x7fffffffffffffff_u64);
                                let v866 = &constructor_reg_to_xmm_mem(ctx, v865);
                                let v867 = constructor_x64_andpd(ctx, v777, v866);
                                let v868 = constructor_output_xmm(ctx, v867);
                                let v869 = Some(v868);
                                // Rule at src/isa/x64/lower.isle line 1397.
                                return v869;
                            }
                            F32X4 => {
                                let v777 = constructor_put_in_xmm(ctx, v577);
                                let v870 = constructor_vector_all_ones(ctx);
                                let v871 = &C::xmi_imm(ctx, 0x1_u32);
                                let v872 = constructor_x64_psrld(ctx, v870, v871);
                                let v873 = &C::xmm_to_xmm_mem(ctx, v872);
                                let v874 = constructor_x64_andps(ctx, v777, v873);
                                let v875 = constructor_output_xmm(ctx, v874);
                                let v876 = Some(v875);
                                // Rule at src/isa/x64/lower.isle line 1401.
                                return v876;
                            }
                            F64X2 => {
                                let v777 = constructor_put_in_xmm(ctx, v577);
                                let v870 = constructor_vector_all_ones(ctx);
                                let v871 = &C::xmi_imm(ctx, 0x1_u32);
                                let v877 = constructor_x64_psrlq(ctx, v870, v871);
                                let v878 = &C::xmm_to_xmm_mem(ctx, v877);
                                let v879 = constructor_x64_andpd(ctx, v777, v878);
                                let v880 = constructor_output_xmm(ctx, v879);
                                let v881 = Some(v880);
                                // Rule at src/isa/x64/lower.isle line 1406.
                                return v881;
                            }
                            _ => {}
                        }
                    }
                }
                &Opcode::Ceil => {
                    let v2978 = &C::put_in_reg_mem(ctx, v577);
                    let v906 = C::value_type(ctx, v577);
                    let v2980 = constructor_x64_round(ctx, v906, v2978, &RoundImm::RoundUp);
                    let v2981 = constructor_output_xmm(ctx, v2980);
                    let v2982 = Some(v2981);
                    // Rule at src/isa/x64/lower.isle line 4371.
                    return v2982;
                }
                &Opcode::Floor => {
                    let v2978 = &C::put_in_reg_mem(ctx, v577);
                    let v906 = C::value_type(ctx, v577);
                    let v2984 = constructor_x64_round(ctx, v906, v2978, &RoundImm::RoundDown);
                    let v2985 = constructor_output_xmm(ctx, v2984);
                    let v2986 = Some(v2985);
                    // Rule at src/isa/x64/lower.isle line 4376.
                    return v2986;
                }
                &Opcode::Trunc => {
                    let v2978 = &C::put_in_reg_mem(ctx, v577);
                    let v906 = C::value_type(ctx, v577);
                    let v2992 = constructor_x64_round(ctx, v906, v2978, &RoundImm::RoundZero);
                    let v2993 = constructor_output_xmm(ctx, v2992);
                    let v2994 = Some(v2993);
                    // Rule at src/isa/x64/lower.isle line 4386.
                    return v2994;
                }
                &Opcode::Nearest => {
                    let v2978 = &C::put_in_reg_mem(ctx, v577);
                    let v906 = C::value_type(ctx, v577);
                    let v2988 = constructor_x64_round(ctx, v906, v2978, &RoundImm::RoundNearest);
                    let v2989 = constructor_output_xmm(ctx, v2988);
                    let v2990 = Some(v2989);
                    // Rule at src/isa/x64/lower.isle line 4381.
                    return v2990;
                }
                &Opcode::ScalarToVector => {
                    let v3301 = &C::sinkable_load(ctx, v577);
                    if let Some(v3302) = v3301 {
                        let v906 = C::value_type(ctx, v577);
                        let v3309 = C::ty_64(ctx, v906);
                        if let Some(v3310) = v3309 {
                            let v3305 = &C::sink_load(ctx, v3302);
                            let v3311 = constructor_x64_movsd_load(ctx, v3305);
                            let v3312 = constructor_output_xmm(ctx, v3311);
                            let v3313 = Some(v3312);
                            // Rule at src/isa/x64/lower.isle line 4816.
                            return v3313;
                        }
                        let v3303 = C::ty_32(ctx, v906);
                        if let Some(v3304) = v3303 {
                            let v3305 = &C::sink_load(ctx, v3302);
                            let v3306 = constructor_x64_movss_load(ctx, v3305);
                            let v3307 = constructor_output_xmm(ctx, v3306);
                            let v3308 = Some(v3307);
                            // Rule at src/isa/x64/lower.isle line 4814.
                            return v3308;
                        }
                    }
                    let v906 = C::value_type(ctx, v577);
                    match v906 {
                        F32 => {
                            let v1838 = constructor_xmm_zero(ctx, F32X4);
                            let v3290 = constructor_put_in_xmm(ctx, v577);
                            let v3291 = constructor_x64_movss_regmove(ctx, v1838, v3290);
                            let v3292 = constructor_output_xmm(ctx, v3291);
                            let v3293 = Some(v3292);
                            // Rule at src/isa/x64/lower.isle line 4802.
                            return v3293;
                        }
                        F64 => {
                            let v1844 = constructor_xmm_zero(ctx, F64X2);
                            let v3290 = constructor_put_in_xmm(ctx, v577);
                            let v3294 = constructor_x64_movsd_regmove(ctx, v1844, v3290);
                            let v3295 = constructor_output_xmm(ctx, v3294);
                            let v3296 = Some(v3295);
                            // Rule at src/isa/x64/lower.isle line 4804.
                            return v3296;
                        }
                        _ => {}
                    }
                    let v578 = constructor_put_in_gpr(ctx, v577);
                    let v3297 = C::ty_bits(ctx, v906);
                    let v3298 = constructor_bitcast_gpr_to_xmm(ctx, v3297, v578);
                    let v3299 = constructor_output_xmm(ctx, v3298);
                    let v3300 = Some(v3299);
                    // Rule at src/isa/x64/lower.isle line 4809.
                    return v3300;
                }
                &Opcode::Bmask => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v582 = C::put_in_regs(ctx, v577);
                        let v3 = C::value_type(ctx, v2);
                        let v906 = C::value_type(ctx, v577);
                        let v907 = constructor_lower_bmask(ctx, v3, v906, v582);
                        let v908 = C::output(ctx, v907);
                        let v909 = Some(v908);
                        // Rule at src/isa/x64/lower.isle line 1468.
                        return v909;
                    }
                }
                &Opcode::Ireduce => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        let v4 = C::fits_in_64(ctx, v3);
                        if let Some(v5) = v4 {
                            let v582 = C::put_in_regs(ctx, v577);
                            let v583 = constructor_value_regs_get_gpr(ctx, v582, 0x0_usize);
                            let v1754 = constructor_output_gpr(ctx, v583);
                            let v1755 = Some(v1754);
                            // Rule at src/isa/x64/lower.isle line 2657.
                            return v1755;
                        }
                        let v906 = C::value_type(ctx, v577);
                        if v3 == v906 {
                            let v1752 = constructor_output_value(ctx, v577);
                            let v1753 = Some(v1752);
                            // Rule at src/isa/x64/lower.isle line 2651.
                            return v1753;
                        }
                    }
                }
                &Opcode::SwidenLow => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        match v3 {
                            I16X8 => {
                                let v678 = C::has_sse41(ctx);
                                if v678 == true {
                                    let v906 = C::value_type(ctx, v577);
                                    if v906 == I8X16 {
                                        let v773 = &C::put_in_xmm_mem(ctx, v577);
                                        let v2829 = constructor_x64_pmovsxbw(ctx, v773);
                                        let v2830 = constructor_output_xmm(ctx, v2829);
                                        let v2831 = Some(v2830);
                                        // Rule at src/isa/x64/lower.isle line 4084.
                                        return v2831;
                                    }
                                }
                            }
                            I32X4 => {
                                let v678 = C::has_sse41(ctx);
                                if v678 == true {
                                    let v906 = C::value_type(ctx, v577);
                                    if v906 == I16X8 {
                                        let v773 = &C::put_in_xmm_mem(ctx, v577);
                                        let v2832 = constructor_x64_pmovsxwd(ctx, v773);
                                        let v2833 = constructor_output_xmm(ctx, v2832);
                                        let v2834 = Some(v2833);
                                        // Rule at src/isa/x64/lower.isle line 4087.
                                        return v2834;
                                    }
                                }
                            }
                            I64X2 => {
                                let v678 = C::has_sse41(ctx);
                                if v678 == true {
                                    let v906 = C::value_type(ctx, v577);
                                    if v906 == I32X4 {
                                        let v773 = &C::put_in_xmm_mem(ctx, v577);
                                        let v2835 = constructor_x64_pmovsxdq(ctx, v773);
                                        let v2836 = constructor_output_xmm(ctx, v2835);
                                        let v2837 = Some(v2836);
                                        // Rule at src/isa/x64/lower.isle line 4090.
                                        return v2837;
                                    }
                                }
                            }
                            _ => {}
                        }
                        let v777 = constructor_put_in_xmm(ctx, v577);
                        let v2838 = constructor_lower_swiden_low(ctx, v3, v777);
                        let v2839 = constructor_output_xmm(ctx, v2838);
                        let v2840 = Some(v2839);
                        // Rule at src/isa/x64/lower.isle line 4094.
                        return v2840;
                    }
                }
                &Opcode::SwidenHigh => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        match v3 {
                            I16X8 => {
                                let v906 = C::value_type(ctx, v577);
                                if v906 == I8X16 {
                                    let v678 = C::has_sse41(ctx);
                                    if v678 == true {
                                        let v772 = C::has_ssse3(ctx);
                                        if v772 == true {
                                            let v777 = constructor_put_in_xmm(ctx, v577);
                                            let v1857 = &C::xmm_to_xmm_mem(ctx, v777);
                                            let v2841 = constructor_x64_palignr(ctx, v777, v1857, 0x8_u8);
                                            let v2842 = &C::xmm_to_xmm_mem(ctx, v2841);
                                            let v2843 = constructor_x64_pmovsxbw(ctx, v2842);
                                            let v2844 = constructor_output_xmm(ctx, v2843);
                                            let v2845 = Some(v2844);
                                            // Rule at src/isa/x64/lower.isle line 4117.
                                            return v2845;
                                        }
                                    }
                                    let v777 = constructor_put_in_xmm(ctx, v577);
                                    let v1857 = &C::xmm_to_xmm_mem(ctx, v777);
                                    let v2854 = constructor_x64_punpckhbw(ctx, v777, v1857);
                                    let v2855 = &C::xmi_imm(ctx, 0x8_u32);
                                    let v2856 = constructor_x64_psraw(ctx, v2854, v2855);
                                    let v2857 = constructor_output_xmm(ctx, v2856);
                                    let v2858 = Some(v2857);
                                    // Rule at src/isa/x64/lower.isle line 4133.
                                    return v2858;
                                }
                            }
                            I32X4 => {
                                let v906 = C::value_type(ctx, v577);
                                if v906 == I16X8 {
                                    let v678 = C::has_sse41(ctx);
                                    if v678 == true {
                                        let v772 = C::has_ssse3(ctx);
                                        if v772 == true {
                                            let v777 = constructor_put_in_xmm(ctx, v577);
                                            let v1857 = &C::xmm_to_xmm_mem(ctx, v777);
                                            let v2841 = constructor_x64_palignr(ctx, v777, v1857, 0x8_u8);
                                            let v2842 = &C::xmm_to_xmm_mem(ctx, v2841);
                                            let v2846 = constructor_x64_pmovsxwd(ctx, v2842);
                                            let v2847 = constructor_output_xmm(ctx, v2846);
                                            let v2848 = Some(v2847);
                                            // Rule at src/isa/x64/lower.isle line 4122.
                                            return v2848;
                                        }
                                    }
                                    let v777 = constructor_put_in_xmm(ctx, v577);
                                    let v1857 = &C::xmm_to_xmm_mem(ctx, v777);
                                    let v2859 = constructor_x64_punpckhwd(ctx, v777, v1857);
                                    let v2643 = &C::xmi_imm(ctx, 0x10_u32);
                                    let v2860 = constructor_x64_psrad(ctx, v2859, v2643);
                                    let v2861 = constructor_output_xmm(ctx, v2860);
                                    let v2862 = Some(v2861);
                                    // Rule at src/isa/x64/lower.isle line 4136.
                                    return v2862;
                                }
                            }
                            I64X2 => {
                                let v906 = C::value_type(ctx, v577);
                                if v906 == I32X4 {
                                    let v678 = C::has_sse41(ctx);
                                    if v678 == true {
                                        let v773 = &C::put_in_xmm_mem(ctx, v577);
                                        let v2849 = constructor_x64_pshufd(ctx, v773, 0xee_u8);
                                        let v2850 = &C::xmm_to_xmm_mem(ctx, v2849);
                                        let v2851 = constructor_x64_pmovsxdq(ctx, v2850);
                                        let v2852 = constructor_output_xmm(ctx, v2851);
                                        let v2853 = Some(v2852);
                                        // Rule at src/isa/x64/lower.isle line 4127.
                                        return v2853;
                                    }
                                    let v773 = &C::put_in_xmm_mem(ctx, v577);
                                    let v2864 = constructor_x64_pshufd(ctx, v773, 0xe_u8);
                                    let v2865 = constructor_xmm_zero(ctx, I32X4);
                                    let v2866 = &constructor_xmm_to_xmm_mem_aligned(ctx, v2864);
                                    let v2867 = constructor_x64_pcmpgtd_a(ctx, v2865, v2866);
                                    let v2868 = &C::xmm_to_xmm_mem(ctx, v2867);
                                    let v2869 = constructor_x64_punpckldq(ctx, v2864, v2868);
                                    let v2870 = constructor_output_xmm(ctx, v2869);
                                    let v2871 = Some(v2870);
                                    // Rule at src/isa/x64/lower.isle line 4141.
                                    return v2871;
                                }
                            }
                            _ => {}
                        }
                    }
                }
                &Opcode::UwidenLow => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        match v3 {
                            I16X8 => {
                                let v678 = C::has_sse41(ctx);
                                if v678 == true {
                                    let v906 = C::value_type(ctx, v577);
                                    if v906 == I8X16 {
                                        let v773 = &C::put_in_xmm_mem(ctx, v577);
                                        let v2872 = constructor_x64_pmovzxbw(ctx, v773);
                                        let v2873 = constructor_output_xmm(ctx, v2872);
                                        let v2874 = Some(v2873);
                                        // Rule at src/isa/x64/lower.isle line 4149.
                                        return v2874;
                                    }
                                }
                            }
                            I32X4 => {
                                let v678 = C::has_sse41(ctx);
                                if v678 == true {
                                    let v906 = C::value_type(ctx, v577);
                                    if v906 == I16X8 {
                                        let v773 = &C::put_in_xmm_mem(ctx, v577);
                                        let v2875 = constructor_x64_pmovzxwd(ctx, v773);
                                        let v2876 = constructor_output_xmm(ctx, v2875);
                                        let v2877 = Some(v2876);
                                        // Rule at src/isa/x64/lower.isle line 4152.
                                        return v2877;
                                    }
                                }
                            }
                            I64X2 => {
                                let v678 = C::has_sse41(ctx);
                                if v678 == true {
                                    let v906 = C::value_type(ctx, v577);
                                    if v906 == I32X4 {
                                        let v773 = &C::put_in_xmm_mem(ctx, v577);
                                        let v2878 = constructor_x64_pmovzxdq(ctx, v773);
                                        let v2879 = constructor_output_xmm(ctx, v2878);
                                        let v2880 = Some(v2879);
                                        // Rule at src/isa/x64/lower.isle line 4155.
                                        return v2880;
                                    }
                                }
                            }
                            _ => {}
                        }
                        let v777 = constructor_put_in_xmm(ctx, v577);
                        let v2881 = constructor_lower_uwiden_low(ctx, v3, v777);
                        let v2882 = constructor_output_xmm(ctx, v2881);
                        let v2883 = Some(v2882);
                        // Rule at src/isa/x64/lower.isle line 4159.
                        return v2883;
                    }
                }
                &Opcode::UwidenHigh => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        match v3 {
                            I16X8 => {
                                let v906 = C::value_type(ctx, v577);
                                if v906 == I8X16 {
                                    let v777 = constructor_put_in_xmm(ctx, v577);
                                    let v778 = constructor_xmm_zero(ctx, I8X16);
                                    let v2884 = &C::xmm_to_xmm_mem(ctx, v778);
                                    let v2885 = constructor_x64_punpckhbw(ctx, v777, v2884);
                                    let v2886 = constructor_output_xmm(ctx, v2885);
                                    let v2887 = Some(v2886);
                                    // Rule at src/isa/x64/lower.isle line 4174.
                                    return v2887;
                                }
                            }
                            I32X4 => {
                                let v906 = C::value_type(ctx, v577);
                                if v906 == I16X8 {
                                    let v777 = constructor_put_in_xmm(ctx, v577);
                                    let v778 = constructor_xmm_zero(ctx, I8X16);
                                    let v2884 = &C::xmm_to_xmm_mem(ctx, v778);
                                    let v2888 = constructor_x64_punpckhwd(ctx, v777, v2884);
                                    let v2889 = constructor_output_xmm(ctx, v2888);
                                    let v2890 = Some(v2889);
                                    // Rule at src/isa/x64/lower.isle line 4176.
                                    return v2890;
                                }
                            }
                            I64X2 => {
                                let v906 = C::value_type(ctx, v577);
                                if v906 == I32X4 {
                                    let v777 = constructor_put_in_xmm(ctx, v577);
                                    let v2688 = constructor_xmm_zero(ctx, F32X4);
                                    let v2689 = &C::xmm_to_xmm_mem(ctx, v2688);
                                    let v2891 = constructor_x64_unpckhps(ctx, v777, v2689);
                                    let v2892 = constructor_output_xmm(ctx, v2891);
                                    let v2893 = Some(v2892);
                                    // Rule at src/isa/x64/lower.isle line 4178.
                                    return v2893;
                                }
                            }
                            _ => {}
                        }
                    }
                }
                &Opcode::Uextend => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        match v3 {
                            I64 => {
                                let v1514 = constructor_extend_to_gpr(ctx, v577, I64, &ExtendKind::Zero);
                                let v1735 = constructor_output_gpr(ctx, v1514);
                                let v1736 = Some(v1735);
                                // Rule at src/isa/x64/lower.isle line 2620.
                                return v1736;
                            }
                            I128 => {
                                let v1514 = constructor_extend_to_gpr(ctx, v577, I64, &ExtendKind::Zero);
                                let v1730 = C::gpr_to_reg(ctx, v1514);
                                let v1731 = constructor_imm(ctx, I64, 0x0_u64);
                                let v1732 = C::value_regs(ctx, v1730, v1731);
                                let v1733 = C::output(ctx, v1732);
                                let v1734 = Some(v1733);
                                // Rule at src/isa/x64/lower.isle line 2616.
                                return v1734;
                            }
                            _ => {}
                        }
                        let v1737 = C::fits_in_32(ctx, v3);
                        if let Some(v1738) = v1737 {
                            let v1550 = constructor_extend_to_gpr(ctx, v577, I32, &ExtendKind::Zero);
                            let v1739 = constructor_output_gpr(ctx, v1550);
                            let v1740 = Some(v1739);
                            // Rule at src/isa/x64/lower.isle line 2625.
                            return v1740;
                        }
                    }
                }
                &Opcode::Sextend => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        match v3 {
                            I64 => {
                                let v1741 = constructor_extend_to_gpr(ctx, v577, I64, &ExtendKind::Sign);
                                let v1748 = constructor_output_gpr(ctx, v1741);
                                let v1749 = Some(v1748);
                                // Rule at src/isa/x64/lower.isle line 2640.
                                return v1749;
                            }
                            I128 => {
                                let v1741 = constructor_extend_to_gpr(ctx, v577, I64, &ExtendKind::Sign);
                                let v1742 = constructor_x64_sarq_mi(ctx, v1741, 0x3f_u8);
                                let v1743 = C::gpr_to_reg(ctx, v1741);
                                let v1744 = C::gpr_to_reg(ctx, v1742);
                                let v1745 = C::value_regs(ctx, v1743, v1744);
                                let v1746 = C::output(ctx, v1745);
                                let v1747 = Some(v1746);
                                // Rule at src/isa/x64/lower.isle line 2634.
                                return v1747;
                            }
                            _ => {}
                        }
                        let v1737 = C::fits_in_32(ctx, v3);
                        if let Some(v1738) = v1737 {
                            let v1576 = constructor_extend_to_gpr(ctx, v577, I32, &ExtendKind::Sign);
                            let v1750 = constructor_output_gpr(ctx, v1576);
                            let v1751 = Some(v1750);
                            // Rule at src/isa/x64/lower.isle line 2645.
                            return v1751;
                        }
                    }
                }
                &Opcode::Fpromote => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        if v3 == F64 {
                            let v1844 = constructor_xmm_zero(ctx, F64X2);
                            let v1839 = &C::put_in_xmm_mem(ctx, v577);
                            let v1854 = constructor_x64_cvtss2sd(ctx, v1844, v1839);
                            let v1855 = constructor_output_xmm(ctx, v1854);
                            let v1856 = Some(v1855);
                            // Rule at src/isa/x64/lower.isle line 2748.
                            return v1856;
                        }
                    }
                }
                &Opcode::Fdemote => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        if v3 == F32 {
                            let v1838 = constructor_xmm_zero(ctx, F32X4);
                            let v1839 = &C::put_in_xmm_mem(ctx, v577);
                            let v1861 = constructor_x64_cvtsd2ss(ctx, v1838, v1839);
                            let v1862 = constructor_output_xmm(ctx, v1861);
                            let v1863 = Some(v1862);
                            // Rule at src/isa/x64/lower.isle line 2756.
                            return v1863;
                        }
                    }
                }
                &Opcode::Fvdemote => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        if v3 == F32X4 {
                            let v773 = &C::put_in_xmm_mem(ctx, v577);
                            let v1864 = constructor_x64_cvtpd2ps(ctx, v773);
                            let v1865 = constructor_output_xmm(ctx, v1864);
                            let v1866 = Some(v1865);
                            // Rule at src/isa/x64/lower.isle line 2760.
                            return v1866;
                        }
                    }
                }
                &Opcode::FvpromoteLow => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        if v3 == F64X2 {
                            let v777 = constructor_put_in_xmm(ctx, v577);
                            let v1857 = &C::xmm_to_xmm_mem(ctx, v777);
                            let v1858 = constructor_x64_cvtps2pd(ctx, v1857);
                            let v1859 = constructor_output_xmm(ctx, v1858);
                            let v1860 = Some(v1859);
                            // Rule at src/isa/x64/lower.isle line 2752.
                            return v1860;
                        }
                    }
                }
                &Opcode::FcvtToUint => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v906 = C::value_type(ctx, v577);
                        let v2659 = C::ty_scalar_float(ctx, v906);
                        if let Some(v2660) = v2659 {
                            let v3 = C::value_type(ctx, v2);
                            let v192 = false;
                            let v2661 = constructor_cvt_float_to_uint_seq(ctx, v3, v577, v192);
                            let v2662 = constructor_output_gpr(ctx, v2661);
                            let v2663 = Some(v2662);
                            // Rule at src/isa/x64/lower.isle line 3836.
                            return v2663;
                        }
                    }
                }
                &Opcode::FcvtToSint => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v906 = C::value_type(ctx, v577);
                        let v2659 = C::ty_scalar_float(ctx, v906);
                        if let Some(v2660) = v2659 {
                            let v3 = C::value_type(ctx, v2);
                            let v192 = false;
                            let v2667 = constructor_cvt_float_to_sint_seq(ctx, v3, v577, v192);
                            let v2668 = constructor_output_gpr(ctx, v2667);
                            let v2669 = Some(v2668);
                            // Rule at src/isa/x64/lower.isle line 3842.
                            return v2669;
                        }
                    }
                }
                &Opcode::FcvtToUintSat => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        if v3 == I32X4 {
                            let v906 = C::value_type(ctx, v577);
                            if v906 == F32X4 {
                                let v777 = constructor_put_in_xmm(ctx, v577);
                                let v2688 = constructor_xmm_zero(ctx, F32X4);
                                let v2689 = &C::xmm_to_xmm_mem(ctx, v2688);
                                let v2690 = constructor_x64_maxps(ctx, v777, v2689);
                                let v2691 = &C::xmm_to_xmm_mem(ctx, v2688);
                                let v2692 = constructor_x64_pcmpeqd(ctx, v2688, v2691);
                                let v2693 = &C::xmi_imm(ctx, 0x1_u32);
                                let v2694 = constructor_x64_psrld(ctx, v2692, v2693);
                                let v2695 = &C::xmm_to_xmm_mem(ctx, v2694);
                                let v2696 = constructor_x64_cvtdq2ps(ctx, v2695);
                                let v2697 = &C::xmm_to_xmm_mem(ctx, v2690);
                                let v2698 = constructor_x64_cvttps2dq(ctx, v2697);
                                let v2699 = &C::xmm_to_xmm_mem(ctx, v2696);
                                let v2700 = constructor_x64_subps(ctx, v2690, v2699);
                                let v2701 = &C::xmm_to_xmm_mem(ctx, v2700);
                                let v2702 = constructor_x64_cmpps(ctx, v2696, v2701, &FcmpImm::LessThanOrEqual);
                                let v2703 = &C::xmm_to_xmm_mem(ctx, v2700);
                                let v2704 = constructor_x64_cvttps2dq(ctx, v2703);
                                let v2705 = &C::xmm_to_xmm_mem(ctx, v2702);
                                let v2706 = constructor_x64_pxor(ctx, v2704, v2705);
                                let v2707 = constructor_xmm_zero(ctx, I32X4);
                                let v2708 = constructor_lower_vec_smax(ctx, I32X4, v2706, v2707);
                                let v2709 = &C::xmm_to_xmm_mem(ctx, v2698);
                                let v2710 = constructor_x64_paddd(ctx, v2708, v2709);
                                let v2711 = constructor_output_xmm(ctx, v2710);
                                let v2712 = Some(v2711);
                                // Rule at src/isa/x64/lower.isle line 3920.
                                return v2712;
                            }
                        }
                        let v906 = C::value_type(ctx, v577);
                        let v2659 = C::ty_scalar_float(ctx, v906);
                        if let Some(v2660) = v2659 {
                            let v202 = true;
                            let v2664 = constructor_cvt_float_to_uint_seq(ctx, v3, v577, v202);
                            let v2665 = constructor_output_gpr(ctx, v2664);
                            let v2666 = Some(v2665);
                            // Rule at src/isa/x64/lower.isle line 3839.
                            return v2666;
                        }
                    }
                }
                &Opcode::FcvtToSintSat => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        if v3 == I32X4 {
                            let v906 = C::value_type(ctx, v577);
                            if v906 == F32X4 {
                                let v777 = constructor_put_in_xmm(ctx, v577);
                                let v1857 = &C::xmm_to_xmm_mem(ctx, v777);
                                let v2673 = constructor_x64_cmpps(ctx, v777, v1857, &FcmpImm::Equal);
                                let v2674 = &C::xmm_to_xmm_mem(ctx, v2673);
                                let v2675 = constructor_x64_andps(ctx, v777, v2674);
                                let v2676 = &C::xmm_to_xmm_mem(ctx, v2675);
                                let v2677 = constructor_x64_pxor(ctx, v2673, v2676);
                                let v2678 = &C::xmm_to_xmm_mem(ctx, v2675);
                                let v2679 = constructor_x64_cvttps2dq(ctx, v2678);
                                let v2680 = &C::xmm_to_xmm_mem(ctx, v2677);
                                let v2681 = constructor_x64_pand(ctx, v2679, v2680);
                                let v2682 = &C::xmi_imm(ctx, 0x1f_u32);
                                let v2683 = constructor_x64_psrad(ctx, v2681, v2682);
                                let v2684 = &C::xmm_to_xmm_mem(ctx, v2679);
                                let v2685 = constructor_x64_pxor(ctx, v2683, v2684);
                                let v2686 = constructor_output_xmm(ctx, v2685);
                                let v2687 = Some(v2686);
                                // Rule at src/isa/x64/lower.isle line 3849.
                                return v2687;
                            }
                        }
                        let v906 = C::value_type(ctx, v577);
                        let v2659 = C::ty_scalar_float(ctx, v906);
                        if let Some(v2660) = v2659 {
                            let v202 = true;
                            let v2670 = constructor_cvt_float_to_sint_seq(ctx, v3, v577, v202);
                            let v2671 = constructor_output_gpr(ctx, v2670);
                            let v2672 = Some(v2671);
                            // Rule at src/isa/x64/lower.isle line 3845.
                            return v2672;
                        }
                    }
                }
                &Opcode::X86Cvtt2dq => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        if v3 == I32X4 {
                            let v906 = C::value_type(ctx, v577);
                            if v906 == F32X4 {
                                let v773 = &C::put_in_xmm_mem(ctx, v577);
                                let v2713 = constructor_x64_cvttps2dq(ctx, v773);
                                let v2714 = constructor_output_xmm(ctx, v2713);
                                let v2715 = Some(v2714);
                                // Rule at src/isa/x64/lower.isle line 3967.
                                return v2715;
                            }
                        }
                    }
                }
                &Opcode::FcvtFromUint => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        match v3 {
                            F32 => {
                                let v906 = C::value_type(ctx, v577);
                                let v2589 = C::fits_in_32(ctx, v906);
                                if let Some(v2590) = v2589 {
                                    let v2591 = C::ty_int(ctx, v2590);
                                    if let Some(v2592) = v2591 {
                                        let v1838 = constructor_xmm_zero(ctx, F32X4);
                                        let v2593 = constructor_extend_to_gpr(ctx, v577, I64, &ExtendKind::Zero);
                                        let v2594 = &C::gpr_to_gpr_mem(ctx, v2593);
                                        let v2595 = constructor_x64_cvtsi2ss(ctx, I64, v1838, v2594);
                                        let v2596 = constructor_output_xmm(ctx, v2595);
                                        let v2597 = Some(v2596);
                                        // Rule at src/isa/x64/lower.isle line 3724.
                                        return v2597;
                                    }
                                }
                            }
                            F64 => {
                                let v906 = C::value_type(ctx, v577);
                                let v2589 = C::fits_in_32(ctx, v906);
                                if let Some(v2590) = v2589 {
                                    let v2591 = C::ty_int(ctx, v2590);
                                    if let Some(v2592) = v2591 {
                                        let v1844 = constructor_xmm_zero(ctx, F64X2);
                                        let v2593 = constructor_extend_to_gpr(ctx, v577, I64, &ExtendKind::Zero);
                                        let v2594 = &C::gpr_to_gpr_mem(ctx, v2593);
                                        let v2598 = constructor_x64_cvtsi2sd(ctx, I64, v1844, v2594);
                                        let v2599 = constructor_output_xmm(ctx, v2598);
                                        let v2600 = Some(v2599);
                                        // Rule at src/isa/x64/lower.isle line 3727.
                                        return v2600;
                                    }
                                }
                            }
                            F32X4 => {
                                let v520 = C::has_avx512vl(ctx);
                                if v520 == true {
                                    let v521 = C::has_avx512f(ctx);
                                    if v521 == true {
                                        let v773 = &C::put_in_xmm_mem(ctx, v577);
                                        let v2637 = constructor_x64_vcvtudq2ps(ctx, v773);
                                        let v2638 = constructor_output_xmm(ctx, v2637);
                                        let v2639 = Some(v2638);
                                        // Rule at src/isa/x64/lower.isle line 3784.
                                        return v2639;
                                    }
                                }
                                let v777 = constructor_put_in_xmm(ctx, v577);
                                let v2641 = &C::xmi_imm(ctx, 0x10_u32);
                                let v2642 = constructor_x64_pslld(ctx, v777, v2641);
                                let v2643 = &C::xmi_imm(ctx, 0x10_u32);
                                let v2644 = constructor_x64_psrld(ctx, v2642, v2643);
                                let v2645 = &C::xmm_to_xmm_mem(ctx, v2644);
                                let v2646 = constructor_x64_psubd(ctx, v777, v2645);
                                let v2647 = &C::xmm_to_xmm_mem(ctx, v2644);
                                let v2648 = constructor_x64_cvtdq2ps(ctx, v2647);
                                let v2649 = &C::xmi_imm(ctx, 0x1_u32);
                                let v2650 = constructor_x64_psrld(ctx, v2646, v2649);
                                let v2651 = &C::xmm_to_xmm_mem(ctx, v2650);
                                let v2652 = constructor_x64_cvtdq2ps(ctx, v2651);
                                let v2653 = &C::xmm_to_xmm_mem(ctx, v2652);
                                let v2654 = constructor_x64_addps(ctx, v2652, v2653);
                                let v2655 = &C::xmm_to_xmm_mem(ctx, v2648);
                                let v2656 = constructor_x64_addps(ctx, v2654, v2655);
                                let v2657 = constructor_output_xmm(ctx, v2656);
                                let v2658 = Some(v2657);
                                // Rule at src/isa/x64/lower.isle line 3812.
                                return v2658;
                            }
                            F64X2 => {
                                let v2579 = C::def_inst(ctx, v577);
                                if let Some(v2580) = v2579 {
                                    let v2581 = &C::inst_data_value(ctx, v2580);
                                    if let &InstructionData::Unary {
                                        opcode: ref v2582,
                                        arg: v2583,
                                    } = v2581 {
                                        if let &Opcode::UwidenLow = v2582 {
                                            let v2584 = C::value_type(ctx, v2583);
                                            if v2584 == I32X4 {
                                                let v2628 = C::emit_u128_le_const(ctx, 0x4330000043300000_u128);
                                                let v2629 = &constructor_const_to_xmm_mem(ctx, v2628);
                                                let v2630 = constructor_put_in_xmm(ctx, v2583);
                                                let v2631 = constructor_x64_unpcklps(ctx, v2630, v2629);
                                                let v2632 = C::emit_u128_le_const(ctx, 0x43300000000000004330000000000000_u128);
                                                let v2633 = &constructor_const_to_xmm_mem(ctx, v2632);
                                                let v2634 = constructor_x64_subpd(ctx, v2631, v2633);
                                                let v2635 = constructor_output_xmm(ctx, v2634);
                                                let v2636 = Some(v2635);
                                                // Rule at src/isa/x64/lower.isle line 3776.
                                                return v2636;
                                            }
                                        }
                                    }
                                }
                            }
                            _ => {}
                        }
                        let v906 = C::value_type(ctx, v577);
                        match v906 {
                            I64 => {
                                let v578 = constructor_put_in_gpr(ctx, v577);
                                let v2601 = constructor_cvt_u64_to_float_seq(ctx, v3, v578);
                                let v2602 = constructor_output_xmm(ctx, v2601);
                                let v2603 = Some(v2602);
                                // Rule at src/isa/x64/lower.isle line 3730.
                                return v2603;
                            }
                            I64X2 => {
                                if v3 == F64X2 {
                                    let v2605 = C::emit_u128_le_const(ctx, 0xffffffff00000000ffffffff_u128);
                                    let v2606 = &constructor_const_to_xmm_mem(ctx, v2605);
                                    let v2608 = C::emit_u128_le_const(ctx, 0x43300000000000004330000000000000_u128);
                                    let v2609 = &constructor_const_to_xmm_mem(ctx, v2608);
                                    let v2611 = C::emit_u128_le_const(ctx, 0x45300000000000004530000000000000_u128);
                                    let v2612 = &constructor_const_to_xmm_mem(ctx, v2611);
                                    let v2614 = C::emit_u128_le_const(ctx, 0x45300000001000004530000000100000_u128);
                                    let v2615 = &constructor_const_to_xmm_mem(ctx, v2614);
                                    let v2616 = constructor_put_in_xmm(ctx, v577);
                                    let v2617 = constructor_x64_pand(ctx, v2616, v2606);
                                    let v2618 = constructor_x64_por(ctx, v2617, v2609);
                                    let v2619 = constructor_put_in_xmm(ctx, v577);
                                    let v714 = &C::xmi_imm(ctx, 0x20_u32);
                                    let v2620 = constructor_x64_psrlq(ctx, v2619, v714);
                                    let v2621 = constructor_x64_por(ctx, v2620, v2612);
                                    let v2622 = constructor_x64_subpd(ctx, v2621, v2615);
                                    let v2623 = &C::xmm_to_xmm_mem(ctx, v2622);
                                    let v2624 = constructor_x64_addpd(ctx, v2618, v2623);
                                    let v2625 = constructor_output_xmm(ctx, v2624);
                                    let v2626 = Some(v2625);
                                    // Rule at src/isa/x64/lower.isle line 3761.
                                    return v2626;
                                }
                            }
                            _ => {}
                        }
                    }
                }
                &Opcode::FcvtFromSint => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        match v3 {
                            F32 => {
                                let v906 = C::value_type(ctx, v577);
                                match v906 {
                                    I8 => {
                                        let v1838 = constructor_xmm_zero(ctx, F32X4);
                                        let v2545 = constructor_extend_to_gpr(ctx, v577, I32, &ExtendKind::Sign);
                                        let v2546 = &C::gpr_to_gpr_mem(ctx, v2545);
                                        let v2547 = constructor_x64_cvtsi2ss(ctx, I32, v1838, v2546);
                                        let v2548 = constructor_output_xmm(ctx, v2547);
                                        let v2549 = Some(v2548);
                                        // Rule at src/isa/x64/lower.isle line 3686.
                                        return v2549;
                                    }
                                    I16 => {
                                        let v1838 = constructor_xmm_zero(ctx, F32X4);
                                        let v2545 = constructor_extend_to_gpr(ctx, v577, I32, &ExtendKind::Sign);
                                        let v2546 = &C::gpr_to_gpr_mem(ctx, v2545);
                                        let v2547 = constructor_x64_cvtsi2ss(ctx, I32, v1838, v2546);
                                        let v2548 = constructor_output_xmm(ctx, v2547);
                                        let v2549 = Some(v2548);
                                        // Rule at src/isa/x64/lower.isle line 3689.
                                        return v2549;
                                    }
                                    _ => {}
                                }
                                let v2550 = C::ty_int(ctx, v906);
                                if let Some(v2551) = v2550 {
                                    let v2552 = C::fits_in_64(ctx, v2551);
                                    if let Some(v2553) = v2552 {
                                        let v1838 = constructor_xmm_zero(ctx, F32X4);
                                        let v2554 = &constructor_put_in_gpr_mem(ctx, v577);
                                        let v2555 = constructor_x64_cvtsi2ss(ctx, v2553, v1838, v2554);
                                        let v2556 = constructor_output_xmm(ctx, v2555);
                                        let v2557 = Some(v2556);
                                        // Rule at src/isa/x64/lower.isle line 3692.
                                        return v2557;
                                    }
                                }
                            }
                            F64 => {
                                let v906 = C::value_type(ctx, v577);
                                match v906 {
                                    I8 => {
                                        let v1844 = constructor_xmm_zero(ctx, F64X2);
                                        let v2545 = constructor_extend_to_gpr(ctx, v577, I32, &ExtendKind::Sign);
                                        let v2546 = &C::gpr_to_gpr_mem(ctx, v2545);
                                        let v2558 = constructor_x64_cvtsi2sd(ctx, I32, v1844, v2546);
                                        let v2559 = constructor_output_xmm(ctx, v2558);
                                        let v2560 = Some(v2559);
                                        // Rule at src/isa/x64/lower.isle line 3695.
                                        return v2560;
                                    }
                                    I16 => {
                                        let v1844 = constructor_xmm_zero(ctx, F64X2);
                                        let v2545 = constructor_extend_to_gpr(ctx, v577, I32, &ExtendKind::Sign);
                                        let v2546 = &C::gpr_to_gpr_mem(ctx, v2545);
                                        let v2558 = constructor_x64_cvtsi2sd(ctx, I32, v1844, v2546);
                                        let v2559 = constructor_output_xmm(ctx, v2558);
                                        let v2560 = Some(v2559);
                                        // Rule at src/isa/x64/lower.isle line 3698.
                                        return v2560;
                                    }
                                    _ => {}
                                }
                                let v2550 = C::ty_int(ctx, v906);
                                if let Some(v2551) = v2550 {
                                    let v2552 = C::fits_in_64(ctx, v2551);
                                    if let Some(v2553) = v2552 {
                                        let v1844 = constructor_xmm_zero(ctx, F64X2);
                                        let v2554 = &constructor_put_in_gpr_mem(ctx, v577);
                                        let v2561 = constructor_x64_cvtsi2sd(ctx, v2553, v1844, v2554);
                                        let v2562 = constructor_output_xmm(ctx, v2561);
                                        let v2563 = Some(v2562);
                                        // Rule at src/isa/x64/lower.isle line 3701.
                                        return v2563;
                                    }
                                }
                            }
                            F64X2 => {
                                let v2579 = C::def_inst(ctx, v577);
                                if let Some(v2580) = v2579 {
                                    let v2581 = &C::inst_data_value(ctx, v2580);
                                    if let &InstructionData::Unary {
                                        opcode: ref v2582,
                                        arg: v2583,
                                    } = v2581 {
                                        if let &Opcode::SwidenLow = v2582 {
                                            let v2584 = C::value_type(ctx, v2583);
                                            if v2584 == I32X4 {
                                                let v2585 = &C::put_in_xmm_mem(ctx, v2583);
                                                let v2586 = constructor_x64_cvtdq2pd(ctx, v2585);
                                                let v2587 = constructor_output_xmm(ctx, v2586);
                                                let v2588 = Some(v2587);
                                                // Rule at src/isa/x64/lower.isle line 3719.
                                                return v2588;
                                            }
                                        }
                                    }
                                }
                            }
                            _ => {}
                        }
                    }
                    let v906 = C::value_type(ctx, v577);
                    match v906 {
                        I32X4 => {
                            let v773 = &C::put_in_xmm_mem(ctx, v577);
                            let v2564 = constructor_x64_cvtdq2ps(ctx, v773);
                            let v2565 = constructor_output_xmm(ctx, v2564);
                            let v2566 = Some(v2565);
                            // Rule at src/isa/x64/lower.isle line 3704.
                            return v2566;
                        }
                        I64X2 => {
                            let v777 = constructor_put_in_xmm(ctx, v577);
                            let v2567 = constructor_xmm_zero(ctx, F64X2);
                            let v2568 = constructor_x64_movq_to_gpr(ctx, v777);
                            let v2569 = &C::gpr_to_gpr_mem(ctx, v2568);
                            let v2570 = constructor_x64_cvtsi2sd(ctx, I64, v2567, v2569);
                            let v813 = &C::xmm_to_xmm_mem(ctx, v777);
                            let v2571 = constructor_x64_pshufd(ctx, v813, 0xee_u8);
                            let v2572 = constructor_x64_movq_to_gpr(ctx, v2571);
                            let v2573 = &C::gpr_to_gpr_mem(ctx, v2572);
                            let v2574 = constructor_x64_cvtsi2sd(ctx, I64, v2567, v2573);
                            let v2575 = &C::xmm_to_xmm_mem(ctx, v2574);
                            let v2576 = constructor_x64_unpcklpd(ctx, v2570, v2575);
                            let v2577 = constructor_output_xmm(ctx, v2576);
                            let v2578 = Some(v2577);
                            // Rule at src/isa/x64/lower.isle line 3710.
                            return v2578;
                        }
                        _ => {}
                    }
                }
                &Opcode::Isplit => {
                    let v906 = C::value_type(ctx, v577);
                    if v906 == I128 {
                        let v582 = C::put_in_regs(ctx, v577);
                        let v3429 = C::value_regs_get(ctx, v582, 0x0_usize);
                        let v3430 = C::value_regs_get(ctx, v582, 0x1_usize);
                        let v3431 = C::value_reg(ctx, v3429);
                        let v3432 = C::value_reg(ctx, v3430);
                        let v3433 = C::output_pair(ctx, v3431, v3432);
                        let v3434 = Some(v3433);
                        // Rule at src/isa/x64/lower.isle line 4991.
                        return v3434;
                    }
                }
                _ => {}
            }
        }
        &InstructionData::UnaryConst {
            opcode: ref v43,
            constant_handle: v44,
        } => {
            match v43 {
                &Opcode::F128const => {
                    let v50 = C::u128_from_constant(ctx, v44);
                    if let Some(v51) = v50 {
                        if v51 == 0x0_u128 {
                            let v52 = constructor_xmm_zero(ctx, F128);
                            let v53 = constructor_output_xmm(ctx, v52);
                            let v54 = Some(v53);
                            // Rule at src/isa/x64/lower.isle line 46.
                            return v54;
                        }
                    }
                    let v46 = C::const_to_vconst(ctx, v44);
                    let v47 = constructor_x64_xmm_load_const(ctx, F128, v46);
                    let v48 = constructor_output_xmm(ctx, v47);
                    let v49 = Some(v48);
                    // Rule at src/isa/x64/lower.isle line 42.
                    return v49;
                }
                &Opcode::Vconst => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v50 = C::u128_from_constant(ctx, v44);
                        if let Some(v51) = v50 {
                            match v51 {
                                0xffffffffffffffffffffffffffffffff_u128 => {
                                    let v3097 = constructor_vector_all_ones(ctx);
                                    let v3098 = constructor_output_xmm(ctx, v3097);
                                    let v3099 = Some(v3098);
                                    // Rule at src/isa/x64/lower.isle line 4556.
                                    return v3099;
                                }
                                0x0_u128 => {
                                    let v3 = C::value_type(ctx, v2);
                                    let v3094 = constructor_xmm_zero(ctx, v3);
                                    let v3095 = constructor_output_xmm(ctx, v3094);
                                    let v3096 = Some(v3095);
                                    // Rule at src/isa/x64/lower.isle line 4555.
                                    return v3096;
                                }
                                _ => {}
                            }
                        }
                        let v46 = C::const_to_vconst(ctx, v44);
                        let v3 = C::value_type(ctx, v2);
                        let v3091 = constructor_x64_xmm_load_const(ctx, v3, v46);
                        let v3092 = constructor_output_xmm(ctx, v3091);
                        let v3093 = Some(v3092);
                        // Rule at src/isa/x64/lower.isle line 4550.
                        return v3093;
                    }
                }
                _ => {}
            }
        }
        &InstructionData::UnaryGlobalValue {
            opcode: ref v2320,
            global_value: v2321,
        } => {
            match v2320 {
                &Opcode::SymbolValue => {
                    let v2322 = C::symbol_value_data(ctx, v2321);
                    if let Some(v2323) = v2322 {
                        let v2327 = constructor_load_ext_name(ctx, v2323.0, v2323.2, &v2323.1);
                        let v2328 = constructor_output_gpr(ctx, v2327);
                        let v2329 = Some(v2328);
                        // Rule at src/isa/x64/lower.isle line 3419.
                        return v2329;
                    }
                }
                &Opcode::TlsValue => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v2322 = C::symbol_value_data(ctx, v2321);
                        if let Some(v2323) = v2322 {
                            let v3 = C::value_type(ctx, v2);
                            let v3435 = &C::tls_model(ctx, v3);
                            match v3435 {
                                &TlsModel::ElfGd => {
                                    let v3436 = constructor_elf_tls_get_addr(ctx, v2323.0);
                                    let v3437 = constructor_output_gpr(ctx, v3436);
                                    let v3438 = Some(v3437);
                                    // Rule at src/isa/x64/lower.isle line 4999.
                                    return v3438;
                                }
                                &TlsModel::Macho => {
                                    let v3439 = constructor_macho_tls_get_addr(ctx, v2323.0);
                                    let v3440 = constructor_output_gpr(ctx, v3439);
                                    let v3441 = Some(v3440);
                                    // Rule at src/isa/x64/lower.isle line 5002.
                                    return v3441;
                                }
                                &TlsModel::Coff => {
                                    let v3442 = constructor_coff_tls_get_addr(ctx, v2323.0);
                                    let v3443 = constructor_output_gpr(ctx, v3442);
                                    let v3444 = Some(v3443);
                                    // Rule at src/isa/x64/lower.isle line 5005.
                                    return v3444;
                                }
                                _ => {}
                            }
                        }
                    }
                }
                _ => {}
            }
        }
        &InstructionData::UnaryIeee16 {
            opcode: ref v20,
            imm: v21,
        } => {
            if let &Opcode::F16const = v20 {
                let v22 = C::u16_from_ieee16(ctx, v21);
                let v24 = C::u16_into_u64(ctx, v22);
                let v25 = constructor_imm(ctx, F16, v24);
                let v26 = constructor_output_reg(ctx, v25);
                let v27 = Some(v26);
                // Rule at src/isa/x64/lower.isle line 28.
                return v27;
            }
        }
        &InstructionData::UnaryIeee32 {
            opcode: ref v28,
            imm: v29,
        } => {
            if let &Opcode::F32const = v28 {
                let v30 = C::u32_from_ieee32(ctx, v29);
                let v32 = C::u32_into_u64(ctx, v30);
                let v33 = constructor_imm(ctx, F32, v32);
                let v34 = constructor_output_reg(ctx, v33);
                let v35 = Some(v34);
                // Rule at src/isa/x64/lower.isle line 33.
                return v35;
            }
        }
        &InstructionData::UnaryIeee64 {
            opcode: ref v36,
            imm: v37,
        } => {
            if let &Opcode::F64const = v36 {
                let v38 = C::u64_from_ieee64(ctx, v37);
                let v40 = constructor_imm(ctx, F64, v38);
                let v41 = constructor_output_reg(ctx, v40);
                let v42 = Some(v41);
                // Rule at src/isa/x64/lower.isle line 38.
                return v42;
            }
        }
        &InstructionData::UnaryImm {
            opcode: ref v7,
            imm: v8,
        } => {
            if let &Opcode::Iconst = v7 {
                let v1 = C::first_result(ctx, arg0);
                if let Some(v2) = v1 {
                    let v3 = C::value_type(ctx, v2);
                    if v3 == I128 {
                        let v9 = C::u64_from_imm64(ctx, v8);
                        let v14 = constructor_imm(ctx, I64, v9);
                        let v16 = constructor_imm(ctx, I64, 0x0_u64);
                        let v17 = C::value_regs(ctx, v14, v16);
                        let v18 = C::output(ctx, v17);
                        let v19 = Some(v18);
                        // Rule at src/isa/x64/lower.isle line 21.
                        return v19;
                    }
                    let v4 = C::fits_in_64(ctx, v3);
                    if let Some(v5) = v4 {
                        let v9 = C::u64_from_imm64(ctx, v8);
                        let v10 = constructor_imm(ctx, v5, v9);
                        let v11 = constructor_output_reg(ctx, v10);
                        let v12 = Some(v11);
                        // Rule at src/isa/x64/lower.isle line 16.
                        return v12;
                    }
                }
            }
        }
        _ => {}
    }
    None
}

// 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 {
        &InstructionData::BranchTable {
            opcode: ref v71,
            arg: v72,
            table: v73,
        } => {
            if let &Opcode::BrTable = v71 {
                let v75 = C::jump_table_targets(ctx, arg1);
                if let Some(v76) = v75 {
                    let v79 = C::jump_table_size(ctx, &v76.1);
                    let v74 = C::value_type(ctx, v72);
                    let v80 = C::u32_into_u64(ctx, v79);
                    let v81 = constructor_imm(ctx, v74, v80);
                    let v84 = constructor_extend_to_gpr(ctx, v72, I64, &ExtendKind::Zero);
                    let v85 = &constructor_reg_to_gpr_mem_imm(ctx, v81);
                    let v86 = &constructor_x64_cmp(ctx, v74, v84, v85);
                    let v88 = &C::gpr_to_gpr_mem(ctx, v84);
                    let v89 = C::gpr_new(ctx, v81);
                    let v90 = &constructor_cmove(ctx, v74, &CC::B, v88, v89);
                    let v91 = constructor_with_flags_reg(ctx, v86, v90);
                    let v92 = C::gpr_new(ctx, v91);
                    let v93 = &constructor_jmp_table_seq(ctx, v74, v92, v76.0, &v76.1);
                    let v94 = constructor_emit_side_effect(ctx, v93);
                    let v95 = Some(v94);
                    // Rule at src/isa/x64/lower.isle line 3642.
                    return v95;
                }
            }
        }
        &InstructionData::Brif {
            opcode: ref v57,
            arg: v58,
            blocks: ref v59,
        } => {
            if let &Opcode::Brif = v57 {
                let v63 = C::two_targets(ctx, arg1);
                if let Some(v64) = v63 {
                    let v67 = &constructor_is_nonzero_cmp(ctx, v58);
                    let v68 = &constructor_jmp_cond_result(ctx, v67, v64.0, v64.1);
                    let v69 = constructor_emit_side_effect(ctx, v68);
                    let v70 = Some(v69);
                    // Rule at src/isa/x64/lower.isle line 3637.
                    return v70;
                }
            }
        }
        &InstructionData::Jump {
            opcode: ref v50,
            destination: v51,
        } => {
            if let &Opcode::Jump = v50 {
                let v52 = C::single_target(ctx, arg1);
                if let Some(v53) = v52 {
                    let v54 = &constructor_jmp_known(ctx, v53);
                    let v55 = constructor_emit_side_effect(ctx, v54);
                    let v56 = Some(v55);
                    // Rule at src/isa/x64/lower.isle line 3632.
                    return v56;
                }
            }
        }
        &InstructionData::TryCall {
            opcode: ref v2,
            args: v3,
            func_ref: v4,
            exception: v5,
        } => {
            if let &Opcode::TryCall = v2 {
                let v7 = C::func_ref_data(ctx, v4);
                if let &RelocDistance::Near = &v7.2 {
                    let v13 = C::abi_sig(ctx, v7.0);
                    let v14 = C::try_call_info(ctx, v5, arg1);
                    let v6 = C::value_list_slice(ctx, v3);
                    let v15 = &C::put_in_regs_vec(ctx, v6);
                    let v16 = C::gen_call_args(ctx, v13, v15);
                    let v17 = C::gen_try_call_rets(ctx, v13);
                    let v18 = &C::gen_call_info(ctx, v13, v7.1, v16, v17, v14, v7.3);
                    let v19 = &constructor_call_known(ctx, v18);
                    let v20 = constructor_emit_side_effect(ctx, v19);
                    let v21 = Some(v20);
                    // Rule at src/isa/x64/lower.isle line 3578.
                    return v21;
                }
                if v7.3 == false {
                    let v13 = C::abi_sig(ctx, v7.0);
                    let v14 = C::try_call_info(ctx, v5, arg1);
                    let v6 = C::value_list_slice(ctx, v3);
                    let v15 = &C::put_in_regs_vec(ctx, v6);
                    let v16 = C::gen_call_args(ctx, v13, v15);
                    let v17 = C::gen_try_call_rets(ctx, v13);
                    let v23 = constructor_load_ext_name(ctx, v7.1, 0_i64, &v7.2);
                    let v24 = C::gpr_to_reg(ctx, v23);
                    let v25 = RegMem::Reg {
                        reg: v24,
                    };
                    let v26 = &C::gen_call_ind_info(ctx, v13, &v25, v16, v17, v14);
                    let v27 = &constructor_call_unknown(ctx, v26);
                    let v28 = constructor_emit_side_effect(ctx, v27);
                    let v29 = Some(v28);
                    // Rule at src/isa/x64/lower.isle line 3587.
                    return v29;
                }
            }
        }
        &InstructionData::TryCallIndirect {
            opcode: ref v30,
            args: v31,
            exception: v32,
        } => {
            if let &Opcode::TryCallIndirect = v30 {
                let v33 = C::value_list_slice(ctx, v31);
                let v34 = C::value_slice_unwrap(ctx, v33);
                if let Some(v35) = v34 {
                    let v38 = C::exception_sig(ctx, v32);
                    let v39 = C::abi_sig(ctx, v38);
                    let v40 = C::try_call_info(ctx, v32, arg1);
                    let v41 = C::put_in_reg(ctx, v35.0);
                    let v43 = &C::put_in_regs_vec(ctx, v35.1);
                    let v44 = C::gen_call_args(ctx, v39, v43);
                    let v45 = C::gen_try_call_rets(ctx, v39);
                    let v42 = RegMem::Reg {
                        reg: v41,
                    };
                    let v46 = &C::gen_call_ind_info(ctx, v39, &v42, v44, v45, v40);
                    let v47 = &constructor_call_unknown(ctx, v46);
                    let v48 = constructor_emit_side_effect(ctx, v47);
                    let v49 = Some(v48);
                    // Rule at src/isa/x64/lower.isle line 3597.
                    return v49;
                }
            }
        }
        _ => {}
    }
    None
}

// Generated as internal constructor for term iadd128.
pub fn constructor_iadd128<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: Gpr,
    arg2: &GprMemImm,
    arg3: &GprMemImm,
) -> ValueRegs {
    let v5 = &constructor_x64_add_with_flags_paired(ctx, I64, arg0, arg2);
    let v6 = &constructor_x64_adc_paired(ctx, I64, arg1, arg3);
    let v7 = constructor_with_flags(ctx, v5, v6);
    // Rule at src/isa/x64/lower.isle line 135.
    return v7;
}

// Generated as internal constructor for term construct_overflow_op.
pub fn constructor_construct_overflow_op<C: Context>(
    ctx: &mut C,
    arg0: &CC,
    arg1: &ProducesFlags,
) -> InstOutput {
    let v2 = &constructor_x64_setcc_paired(ctx, arg0);
    let v3 = constructor_with_flags(ctx, arg1, v2);
    let v5 = C::value_regs_get(ctx, v3, 0x0_usize);
    let v6 = C::value_reg(ctx, v5);
    let v8 = C::value_regs_get(ctx, v3, 0x1_usize);
    let v9 = C::value_reg(ctx, v8);
    let v10 = C::output_pair(ctx, v6, v9);
    // Rule at src/isa/x64/lower.isle line 142.
    return v10;
}

// Generated as internal constructor for term construct_overflow_op_alu.
pub fn constructor_construct_overflow_op_alu<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: &CC,
    arg2: &ProduceFlagsOp,
    arg3: Gpr,
    arg4: &GprMemImm,
) -> InstOutput {
    let v5 = &constructor_x64_produce_flags(ctx, arg2, arg0, arg3, arg4);
    let v6 = constructor_construct_overflow_op(ctx, arg1, v5);
    // Rule at src/isa/x64/lower.isle line 149.
    return v6;
}

// Generated as internal constructor for term construct_overflow_op_alu_128.
pub fn constructor_construct_overflow_op_alu_128<C: Context>(
    ctx: &mut C,
    arg0: &CC,
    arg1: &ProduceFlagsOp,
    arg2: &ChainFlagsOp,
    arg3: Value,
    arg4: Value,
) -> InstOutput {
    let v5 = C::put_in_regs(ctx, arg3);
    let v7 = constructor_value_regs_get_gpr(ctx, v5, 0x0_usize);
    let v9 = constructor_value_regs_get_gpr(ctx, v5, 0x1_usize);
    let v10 = C::put_in_regs(ctx, arg4);
    let v11 = constructor_value_regs_get_gpr(ctx, v10, 0x0_usize);
    let v12 = constructor_value_regs_get_gpr(ctx, v10, 0x1_usize);
    let v14 = &C::gpr_to_gpr_mem_imm(ctx, v11);
    let v15 = &constructor_x64_produce_flags(ctx, arg1, I64, v7, v14);
    let v16 = &constructor_x64_chain_flags(ctx, arg2, I64, v9, v12);
    let v17 = &constructor_x64_setcc_paired(ctx, arg0);
    let v18 = &constructor_with_flags_chained(ctx, v15, v16, v17);
    let v19 = constructor_multi_reg_to_pair_and_single(ctx, v18);
    // Rule at src/isa/x64/lower.isle line 157.
    return v19;
}

// Generated as internal constructor for term isub128.
pub fn constructor_isub128<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: Gpr,
    arg2: &GprMemImm,
    arg3: &GprMemImm,
) -> ValueRegs {
    let v5 = &constructor_x64_sub_with_flags_paired(ctx, I64, arg0, arg2);
    let v6 = &constructor_x64_sbb_paired(ctx, I64, arg1, arg3);
    let v7 = constructor_with_flags(ctx, v5, v6);
    // Rule at src/isa/x64/lower.isle line 291.
    return v7;
}

// Generated as internal constructor for term sse_and.
pub fn constructor_sse_and<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Xmm,
    arg2: &XmmMem,
) -> Xmm {
    match arg0 {
        F32 => {
            let v3 = constructor_x64_andps(ctx, arg1, arg2);
            // Rule at src/isa/x64/lower.isle line 345.
            return v3;
        }
        F64 => {
            let v4 = constructor_x64_andpd(ctx, arg1, arg2);
            // Rule at src/isa/x64/lower.isle line 346.
            return v4;
        }
        F32X4 => {
            let v3 = constructor_x64_andps(ctx, arg1, arg2);
            // Rule at src/isa/x64/lower.isle line 343.
            return v3;
        }
        F64X2 => {
            let v4 = constructor_x64_andpd(ctx, arg1, arg2);
            // Rule at src/isa/x64/lower.isle line 344.
            return v4;
        }
        _ => {}
    }
    let v5 = C::multi_lane(ctx, arg0);
    if let Some(v6) = v5 {
        let v9 = constructor_x64_pand(ctx, arg1, arg2);
        // Rule at src/isa/x64/lower.isle line 347.
        return v9;
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "sse_and", "src/isa/x64/lower.isle line 342")
}

// Generated as internal constructor for term and_i128.
pub fn constructor_and_i128<C: Context>(
    ctx: &mut C,
    arg0: ValueRegs,
    arg1: ValueRegs,
) -> ValueRegs {
    let v3 = constructor_value_regs_get_gpr(ctx, arg0, 0x0_usize);
    let v5 = constructor_value_regs_get_gpr(ctx, arg0, 0x1_usize);
    let v6 = constructor_value_regs_get_gpr(ctx, arg1, 0x0_usize);
    let v7 = constructor_value_regs_get_gpr(ctx, arg1, 0x1_usize);
    let v9 = &C::gpr_to_gpr_mem_imm(ctx, v6);
    let v10 = constructor_x64_and(ctx, I64, v3, v9);
    let v11 = &C::gpr_to_gpr_mem_imm(ctx, v7);
    let v12 = constructor_x64_and(ctx, I64, v5, v11);
    let v13 = constructor_value_gprs(ctx, v10, v12);
    // Rule at src/isa/x64/lower.isle line 356.
    return v13;
}

// Generated as internal constructor for term sse_and_not.
pub fn constructor_sse_and_not<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Xmm,
    arg2: &XmmMem,
) -> Xmm {
    match arg0 {
        F32X4 => {
            let v3 = constructor_x64_andnps(ctx, arg1, arg2);
            // Rule at src/isa/x64/lower.isle line 374.
            return v3;
        }
        F64X2 => {
            let v4 = constructor_x64_andnpd(ctx, arg1, arg2);
            // Rule at src/isa/x64/lower.isle line 375.
            return v4;
        }
        _ => {}
    }
    let v5 = C::multi_lane(ctx, arg0);
    if let Some(v6) = v5 {
        let v9 = constructor_x64_pandn(ctx, arg1, arg2);
        // Rule at src/isa/x64/lower.isle line 376.
        return v9;
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "sse_and_not", "src/isa/x64/lower.isle line 373")
}

// Generated as internal constructor for term val_minus_one.
pub fn constructor_val_minus_one<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);
        if let &InstructionData::Binary {
            opcode: ref v4,
            args: ref v5,
        } = v3 {
            match v4 {
                &Opcode::Iadd => {
                    let v6 = C::unpack_value_array_2(ctx, v5);
                    let v18 = C::i64_from_iconst(ctx, v6.0);
                    if let Some(v19) = v18 {
                        if v19 == -1_i64 {
                            let v20 = Some(v6.1);
                            // Rule at src/isa/x64/lower.isle line 405.
                            return v20;
                        }
                    }
                    let v16 = C::i64_from_iconst(ctx, v6.1);
                    if let Some(v17) = v16 {
                        if v17 == -1_i64 {
                            let v15 = Some(v6.0);
                            // Rule at src/isa/x64/lower.isle line 404.
                            return v15;
                        }
                    }
                }
                &Opcode::Isub => {
                    let v6 = C::unpack_value_array_2(ctx, v5);
                    let v9 = C::def_inst(ctx, v6.1);
                    if let Some(v10) = v9 {
                        let v11 = &C::inst_data_value(ctx, v10);
                        if let &InstructionData::UnaryImm {
                            opcode: ref v12,
                            imm: v13,
                        } = v11 {
                            if let &Opcode::Iconst = v12 {
                                let v14 = C::u64_from_imm64(ctx, v13);
                                if v14 == 0x1_u64 {
                                    let v15 = Some(v6.0);
                                    // Rule at src/isa/x64/lower.isle line 403.
                                    return v15;
                                }
                            }
                        }
                    }
                }
                _ => {}
            }
        }
    }
    None
}

// Generated as internal constructor for term sse_or.
pub fn constructor_sse_or<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Xmm,
    arg2: &XmmMem,
) -> Xmm {
    match arg0 {
        F32 => {
            let v3 = constructor_x64_orps(ctx, arg1, arg2);
            // Rule at src/isa/x64/lower.isle line 469.
            return v3;
        }
        F64 => {
            let v4 = constructor_x64_orpd(ctx, arg1, arg2);
            // Rule at src/isa/x64/lower.isle line 470.
            return v4;
        }
        F32X4 => {
            let v3 = constructor_x64_orps(ctx, arg1, arg2);
            // Rule at src/isa/x64/lower.isle line 467.
            return v3;
        }
        F64X2 => {
            let v4 = constructor_x64_orpd(ctx, arg1, arg2);
            // Rule at src/isa/x64/lower.isle line 468.
            return v4;
        }
        _ => {}
    }
    let v5 = C::multi_lane(ctx, arg0);
    if let Some(v6) = v5 {
        let v9 = constructor_x64_por(ctx, arg1, arg2);
        // Rule at src/isa/x64/lower.isle line 471.
        return v9;
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "sse_or", "src/isa/x64/lower.isle line 466")
}

// Generated as internal constructor for term or_i128.
pub fn constructor_or_i128<C: Context>(
    ctx: &mut C,
    arg0: ValueRegs,
    arg1: ValueRegs,
) -> ValueRegs {
    let v3 = constructor_value_regs_get_gpr(ctx, arg0, 0x0_usize);
    let v5 = constructor_value_regs_get_gpr(ctx, arg0, 0x1_usize);
    let v6 = constructor_value_regs_get_gpr(ctx, arg1, 0x0_usize);
    let v7 = constructor_value_regs_get_gpr(ctx, arg1, 0x1_usize);
    let v9 = &C::gpr_to_gpr_mem_imm(ctx, v6);
    let v10 = constructor_x64_or(ctx, I64, v3, v9);
    let v11 = &C::gpr_to_gpr_mem_imm(ctx, v7);
    let v12 = constructor_x64_or(ctx, I64, v5, v11);
    let v13 = constructor_value_gprs(ctx, v10, v12);
    // Rule at src/isa/x64/lower.isle line 480.
    return v13;
}

// Generated as internal constructor for term shl_i128.
pub fn constructor_shl_i128<C: Context>(
    ctx: &mut C,
    arg0: ValueRegs,
    arg1: Gpr,
) -> ValueRegs {
    let v3 = constructor_value_regs_get_gpr(ctx, arg0, 0x0_usize);
    let v5 = constructor_value_regs_get_gpr(ctx, arg0, 0x1_usize);
    let v7 = &constructor_gpr_to_imm8_gpr(ctx, arg1);
    let v8 = constructor_x64_shl(ctx, I64, v3, v7);
    let v9 = &constructor_gpr_to_imm8_gpr(ctx, arg1);
    let v10 = constructor_x64_shl(ctx, I64, v5, v9);
    let v12 = constructor_imm(ctx, I64, 0x40_u64);
    let v13 = C::gpr_new(ctx, v12);
    let v14 = &C::gpr_to_gpr_mem_imm(ctx, arg1);
    let v15 = constructor_x64_sub(ctx, I64, v13, v14);
    let v16 = &constructor_gpr_to_imm8_gpr(ctx, v15);
    let v17 = constructor_x64_shr(ctx, I64, v3, v16);
    let v19 = constructor_imm(ctx, I64, 0x0_u64);
    let v20 = C::gpr_new(ctx, v19);
    let v21 = &C::gpr_to_gpr_mem(ctx, arg1);
    let v23 = &constructor_x64_testq_mi(ctx, v21, 127_i32);
    let v25 = &C::gpr_to_gpr_mem(ctx, v20);
    let v26 = &constructor_cmove(ctx, I64, &CC::Z, v25, v17);
    let v27 = constructor_with_flags_reg(ctx, v23, v26);
    let v28 = C::gpr_new(ctx, v27);
    let v29 = &C::gpr_to_gpr_mem_imm(ctx, v10);
    let v30 = constructor_x64_or(ctx, I64, v28, v29);
    let v31 = &C::gpr_to_gpr_mem(ctx, arg1);
    let v33 = &constructor_x64_testq_mi(ctx, v31, 64_i32);
    let v34 = &C::gpr_to_gpr_mem(ctx, v8);
    let v35 = &constructor_cmove(ctx, I64, &CC::Z, v34, v20);
    let v36 = &C::gpr_to_gpr_mem(ctx, v30);
    let v37 = &constructor_cmove(ctx, I64, &CC::Z, v36, v8);
    let v38 = &constructor_consumes_flags_concat(ctx, v35, v37);
    let v39 = constructor_with_flags(ctx, v33, v38);
    // Rule at src/isa/x64/lower.isle line 573.
    return v39;
}

// Generated as internal constructor for term ishl_i8x16_mask.
pub fn constructor_ishl_i8x16_mask<C: Context>(
    ctx: &mut C,
    arg0: &RegMemImm,
) -> SyntheticAmode {
    match arg0 {
        &RegMemImm::Reg {
            reg: v3,
        } => {
            let v4 = &C::ishl_i8x16_mask_table(ctx);
            let v5 = constructor_x64_leaq_rm(ctx, v4);
            let v6 = C::gpr_new(ctx, v3);
            let v8 = constructor_x64_shlq_mi(ctx, v6, 0x4_u8);
            let v11 = C::mem_flags_trusted(ctx);
            let v12 = Amode::ImmRegRegShift {
                simm32: 0_i32,
                base: v5,
                index: v8,
                shift: 0x0_u8,
                flags: v11,
            };
            let v13 = &C::amode_to_synthetic_amode(ctx, &v12);
            // Rule at src/isa/x64/lower.isle line 647.
            return v13.clone();
        }
        &RegMemImm::Mem {
            addr: ref v14,
        } => {
            let v17 = constructor_x64_load(ctx, I64, v14, &ExtKind::None);
            let v18 = RegMemImm::Reg {
                reg: v17,
            };
            let v19 = &constructor_ishl_i8x16_mask(ctx, &v18);
            // Rule at src/isa/x64/lower.isle line 657.
            return v19.clone();
        }
        &RegMemImm::Imm {
            simm32: v1,
        } => {
            let v2 = &C::ishl_i8x16_mask_for_const(ctx, v1);
            // Rule at src/isa/x64/lower.isle line 638.
            return v2.clone();
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "ishl_i8x16_mask", "src/isa/x64/lower.isle line 632")
}

// Generated as internal constructor for term shr_i128.
pub fn constructor_shr_i128<C: Context>(
    ctx: &mut C,
    arg0: ValueRegs,
    arg1: Gpr,
) -> ValueRegs {
    let v3 = constructor_value_regs_get_gpr(ctx, arg0, 0x0_usize);
    let v5 = constructor_value_regs_get_gpr(ctx, arg0, 0x1_usize);
    let v7 = &constructor_gpr_to_imm8_gpr(ctx, arg1);
    let v8 = constructor_x64_shr(ctx, I64, v3, v7);
    let v9 = &constructor_gpr_to_imm8_gpr(ctx, arg1);
    let v10 = constructor_x64_shr(ctx, I64, v5, v9);
    let v12 = constructor_imm(ctx, I64, 0x40_u64);
    let v13 = C::gpr_new(ctx, v12);
    let v14 = &C::gpr_to_gpr_mem_imm(ctx, arg1);
    let v15 = constructor_x64_sub(ctx, I64, v13, v14);
    let v16 = &constructor_gpr_to_imm8_gpr(ctx, v15);
    let v17 = constructor_x64_shl(ctx, I64, v5, v16);
    let v19 = constructor_imm(ctx, I64, 0x0_u64);
    let v20 = C::gpr_new(ctx, v19);
    let v21 = &C::gpr_to_gpr_mem(ctx, arg1);
    let v23 = &constructor_x64_testq_mi(ctx, v21, 127_i32);
    let v25 = &C::gpr_to_gpr_mem(ctx, v20);
    let v26 = &constructor_cmove(ctx, I64, &CC::Z, v25, v17);
    let v27 = constructor_with_flags_reg(ctx, v23, v26);
    let v28 = C::gpr_new(ctx, v27);
    let v29 = &C::gpr_to_gpr_mem_imm(ctx, v8);
    let v30 = constructor_x64_or(ctx, I64, v28, v29);
    let v31 = &C::gpr_to_gpr_mem(ctx, arg1);
    let v33 = &constructor_x64_testq_mi(ctx, v31, 64_i32);
    let v34 = &C::gpr_to_gpr_mem(ctx, v30);
    let v35 = &constructor_cmove(ctx, I64, &CC::Z, v34, v10);
    let v36 = &C::gpr_to_gpr_mem(ctx, v10);
    let v37 = &constructor_cmove(ctx, I64, &CC::Z, v36, v20);
    let v38 = &constructor_consumes_flags_concat(ctx, v35, v37);
    let v39 = constructor_with_flags(ctx, v33, v38);
    // Rule at src/isa/x64/lower.isle line 682.
    return v39;
}

// Generated as internal constructor for term ushr_i8x16_mask.
pub fn constructor_ushr_i8x16_mask<C: Context>(
    ctx: &mut C,
    arg0: &RegMemImm,
) -> SyntheticAmode {
    match arg0 {
        &RegMemImm::Reg {
            reg: v3,
        } => {
            let v4 = &C::ushr_i8x16_mask_table(ctx);
            let v5 = constructor_x64_leaq_rm(ctx, v4);
            let v6 = C::gpr_new(ctx, v3);
            let v8 = constructor_x64_shlq_mi(ctx, v6, 0x4_u8);
            let v11 = C::mem_flags_trusted(ctx);
            let v12 = Amode::ImmRegRegShift {
                simm32: 0_i32,
                base: v5,
                index: v8,
                shift: 0x0_u8,
                flags: v11,
            };
            let v13 = &C::amode_to_synthetic_amode(ctx, &v12);
            // Rule at src/isa/x64/lower.isle line 753.
            return v13.clone();
        }
        &RegMemImm::Mem {
            addr: ref v14,
        } => {
            let v17 = constructor_x64_load(ctx, I64, v14, &ExtKind::None);
            let v18 = RegMemImm::Reg {
                reg: v17,
            };
            let v19 = &constructor_ushr_i8x16_mask(ctx, &v18);
            // Rule at src/isa/x64/lower.isle line 763.
            return v19.clone();
        }
        &RegMemImm::Imm {
            simm32: v1,
        } => {
            let v2 = &C::ushr_i8x16_mask_for_const(ctx, v1);
            // Rule at src/isa/x64/lower.isle line 744.
            return v2.clone();
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "ushr_i8x16_mask", "src/isa/x64/lower.isle line 738")
}

// Generated as internal constructor for term mask_xmm_shift.
pub fn constructor_mask_xmm_shift<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
) -> RegMemImm {
    let v11 = C::def_inst(ctx, arg1);
    if let Some(v12) = v11 {
        let v13 = &C::inst_data_value(ctx, v12);
        if let &InstructionData::UnaryImm {
            opcode: ref v14,
            imm: v15,
        } = v13 {
            if let &Opcode::Iconst = v14 {
                let v16 = C::shift_amount_masked(ctx, arg0, v15);
                let v17 = C::u8_into_u32(ctx, v16);
                let v18 = RegMemImm::Imm {
                    simm32: v17,
                };
                // Rule at src/isa/x64/lower.isle line 780.
                return v18;
            }
        }
    }
    let v3 = constructor_put_in_gpr(ctx, arg1);
    let v4 = C::shift_mask(ctx, arg0);
    let v5 = C::u8_into_u32(ctx, v4);
    let v6 = RegMemImm::Imm {
        simm32: v5,
    };
    let v7 = &C::gpr_mem_imm_new(ctx, &v6);
    let v8 = constructor_x64_and(ctx, I64, v3, v7);
    let v9 = C::gpr_to_reg(ctx, v8);
    let v10 = &C::reg_to_reg_mem_imm(ctx, v9);
    // Rule at src/isa/x64/lower.isle line 778.
    return v10.clone();
}

// Generated as internal constructor for term sar_i128.
pub fn constructor_sar_i128<C: Context>(
    ctx: &mut C,
    arg0: ValueRegs,
    arg1: Gpr,
) -> ValueRegs {
    let v3 = constructor_value_regs_get_gpr(ctx, arg0, 0x0_usize);
    let v5 = constructor_value_regs_get_gpr(ctx, arg0, 0x1_usize);
    let v7 = &constructor_gpr_to_imm8_gpr(ctx, arg1);
    let v8 = constructor_x64_shr(ctx, I64, v3, v7);
    let v9 = &constructor_gpr_to_imm8_gpr(ctx, arg1);
    let v10 = constructor_x64_sar(ctx, I64, v5, v9);
    let v12 = constructor_imm(ctx, I64, 0x40_u64);
    let v13 = C::gpr_new(ctx, v12);
    let v14 = &C::gpr_to_gpr_mem_imm(ctx, arg1);
    let v15 = constructor_x64_sub(ctx, I64, v13, v14);
    let v16 = &constructor_gpr_to_imm8_gpr(ctx, v15);
    let v17 = constructor_x64_shl(ctx, I64, v5, v16);
    let v18 = &C::gpr_to_gpr_mem(ctx, arg1);
    let v20 = &constructor_x64_testq_mi(ctx, v18, 127_i32);
    let v23 = constructor_imm(ctx, I64, 0x0_u64);
    let v24 = &C::reg_to_gpr_mem(ctx, v23);
    let v25 = &constructor_cmove(ctx, I64, &CC::Z, v24, v17);
    let v26 = constructor_with_flags_reg(ctx, v20, v25);
    let v27 = C::gpr_new(ctx, v26);
    let v28 = &C::gpr_to_gpr_mem_imm(ctx, v27);
    let v29 = constructor_x64_or(ctx, I64, v8, v28);
    let v31 = constructor_x64_sarq_mi(ctx, v5, 0x3f_u8);
    let v32 = &C::gpr_to_gpr_mem(ctx, arg1);
    let v34 = &constructor_x64_testq_mi(ctx, v32, 64_i32);
    let v35 = &C::gpr_to_gpr_mem(ctx, v29);
    let v36 = &constructor_cmove(ctx, I64, &CC::Z, v35, v10);
    let v37 = &C::gpr_to_gpr_mem(ctx, v10);
    let v38 = &constructor_cmove(ctx, I64, &CC::Z, v37, v31);
    let v39 = &constructor_consumes_flags_concat(ctx, v36, v38);
    let v40 = constructor_with_flags(ctx, v34, v39);
    // Rule at src/isa/x64/lower.isle line 794.
    return v40;
}

// Generated as internal constructor for term sshr_i8x16_bigger_shift.
pub fn constructor_sshr_i8x16_bigger_shift<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: &RegMemImm,
) -> XmmMemImm {
    match arg1 {
        &RegMemImm::Reg {
            reg: v7,
        } => {
            let v8 = C::gpr_new(ctx, v7);
            let v9 = RegMemImm::Imm {
                simm32: 0x8_u32,
            };
            let v10 = &C::gpr_mem_imm_new(ctx, &v9);
            let v11 = constructor_x64_add(ctx, arg0, v8, v10);
            let v12 = C::gpr_to_reg(ctx, v11);
            let v13 = RegMemImm::Reg {
                reg: v12,
            };
            let v14 = &constructor_mov_rmi_to_xmm(ctx, &v13);
            // Rule at src/isa/x64/lower.isle line 862.
            return v14.clone();
        }
        &RegMemImm::Mem {
            addr: ref v15,
        } => {
            let v17 = constructor_imm(ctx, arg0, 0x8_u64);
            let v18 = C::gpr_new(ctx, v17);
            let v19 = &C::gpr_mem_imm_new(ctx, arg1);
            let v20 = constructor_x64_add(ctx, arg0, v18, v19);
            let v21 = C::gpr_to_reg(ctx, v20);
            let v22 = RegMemImm::Reg {
                reg: v21,
            };
            let v23 = &constructor_mov_rmi_to_xmm(ctx, &v22);
            // Rule at src/isa/x64/lower.isle line 866.
            return v23.clone();
        }
        &RegMemImm::Imm {
            simm32: v2,
        } => {
            let v4 = C::u32_wrapping_add(ctx, v2, 0x8_u32);
            let v5 = RegMemImm::Imm {
                simm32: v4,
            };
            let v6 = &C::xmm_mem_imm_new(ctx, &v5);
            // Rule at src/isa/x64/lower.isle line 860.
            return v6.clone();
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "sshr_i8x16_bigger_shift", "src/isa/x64/lower.isle line 859")
}

// Generated as internal constructor for term lower_i64x2_sshr_imm.
pub fn constructor_lower_i64x2_sshr_imm<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: u32,
) -> Xmm {
    let v2 = C::u32_into_u64(ctx, arg1);
    let v4 = C::u64_lt(ctx, v2, 0x20_u64);
    if v4 == true {
        let v5 = &C::xmi_imm(ctx, arg1);
        let v6 = constructor_x64_psrad(ctx, arg0, v5);
        let v7 = &C::xmm_to_xmm_mem(ctx, v6);
        let v9 = constructor_x64_pshufd(ctx, v7, 0xed_u8);
        let v10 = &C::xmi_imm(ctx, arg1);
        let v11 = constructor_x64_psrlq(ctx, arg0, v10);
        let v12 = &C::xmm_to_xmm_mem(ctx, v11);
        let v14 = constructor_x64_pshufd(ctx, v12, 0xe8_u8);
        let v15 = &C::xmm_to_xmm_mem(ctx, v9);
        let v16 = constructor_x64_punpckldq(ctx, v14, v15);
        // Rule at src/isa/x64/lower.isle line 905.
        return v16;
    }
    if arg1 == 0x20_u32 {
        let v17 = &C::xmm_to_xmm_mem(ctx, arg0);
        let v18 = constructor_x64_pshufd(ctx, v17, 0xed_u8);
        let v20 = &C::xmi_imm(ctx, 0x1f_u32);
        let v21 = constructor_x64_psrad(ctx, arg0, v20);
        let v22 = &C::xmm_to_xmm_mem(ctx, v21);
        let v23 = constructor_x64_pshufd(ctx, v22, 0xed_u8);
        let v24 = &C::xmm_to_xmm_mem(ctx, v23);
        let v25 = constructor_x64_punpckldq(ctx, v18, v24);
        // Rule at src/isa/x64/lower.isle line 916.
        return v25;
    }
    let v26 = C::u64_lt(ctx, 0x20_u64, v2);
    if v26 == true {
        let v27 = &C::xmi_imm(ctx, 0x1f_u32);
        let v28 = constructor_x64_psrad(ctx, arg0, v27);
        let v29 = &C::xmm_to_xmm_mem(ctx, v28);
        let v30 = constructor_x64_pshufd(ctx, v29, 0xed_u8);
        let v32 = C::u32_wrapping_sub(ctx, arg1, 0x20_u32);
        let v33 = &C::xmi_imm(ctx, v32);
        let v34 = constructor_x64_psrad(ctx, arg0, v33);
        let v35 = &C::xmm_to_xmm_mem(ctx, v34);
        let v36 = constructor_x64_pshufd(ctx, v35, 0xed_u8);
        let v37 = &C::xmm_to_xmm_mem(ctx, v30);
        let v38 = constructor_x64_punpckldq(ctx, v36, v37);
        // Rule at src/isa/x64/lower.isle line 927.
        return v38;
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "lower_i64x2_sshr_imm", "src/isa/x64/lower.isle line 900")
}

// Generated as internal constructor for term lower_i64x2_sshr_gpr.
pub fn constructor_lower_i64x2_sshr_gpr<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: Gpr,
) -> Xmm {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg1);
    let v3 = constructor_x64_movq_to_xmm(ctx, v2);
    let v5 = constructor_flip_high_bit_mask(ctx, I64X2);
    let v6 = &C::xmm_to_xmm_mem_imm(ctx, v3);
    let v7 = constructor_x64_psrlq(ctx, v5, v6);
    let v8 = &C::xmm_to_xmm_mem_imm(ctx, v3);
    let v9 = constructor_x64_psrlq(ctx, arg0, v8);
    let v10 = &C::xmm_to_xmm_mem(ctx, v9);
    let v11 = constructor_x64_pxor(ctx, v7, v10);
    let v12 = &C::xmm_to_xmm_mem(ctx, v7);
    let v13 = constructor_x64_psubq(ctx, v11, v12);
    // Rule at src/isa/x64/lower.isle line 942.
    return v13;
}

// Generated as internal constructor for term imul128.
pub fn constructor_imul128<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: Gpr,
    arg2: &GprMem,
    arg3: &GprMem,
) -> ValueRegs {
    let v5 = constructor_x64_imul(ctx, I64, arg0, arg3);
    let v6 = constructor_x64_imul(ctx, I64, arg1, arg2);
    let v7 = &C::gpr_to_gpr_mem_imm(ctx, v6);
    let v8 = constructor_x64_add(ctx, I64, v5, v7);
    let v9 = false;
    let v10 = constructor_x64_mul(ctx, I64, v9, arg0, arg2);
    let v12 = constructor_value_regs_get_gpr(ctx, v10, 0x0_usize);
    let v14 = constructor_value_regs_get_gpr(ctx, v10, 0x1_usize);
    let v15 = &C::gpr_to_gpr_mem_imm(ctx, v14);
    let v16 = constructor_x64_add(ctx, I64, v8, v15);
    let v17 = constructor_value_gprs(ctx, v12, v16);
    // Rule at src/isa/x64/lower.isle line 1095.
    return v17;
}

// Generated as internal constructor for term lower_bmask.
pub fn constructor_lower_bmask<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Type,
    arg2: ValueRegs,
) -> ValueRegs {
    if arg0 == I128 {
        let v23 = constructor_lower_bmask(ctx, I64, arg1, arg2);
        let v24 = constructor_value_regs_get_gpr(ctx, v23, 0x0_usize);
        let v25 = C::gpr_to_reg(ctx, v24);
        let v26 = C::gpr_to_reg(ctx, v24);
        let v27 = C::value_regs(ctx, v25, v26);
        // Rule at src/isa/x64/lower.isle line 1460.
        return v27;
    }
    let v1 = C::fits_in_64(ctx, arg0);
    if let Some(v2) = v1 {
        if arg1 == I128 {
            let v8 = constructor_value_regs_get_gpr(ctx, arg2, 0x0_usize);
            let v16 = constructor_value_regs_get_gpr(ctx, arg2, 0x1_usize);
            let v18 = &C::gpr_to_gpr_mem_imm(ctx, v16);
            let v19 = constructor_x64_or(ctx, I64, v8, v18);
            let v20 = C::gpr_to_reg(ctx, v19);
            let v21 = C::value_reg(ctx, v20);
            let v22 = constructor_lower_bmask(ctx, v2, I64, v21);
            // Rule at src/isa/x64/lower.isle line 1452.
            return v22;
        }
        let v4 = C::fits_in_64(ctx, arg1);
        if let Some(v5) = v4 {
            let v8 = constructor_value_regs_get_gpr(ctx, arg2, 0x0_usize);
            let v9 = &constructor_x64_neg_paired(ctx, v5, v8);
            let v10 = &C::gpr_to_gpr_mem_imm(ctx, v8);
            let v11 = &constructor_x64_sbb_paired(ctx, v2, v8, v10);
            let v12 = constructor_with_flags(ctx, v9, v11);
            let v14 = C::value_regs_get(ctx, v12, 0x1_usize);
            let v15 = C::value_reg(ctx, v14);
            // Rule at src/isa/x64/lower.isle line 1441.
            return v15;
        }
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "lower_bmask", "src/isa/x64/lower.isle line 1429")
}

// Generated as internal constructor for term not_i128.
pub fn constructor_not_i128<C: Context>(
    ctx: &mut C,
    arg0: Value,
) -> ValueRegs {
    let v1 = C::put_in_regs(ctx, arg0);
    let v3 = constructor_value_regs_get_gpr(ctx, v1, 0x0_usize);
    let v5 = constructor_value_regs_get_gpr(ctx, v1, 0x1_usize);
    let v7 = constructor_x64_not(ctx, I64, v3);
    let v8 = constructor_x64_not(ctx, I64, v5);
    let v9 = constructor_value_gprs(ctx, v7, v8);
    // Rule at src/isa/x64/lower.isle line 1483.
    return v9;
}

// Generated as internal constructor for term all_ones_or_all_zeros.
pub fn constructor_all_ones_or_all_zeros<C: Context>(
    ctx: &mut C,
    arg0: Value,
) -> Option<bool> {
    let v1 = C::def_inst(ctx, arg0);
    if let Some(v2) = v1 {
        let v3 = &C::inst_data_value(ctx, v2);
        match v3 {
            &InstructionData::FloatCompare {
                opcode: ref v17,
                args: ref v18,
                cond: ref v19,
            } => {
                if let &Opcode::Fcmp = v17 {
                    let v10 = C::value_type(ctx, arg0);
                    let v11 = C::multi_lane(ctx, v10);
                    if let Some(v12) = v11 {
                        let v15 = true;
                        let v16 = Some(v15);
                        // Rule at src/isa/x64/lower.isle line 1529.
                        return v16;
                    }
                }
            }
            &InstructionData::IntCompare {
                opcode: ref v4,
                args: ref v5,
                cond: ref v6,
            } => {
                if let &Opcode::Icmp = v4 {
                    let v10 = C::value_type(ctx, arg0);
                    let v11 = C::multi_lane(ctx, v10);
                    if let Some(v12) = v11 {
                        let v15 = true;
                        let v16 = Some(v15);
                        // Rule at src/isa/x64/lower.isle line 1528.
                        return v16;
                    }
                }
            }
            &InstructionData::LoadNoOffset {
                opcode: ref v23,
                arg: v24,
                flags: v25,
            } => {
                if let &Opcode::Bitcast = v23 {
                    let v10 = C::value_type(ctx, arg0);
                    let v11 = C::multi_lane(ctx, v10);
                    if let Some(v12) = v11 {
                        let v26 = C::def_inst(ctx, v24);
                        if let Some(v27) = v26 {
                            let v28 = &C::inst_data_value(ctx, v27);
                            if let &InstructionData::FloatCompare {
                                opcode: ref v29,
                                args: ref v30,
                                cond: ref v31,
                            } = v28 {
                                if let &Opcode::Fcmp = v29 {
                                    let v15 = true;
                                    let v16 = Some(v15);
                                    // Rule at src/isa/x64/lower.isle line 1530.
                                    return v16;
                                }
                            }
                        }
                    }
                }
            }
            &InstructionData::UnaryConst {
                opcode: ref v35,
                constant_handle: v36,
            } => {
                if let &Opcode::Vconst = v35 {
                    let v37 = C::vconst_all_ones_or_all_zeros(ctx, v36);
                    if let Some(v38) = v37 {
                        let v15 = true;
                        let v16 = Some(v15);
                        // Rule at src/isa/x64/lower.isle line 1531.
                        return v16;
                    }
                }
            }
            _ => {}
        }
    }
    None
}

// Generated as internal constructor for term insert_i8x16_lane_pshufd_imm.
pub fn constructor_insert_i8x16_lane_pshufd_imm<C: Context>(
    ctx: &mut C,
    arg0: u8,
) -> u8 {
    match arg0 {
        0x0_u8 => {
            // Rule at src/isa/x64/lower.isle line 1630.
            return 0x54_u8;
        }
        0x1_u8 => {
            // Rule at src/isa/x64/lower.isle line 1631.
            return 0x51_u8;
        }
        0x2_u8 => {
            // Rule at src/isa/x64/lower.isle line 1632.
            return 0x45_u8;
        }
        0x3_u8 => {
            // Rule at src/isa/x64/lower.isle line 1633.
            return 0x15_u8;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "insert_i8x16_lane_pshufd_imm", "src/isa/x64/lower.isle line 1629")
}

// Generated as internal constructor for term f32x4_insertlane.
pub fn constructor_f32x4_insertlane<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: Xmm,
    arg2: u8,
) -> Xmm {
    let v3 = C::has_sse41(ctx);
    if v3 == true {
        let v4 = &C::xmm_to_xmm_mem(ctx, arg1);
        let v5 = C::sse_insertps_lane_imm(ctx, arg2);
        let v6 = constructor_x64_insertps(ctx, arg0, v4, v5);
        // Rule at src/isa/x64/lower.isle line 1699.
        return v6;
    }
    match arg2 {
        0x0_u8 => {
            let v7 = constructor_x64_movss_regmove(ctx, arg0, arg1);
            // Rule at src/isa/x64/lower.isle line 1708.
            return v7;
        }
        0x1_u8 => {
            let v8 = constructor_x64_movlhps(ctx, arg1, arg0);
            let v9 = &C::xmm_to_xmm_mem(ctx, arg0);
            let v11 = constructor_x64_shufps(ctx, v8, v9, 0xe2_u8);
            // Rule at src/isa/x64/lower.isle line 1714.
            return v11;
        }
        0x2_u8 => {
            let v12 = &C::xmm_to_xmm_mem(ctx, arg0);
            let v14 = constructor_x64_shufps(ctx, arg1, v12, 0x30_u8);
            let v15 = &C::xmm_to_xmm_mem(ctx, v14);
            let v17 = constructor_x64_shufps(ctx, arg0, v15, 0x84_u8);
            // Rule at src/isa/x64/lower.isle line 1721.
            return v17;
        }
        0x3_u8 => {
            let v12 = &C::xmm_to_xmm_mem(ctx, arg0);
            let v19 = constructor_x64_shufps(ctx, arg1, v12, 0xe4_u8);
            let v20 = &C::xmm_to_xmm_mem(ctx, v19);
            let v22 = constructor_x64_shufps(ctx, arg0, v20, 0x24_u8);
            // Rule at src/isa/x64/lower.isle line 1728.
            return v22;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "f32x4_insertlane", "src/isa/x64/lower.isle line 1696")
}

// Generated as internal constructor for term cmp_and_choose.
pub fn constructor_cmp_and_choose<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: &CC,
    arg2: Value,
    arg3: Value,
) -> ValueRegs {
    let v1 = C::fits_in_64(ctx, arg0);
    if let Some(v2) = v1 {
        let v6 = C::put_in_reg(ctx, arg2);
        let v7 = C::put_in_reg(ctx, arg3);
        let v8 = C::gpr_new(ctx, v7);
        let v9 = &constructor_reg_to_gpr_mem_imm(ctx, v6);
        let v10 = &constructor_x64_cmp(ctx, v2, v8, v9);
        let v11 = &C::reg_to_gpr_mem(ctx, v7);
        let v12 = C::gpr_new(ctx, v6);
        let v13 = &constructor_cmove(ctx, v2, arg1, v11, v12);
        let v14 = constructor_with_flags_reg(ctx, v10, v13);
        let v15 = C::value_reg(ctx, v14);
        // Rule at src/isa/x64/lower.isle line 1753.
        return v15;
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "cmp_and_choose", "src/isa/x64/lower.isle line 1752")
}

// Generated as internal constructor for term has_pmins.
pub fn constructor_has_pmins<C: Context>(
    ctx: &mut C,
    arg0: Type,
) -> bool {
    match arg0 {
        I16X8 => {
            let v1 = true;
            // Rule at src/isa/x64/lower.isle line 1778.
            return v1;
        }
        I64X2 => {
            let v2 = false;
            // Rule at src/isa/x64/lower.isle line 1779.
            return v2;
        }
        _ => {}
    }
    let v3 = C::has_sse41(ctx);
    // Rule at src/isa/x64/lower.isle line 1780.
    return v3;
}

// Generated as internal constructor for term has_pmaxs.
pub fn constructor_has_pmaxs<C: Context>(
    ctx: &mut C,
    arg0: Type,
) -> bool {
    match arg0 {
        I16X8 => {
            let v1 = true;
            // Rule at src/isa/x64/lower.isle line 1783.
            return v1;
        }
        I64X2 => {
            let v2 = false;
            // Rule at src/isa/x64/lower.isle line 1784.
            return v2;
        }
        _ => {}
    }
    let v3 = C::has_sse41(ctx);
    // Rule at src/isa/x64/lower.isle line 1785.
    return v3;
}

// Generated as internal constructor for term has_pmaxu.
pub fn constructor_has_pmaxu<C: Context>(
    ctx: &mut C,
    arg0: Type,
) -> bool {
    match arg0 {
        I8X16 => {
            let v1 = true;
            // Rule at src/isa/x64/lower.isle line 1788.
            return v1;
        }
        I64X2 => {
            let v2 = false;
            // Rule at src/isa/x64/lower.isle line 1789.
            return v2;
        }
        _ => {}
    }
    let v3 = C::has_sse41(ctx);
    // Rule at src/isa/x64/lower.isle line 1790.
    return v3;
}

// Generated as internal constructor for term has_pminu.
pub fn constructor_has_pminu<C: Context>(
    ctx: &mut C,
    arg0: Type,
) -> bool {
    match arg0 {
        I8X16 => {
            let v1 = true;
            // Rule at src/isa/x64/lower.isle line 1793.
            return v1;
        }
        I64X2 => {
            let v2 = false;
            // Rule at src/isa/x64/lower.isle line 1794.
            return v2;
        }
        _ => {}
    }
    let v3 = C::has_sse41(ctx);
    // Rule at src/isa/x64/lower.isle line 1795.
    return v3;
}

// Generated as internal constructor for term lower_vec_smax.
pub fn constructor_lower_vec_smax<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Xmm,
    arg2: Xmm,
) -> Xmm {
    let v3 = constructor_has_pmaxs(ctx, arg0);
    if v3 == true {
        let v4 = &C::xmm_to_xmm_mem(ctx, arg2);
        let v5 = constructor_x64_pmaxs(ctx, arg0, arg1, v4);
        // Rule at src/isa/x64/lower.isle line 1803.
        return v5;
    }
    let v4 = &C::xmm_to_xmm_mem(ctx, arg2);
    let v6 = constructor_x64_pcmpgt(ctx, arg0, arg1, v4);
    let v7 = &C::xmm_to_xmm_mem(ctx, arg1);
    let v8 = constructor_x64_pand(ctx, v6, v7);
    let v9 = &C::xmm_to_xmm_mem(ctx, arg2);
    let v10 = constructor_x64_pandn(ctx, v6, v9);
    let v11 = &C::xmm_to_xmm_mem(ctx, v10);
    let v12 = constructor_x64_por(ctx, v8, v11);
    // Rule at src/isa/x64/lower.isle line 1807.
    return v12;
}

// Generated as internal constructor for term flip_high_bit_mask.
pub fn constructor_flip_high_bit_mask<C: Context>(
    ctx: &mut C,
    arg0: Type,
) -> Xmm {
    match arg0 {
        I16X8 => {
            let v2 = C::emit_u128_le_const(ctx, 0x80008000800080008000800080008000_u128);
            let v3 = &constructor_const_to_xmm_mem(ctx, v2);
            let v4 = constructor_x64_movdqu_load(ctx, v3);
            // Rule at src/isa/x64/lower.isle line 1862.
            return v4;
        }
        I32X4 => {
            let v6 = C::emit_u128_le_const(ctx, 0x80000000800000008000000080000000_u128);
            let v7 = &constructor_const_to_xmm_mem(ctx, v6);
            let v8 = constructor_x64_movdqu_load(ctx, v7);
            // Rule at src/isa/x64/lower.isle line 1864.
            return v8;
        }
        I64X2 => {
            let v10 = C::emit_u128_le_const(ctx, 0x80000000000000008000000000000000_u128);
            let v11 = &constructor_const_to_xmm_mem(ctx, v10);
            let v12 = constructor_x64_movdqu_load(ctx, v11);
            // Rule at src/isa/x64/lower.isle line 1866.
            return v12;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "flip_high_bit_mask", "src/isa/x64/lower.isle line 1861")
}

// Generated as internal constructor for term trap_if_cond.
pub fn constructor_trap_if_cond<C: Context>(
    ctx: &mut C,
    arg0: &CondResult,
    arg1: &TrapCode,
) -> SideEffectNoResult {
    match arg0 {
        &CondResult::CC {
            producer: ref v1,
            cc: ref v2,
        } => {
            let v4 = &constructor_trap_if(ctx, v2, arg1);
            let v5 = &constructor_with_flags_side_effect(ctx, v1, v4);
            // Rule at src/isa/x64/lower.isle line 1906.
            return v5.clone();
        }
        &CondResult::And {
            producer: ref v6,
            cc1: ref v7,
            cc2: ref v8,
        } => {
            let v9 = &constructor_trap_if_and(ctx, v7, v8, arg1);
            let v10 = &constructor_with_flags_side_effect(ctx, v6, v9);
            // Rule at src/isa/x64/lower.isle line 1908.
            return v10.clone();
        }
        &CondResult::Or {
            producer: ref v11,
            cc1: ref v12,
            cc2: ref v13,
        } => {
            let v14 = &constructor_trap_if_or(ctx, v12, v13, arg1);
            let v15 = &constructor_with_flags_side_effect(ctx, v11, v14);
            // Rule at src/isa/x64/lower.isle line 1910.
            return v15.clone();
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "trap_if_cond", "src/isa/x64/lower.isle line 1905")
}

// Generated as internal constructor for term lower_select.
pub fn constructor_lower_select<C: Context>(
    ctx: &mut C,
    arg0: &CondResult,
    arg1: Value,
    arg2: Value,
) -> InstOutput {
    if let &CondResult::And {
        producer: ref v22,
        cc1: ref v23,
        cc2: ref v24,
    } = arg0 {
        let v25 = &constructor_cond_invert(ctx, arg0);
        let v26 = constructor_lower_select(ctx, v25, arg2, arg1);
        // Rule at src/isa/x64/lower.isle line 2197.
        return v26;
    }
    let v2 = C::value_type(ctx, arg1);
    if v2 == I128 {
        let v18 = C::put_in_regs(ctx, arg1);
        let v19 = C::put_in_regs(ctx, arg2);
        let v20 = constructor_lower_select128(ctx, arg0, v18, v19);
        let v21 = C::output(ctx, v20);
        // Rule at src/isa/x64/lower.isle line 2191.
        return v21;
    }
    let v12 = &C::type_register_class(ctx, v2);
    if let Some(v13) = v12 {
        if let &RegisterClass::Xmm = v13 {
            let v14 = constructor_put_in_xmm(ctx, arg1);
            let v15 = constructor_put_in_xmm(ctx, arg2);
            let v16 = constructor_lower_select_xmm(ctx, v2, arg0, v14, v15);
            let v17 = constructor_output_xmm(ctx, v16);
            // Rule at src/isa/x64/lower.isle line 2189.
            return v17;
        }
    }
    let v3 = C::ty_int(ctx, v2);
    if let Some(v4) = v3 {
        let v5 = C::fits_in_64(ctx, v4);
        if let Some(v6) = v5 {
            let v8 = &constructor_put_in_gpr_mem(ctx, arg1);
            let v9 = constructor_put_in_gpr(ctx, arg2);
            let v10 = constructor_lower_select_gpr(ctx, v6, arg0, v8, v9);
            let v11 = constructor_output_gpr(ctx, v10);
            // Rule at src/isa/x64/lower.isle line 2187.
            return v11;
        }
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "lower_select", "src/isa/x64/lower.isle line 2186")
}

// Generated as internal constructor for term lower_select_gpr.
pub fn constructor_lower_select_gpr<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: &CondResult,
    arg2: &GprMem,
    arg3: Gpr,
) -> Gpr {
    match arg1 {
        &CondResult::CC {
            producer: ref v2,
            cc: ref v3,
        } => {
            let v6 = &constructor_cmove(ctx, arg0, v3, arg2, arg3);
            let v7 = constructor_with_flags(ctx, v2, v6);
            let v9 = constructor_value_regs_get_gpr(ctx, v7, 0x0_usize);
            // Rule at src/isa/x64/lower.isle line 2201.
            return v9;
        }
        &CondResult::Or {
            producer: ref v10,
            cc1: ref v11,
            cc2: ref v12,
        } => {
            let v13 = &constructor_cmove(ctx, arg0, v11, arg2, arg3);
            let v14 = constructor_consumes_flags_get_reg(ctx, v13);
            let v15 = C::gpr_new(ctx, v14);
            let v16 = &constructor_cmove(ctx, arg0, v12, arg2, v15);
            let v17 = &constructor_consumes_flags_return_last(ctx, v13, v16);
            let v18 = constructor_with_flags(ctx, v10, v17);
            let v19 = C::value_regs_get(ctx, v18, 0x0_usize);
            let v20 = C::gpr_new(ctx, v19);
            // Rule at src/isa/x64/lower.isle line 2203.
            return v20;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "lower_select_gpr", "src/isa/x64/lower.isle line 2200")
}

// Generated as internal constructor for term lower_select_xmm.
pub fn constructor_lower_select_xmm<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: &CondResult,
    arg2: Xmm,
    arg3: Xmm,
) -> Xmm {
    match arg1 {
        &CondResult::CC {
            producer: ref v2,
            cc: ref v3,
        } => {
            let v6 = &constructor_cmove_xmm(ctx, arg0, v3, arg2, arg3);
            let v7 = constructor_with_flags(ctx, v2, v6);
            let v9 = C::value_regs_get(ctx, v7, 0x0_usize);
            let v10 = C::xmm_new(ctx, v9);
            // Rule at src/isa/x64/lower.isle line 2210.
            return v10;
        }
        &CondResult::Or {
            producer: ref v11,
            cc1: ref v12,
            cc2: ref v13,
        } => {
            let v14 = &constructor_cmove_xmm(ctx, arg0, v12, arg2, arg3);
            let v15 = constructor_consumes_flags_get_reg(ctx, v14);
            let v16 = C::xmm_new(ctx, v15);
            let v17 = &constructor_cmove_xmm(ctx, arg0, v13, arg2, v16);
            let v18 = &constructor_consumes_flags_return_last(ctx, v14, v17);
            let v19 = constructor_with_flags(ctx, v11, v18);
            let v20 = C::value_regs_get(ctx, v19, 0x0_usize);
            let v21 = C::xmm_new(ctx, v20);
            // Rule at src/isa/x64/lower.isle line 2212.
            return v21;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "lower_select_xmm", "src/isa/x64/lower.isle line 2209")
}

// Generated as internal constructor for term lower_select128.
pub fn constructor_lower_select128<C: Context>(
    ctx: &mut C,
    arg0: &CondResult,
    arg1: ValueRegs,
    arg2: ValueRegs,
) -> ValueRegs {
    match arg0 {
        &CondResult::CC {
            producer: ref v1,
            cc: ref v2,
        } => {
            let v5 = &constructor_cmove128(ctx, v2, arg1, arg2);
            let v6 = constructor_with_flags(ctx, v1, v5);
            // Rule at src/isa/x64/lower.isle line 2219.
            return v6;
        }
        &CondResult::Or {
            producer: ref v7,
            cc1: ref v8,
            cc2: ref v9,
        } => {
            let v10 = &constructor_cmove128(ctx, v8, arg1, arg2);
            let v11 = constructor_consumes_flags_get_regs(ctx, v10);
            let v12 = &constructor_cmove128(ctx, v9, arg1, v11);
            let v13 = &constructor_consumes_flags_return_last(ctx, v10, v12);
            let v14 = constructor_with_flags(ctx, v7, v13);
            // Rule at src/isa/x64/lower.isle line 2221.
            return v14;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "lower_select128", "src/isa/x64/lower.isle line 2218")
}

// Generated as internal constructor for term cmove128.
pub fn constructor_cmove128<C: Context>(
    ctx: &mut C,
    arg0: &CC,
    arg1: ValueRegs,
    arg2: ValueRegs,
) -> ConsumesFlags {
    let v5 = constructor_value_regs_get_gpr(ctx, arg1, 0x0_usize);
    let v6 = &C::gpr_to_gpr_mem(ctx, v5);
    let v7 = constructor_value_regs_get_gpr(ctx, arg2, 0x0_usize);
    let v8 = &constructor_cmove(ctx, I64, arg0, v6, v7);
    let v10 = constructor_value_regs_get_gpr(ctx, arg1, 0x1_usize);
    let v11 = &C::gpr_to_gpr_mem(ctx, v10);
    let v12 = constructor_value_regs_get_gpr(ctx, arg2, 0x1_usize);
    let v13 = &constructor_cmove(ctx, I64, arg0, v11, v12);
    let v14 = &constructor_consumes_flags_concat(ctx, v8, v13);
    // Rule at src/isa/x64/lower.isle line 2230.
    return v14.clone();
}

// Generated as internal constructor for term consumes_flags_return_last.
pub fn constructor_consumes_flags_return_last<C: Context>(
    ctx: &mut C,
    arg0: &ConsumesFlags,
    arg1: &ConsumesFlags,
) -> ConsumesFlags {
    match arg0 {
        &ConsumesFlags::ConsumesFlagsReturnsReg {
            inst: ref v1,
            result: v2,
        } => {
            if let &ConsumesFlags::ConsumesFlagsReturnsReg {
                inst: ref v4,
                result: v5,
            } = arg1 {
                let v6 = C::value_reg(ctx, v5);
                let v7 = ConsumesFlags::ConsumesFlagsTwiceReturnsValueRegs {
                    inst1: v1.clone(),
                    inst2: v4.clone(),
                    result: v6,
                };
                // Rule at src/isa/x64/lower.isle line 2239.
                return v7;
            }
        }
        &ConsumesFlags::ConsumesFlagsTwiceReturnsValueRegs {
            inst1: ref v8,
            inst2: ref v9,
            result: v10,
        } => {
            if let &ConsumesFlags::ConsumesFlagsTwiceReturnsValueRegs {
                inst1: ref v11,
                inst2: ref v12,
                result: v13,
            } = arg1 {
                let v14 = ConsumesFlags::ConsumesFlagsFourTimesReturnsValueRegs {
                    inst1: v8.clone(),
                    inst2: v9.clone(),
                    inst3: v11.clone(),
                    inst4: v12.clone(),
                    result: v13,
                };
                // Rule at src/isa/x64/lower.isle line 2243.
                return v14;
            }
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "consumes_flags_return_last", "src/isa/x64/lower.isle line 2238")
}

// Generated as internal constructor for term do_clz.
pub fn constructor_do_clz<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Type,
    arg2: Gpr,
) -> Gpr {
    let v3 = C::has_lzcnt(ctx);
    if v3 == true {
        let v4 = &C::gpr_to_gpr_mem(ctx, arg2);
        let v5 = constructor_x64_lzcnt(ctx, arg0, v4);
        // Rule at src/isa/x64/lower.isle line 2291.
        return v5;
    }
    let v8 = constructor_imm_i64(ctx, I64, -1_i64);
    let v9 = C::gpr_new(ctx, v8);
    let v10 = constructor_bsr_or_else(ctx, arg0, arg2, v9);
    let v11 = C::gpr_to_reg(ctx, v10);
    let v12 = C::ty_bits_u64(ctx, arg1);
    let v14 = C::u64_wrapping_sub(ctx, v12, 0x1_u64);
    let v15 = constructor_imm(ctx, arg0, v14);
    let v16 = C::gpr_new(ctx, v15);
    let v17 = &constructor_reg_to_gpr_mem_imm(ctx, v11);
    let v18 = constructor_x64_sub(ctx, arg0, v16, v17);
    // Rule at src/isa/x64/lower.isle line 2295.
    return v18;
}

// Generated as internal constructor for term do_ctz.
pub fn constructor_do_ctz<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Type,
    arg2: Gpr,
) -> Gpr {
    let v3 = C::has_bmi1(ctx);
    if v3 == true {
        let v4 = &C::gpr_to_gpr_mem(ctx, arg2);
        let v5 = constructor_x64_tzcnt(ctx, arg0, v4);
        // Rule at src/isa/x64/lower.isle line 2327.
        return v5;
    }
    let v7 = C::ty_bits_u64(ctx, arg1);
    let v8 = constructor_imm(ctx, I64, v7);
    let v9 = C::gpr_new(ctx, v8);
    let v10 = constructor_bsf_or_else(ctx, arg0, arg2, v9);
    // Rule at src/isa/x64/lower.isle line 2331.
    return v10;
}

// Generated as internal constructor for term do_cls.
pub fn constructor_do_cls<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Gpr,
) -> Gpr {
    let v3 = Imm8Gpr::Imm8 {
        imm: 0x1_u8,
    };
    let v4 = constructor_x64_sar(ctx, arg0, arg1, &v3);
    let v5 = C::gpr_to_reg(ctx, v4);
    let v6 = RegMemImm::Reg {
        reg: v5,
    };
    let v7 = &C::gpr_mem_imm_new(ctx, &v6);
    let v8 = constructor_x64_xor(ctx, arg0, arg1, v7);
    let v9 = constructor_do_clz(ctx, arg0, arg0, v8);
    let v11 = RegMemImm::Imm {
        simm32: 0x1_u32,
    };
    let v12 = &C::gpr_mem_imm_new(ctx, &v11);
    let v13 = constructor_x64_sub(ctx, arg0, v9, v12);
    // Rule at src/isa/x64/lower.isle line 2363.
    return v13;
}

// Generated as internal constructor for term do_popcnt.
pub fn constructor_do_popcnt<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Gpr,
) -> Gpr {
    match arg0 {
        I32 => {
            let v38 = constructor_x64_shrl_mi(ctx, arg1, 0x1_u8);
            let v41 = constructor_imm(ctx, I32, 0x77777777_u64);
            let v42 = C::gpr_new(ctx, v41);
            let v43 = &C::gpr_to_gpr_mem_imm(ctx, v42);
            let v44 = constructor_x64_and(ctx, I32, v38, v43);
            let v45 = &C::gpr_to_gpr_mem_imm(ctx, v44);
            let v46 = constructor_x64_sub(ctx, I32, arg1, v45);
            let v47 = constructor_x64_shrl_mi(ctx, v44, 0x1_u8);
            let v48 = &C::gpr_to_gpr_mem_imm(ctx, v42);
            let v49 = constructor_x64_and(ctx, I32, v47, v48);
            let v50 = &C::gpr_to_gpr_mem_imm(ctx, v49);
            let v51 = constructor_x64_sub(ctx, I32, v46, v50);
            let v52 = constructor_x64_shrl_mi(ctx, v49, 0x1_u8);
            let v53 = &C::gpr_to_gpr_mem_imm(ctx, v42);
            let v54 = constructor_x64_and(ctx, I32, v52, v53);
            let v55 = &C::gpr_to_gpr_mem_imm(ctx, v54);
            let v56 = constructor_x64_sub(ctx, I32, v51, v55);
            let v57 = constructor_x64_shrl_mi(ctx, v56, 0x4_u8);
            let v58 = &C::gpr_to_gpr_mem_imm(ctx, v56);
            let v59 = constructor_x64_add(ctx, I32, v57, v58);
            let v61 = RegMemImm::Imm {
                simm32: 0xf0f0f0f_u32,
            };
            let v62 = &C::gpr_mem_imm_new(ctx, &v61);
            let v63 = constructor_x64_and(ctx, I32, v59, v62);
            let v64 = &C::gpr_to_gpr_mem(ctx, v63);
            let v66 = constructor_x64_imul_imm(ctx, I32, v64, 16843009_i32);
            let v68 = constructor_x64_shrl_mi(ctx, v66, 0x18_u8);
            // Rule at src/isa/x64/lower.isle line 2446.
            return v68;
        }
        I64 => {
            let v3 = constructor_x64_shrq_mi(ctx, arg1, 0x1_u8);
            let v6 = constructor_imm(ctx, I64, 0x7777777777777777_u64);
            let v7 = C::gpr_new(ctx, v6);
            let v8 = &C::gpr_to_gpr_mem_imm(ctx, v7);
            let v9 = constructor_x64_and(ctx, I64, v3, v8);
            let v10 = &C::gpr_to_gpr_mem_imm(ctx, v9);
            let v11 = constructor_x64_sub(ctx, I64, arg1, v10);
            let v12 = constructor_x64_shrq_mi(ctx, v9, 0x1_u8);
            let v13 = &C::gpr_to_gpr_mem_imm(ctx, v7);
            let v14 = constructor_x64_and(ctx, I64, v12, v13);
            let v15 = &C::gpr_to_gpr_mem_imm(ctx, v14);
            let v16 = constructor_x64_sub(ctx, I64, v11, v15);
            let v17 = constructor_x64_shrq_mi(ctx, v14, 0x1_u8);
            let v18 = &C::gpr_to_gpr_mem_imm(ctx, v7);
            let v19 = constructor_x64_and(ctx, I64, v17, v18);
            let v20 = &C::gpr_to_gpr_mem_imm(ctx, v19);
            let v21 = constructor_x64_sub(ctx, I64, v16, v20);
            let v23 = constructor_x64_shrq_mi(ctx, v21, 0x4_u8);
            let v24 = &C::gpr_to_gpr_mem_imm(ctx, v21);
            let v25 = constructor_x64_add(ctx, I64, v23, v24);
            let v27 = constructor_imm(ctx, I64, 0xf0f0f0f0f0f0f0f_u64);
            let v28 = C::gpr_new(ctx, v27);
            let v29 = &C::gpr_to_gpr_mem_imm(ctx, v28);
            let v30 = constructor_x64_and(ctx, I64, v25, v29);
            let v32 = constructor_imm(ctx, I64, 0x101010101010101_u64);
            let v33 = C::gpr_new(ctx, v32);
            let v34 = &C::gpr_to_gpr_mem(ctx, v33);
            let v35 = constructor_x64_imul(ctx, I64, v30, v34);
            let v37 = constructor_x64_shrq_mi(ctx, v35, 0x38_u8);
            // Rule at src/isa/x64/lower.isle line 2405.
            return v37;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "do_popcnt", "src/isa/x64/lower.isle line 2404")
}

// Generated as internal constructor for term do_bitrev8.
pub fn constructor_do_bitrev8<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Gpr,
) -> Gpr {
    let v2 = C::ty_mask(ctx, arg0);
    let v4 = C::u64_and(ctx, v2, 0x5555555555555555_u64);
    let v5 = constructor_imm(ctx, arg0, v4);
    let v6 = C::gpr_new(ctx, v5);
    let v7 = &C::gpr_to_gpr_mem_imm(ctx, v6);
    let v8 = constructor_x64_and(ctx, arg0, arg1, v7);
    let v10 = Imm8Gpr::Imm8 {
        imm: 0x1_u8,
    };
    let v11 = constructor_x64_shr(ctx, arg0, arg1, &v10);
    let v12 = &C::gpr_to_gpr_mem_imm(ctx, v6);
    let v13 = constructor_x64_and(ctx, arg0, v11, v12);
    let v14 = constructor_x64_shl(ctx, arg0, v8, &v10);
    let v15 = &C::gpr_to_gpr_mem_imm(ctx, v13);
    let v16 = constructor_x64_or(ctx, arg0, v14, v15);
    let v18 = C::u64_and(ctx, v2, 0x3333333333333333_u64);
    let v19 = constructor_imm(ctx, arg0, v18);
    let v20 = C::gpr_new(ctx, v19);
    let v21 = &C::gpr_to_gpr_mem_imm(ctx, v20);
    let v22 = constructor_x64_and(ctx, arg0, v16, v21);
    let v24 = Imm8Gpr::Imm8 {
        imm: 0x2_u8,
    };
    let v25 = constructor_x64_shr(ctx, arg0, v16, &v24);
    let v26 = &C::gpr_to_gpr_mem_imm(ctx, v20);
    let v27 = constructor_x64_and(ctx, arg0, v25, v26);
    let v28 = constructor_x64_shl(ctx, arg0, v22, &v24);
    let v29 = &C::gpr_to_gpr_mem_imm(ctx, v27);
    let v30 = constructor_x64_or(ctx, arg0, v28, v29);
    let v32 = C::u64_and(ctx, v2, 0xf0f0f0f0f0f0f0f_u64);
    let v33 = constructor_imm(ctx, arg0, v32);
    let v34 = C::gpr_new(ctx, v33);
    let v35 = &C::gpr_to_gpr_mem_imm(ctx, v34);
    let v36 = constructor_x64_and(ctx, arg0, v30, v35);
    let v38 = Imm8Gpr::Imm8 {
        imm: 0x4_u8,
    };
    let v39 = constructor_x64_shr(ctx, arg0, v30, &v38);
    let v40 = &C::gpr_to_gpr_mem_imm(ctx, v34);
    let v41 = constructor_x64_and(ctx, arg0, v39, v40);
    let v42 = constructor_x64_shl(ctx, arg0, v36, &v38);
    let v43 = &C::gpr_to_gpr_mem_imm(ctx, v41);
    let v44 = constructor_x64_or(ctx, arg0, v42, v43);
    // Rule at src/isa/x64/lower.isle line 2538.
    return v44;
}

// Generated as internal constructor for term do_bitrev16.
pub fn constructor_do_bitrev16<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Gpr,
) -> Gpr {
    let v2 = constructor_do_bitrev8(ctx, arg0, arg1);
    let v3 = C::ty_mask(ctx, arg0);
    let v5 = C::u64_and(ctx, v3, 0xff00ff00ff00ff_u64);
    let v6 = constructor_imm(ctx, arg0, v5);
    let v7 = C::gpr_new(ctx, v6);
    let v8 = &C::gpr_to_gpr_mem_imm(ctx, v7);
    let v9 = constructor_x64_and(ctx, arg0, v2, v8);
    let v11 = Imm8Gpr::Imm8 {
        imm: 0x8_u8,
    };
    let v12 = constructor_x64_shr(ctx, arg0, v2, &v11);
    let v13 = &C::gpr_to_gpr_mem_imm(ctx, v7);
    let v14 = constructor_x64_and(ctx, arg0, v12, v13);
    let v15 = constructor_x64_shl(ctx, arg0, v9, &v11);
    let v16 = &C::gpr_to_gpr_mem_imm(ctx, v14);
    let v17 = constructor_x64_or(ctx, arg0, v15, v16);
    // Rule at src/isa/x64/lower.isle line 2561.
    return v17;
}

// Generated as internal constructor for term do_bitrev32.
pub fn constructor_do_bitrev32<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Gpr,
) -> Gpr {
    let v2 = constructor_do_bitrev16(ctx, arg0, arg1);
    let v3 = C::ty_mask(ctx, arg0);
    let v5 = C::u64_and(ctx, v3, 0xffff0000ffff_u64);
    let v6 = constructor_imm(ctx, arg0, v5);
    let v7 = C::gpr_new(ctx, v6);
    let v8 = &C::gpr_to_gpr_mem_imm(ctx, v7);
    let v9 = constructor_x64_and(ctx, arg0, v2, v8);
    let v11 = Imm8Gpr::Imm8 {
        imm: 0x10_u8,
    };
    let v12 = constructor_x64_shr(ctx, arg0, v2, &v11);
    let v13 = &C::gpr_to_gpr_mem_imm(ctx, v7);
    let v14 = constructor_x64_and(ctx, arg0, v12, v13);
    let v15 = constructor_x64_shl(ctx, arg0, v9, &v11);
    let v16 = &C::gpr_to_gpr_mem_imm(ctx, v14);
    let v17 = constructor_x64_or(ctx, arg0, v15, v16);
    // Rule at src/isa/x64/lower.isle line 2573.
    return v17;
}

// Generated as internal constructor for term do_bitrev64.
pub fn constructor_do_bitrev64<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Gpr,
) -> Gpr {
    if arg0 == I64 {
        let v2 = constructor_do_bitrev32(ctx, arg0, arg1);
        let v4 = constructor_imm(ctx, arg0, 0xffffffff_u64);
        let v5 = C::gpr_new(ctx, v4);
        let v6 = &C::gpr_to_gpr_mem_imm(ctx, v5);
        let v7 = constructor_x64_and(ctx, arg0, v2, v6);
        let v9 = constructor_x64_shrq_mi(ctx, v2, 0x20_u8);
        let v10 = constructor_x64_shlq_mi(ctx, v7, 0x20_u8);
        let v11 = &C::gpr_to_gpr_mem_imm(ctx, v9);
        let v12 = constructor_x64_or(ctx, arg0, v10, v11);
        // Rule at src/isa/x64/lower.isle line 2585.
        return v12;
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "do_bitrev64", "src/isa/x64/lower.isle line 2584")
}

// Generated as internal constructor for term fmadd.
pub fn constructor_fmadd<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
    arg3: Value,
) -> Xmm {
    let v24 = C::def_inst(ctx, arg2);
    if let Some(v25) = v24 {
        let v26 = &C::inst_data_value(ctx, v25);
        if let &InstructionData::Unary {
            opcode: ref v27,
            arg: v28,
        } = v26 {
            if let &Opcode::Fneg = v27 {
                let v29 = constructor_fnmadd(ctx, arg0, arg1, v28, arg3);
                // Rule at src/isa/x64/lower.isle line 3010.
                return v29;
            }
        }
    }
    let v18 = C::def_inst(ctx, arg1);
    if let Some(v19) = v18 {
        let v20 = &C::inst_data_value(ctx, v19);
        if let &InstructionData::Unary {
            opcode: ref v21,
            arg: v22,
        } = v20 {
            if let &Opcode::Fneg = v21 {
                let v23 = constructor_fnmadd(ctx, arg0, v22, arg2, arg3);
                // Rule at src/isa/x64/lower.isle line 3009.
                return v23;
            }
        }
    }
    let v14 = &C::sinkable_load(ctx, arg2);
    if let Some(v15) = v14 {
        let v4 = constructor_put_in_xmm(ctx, arg1);
        let v11 = constructor_put_in_xmm(ctx, arg3);
        let v16 = &constructor_sink_load_to_xmm_mem(ctx, v15);
        let v17 = constructor_x64_vfmadd132(ctx, arg0, v4, v11, v16);
        // Rule at src/isa/x64/lower.isle line 3005.
        return v17;
    }
    let v8 = &C::sinkable_load(ctx, arg1);
    if let Some(v9) = v8 {
        let v10 = constructor_put_in_xmm(ctx, arg2);
        let v11 = constructor_put_in_xmm(ctx, arg3);
        let v12 = &constructor_sink_load_to_xmm_mem(ctx, v9);
        let v13 = constructor_x64_vfmadd132(ctx, arg0, v10, v11, v12);
        // Rule at src/isa/x64/lower.isle line 3004.
        return v13;
    }
    let v4 = constructor_put_in_xmm(ctx, arg1);
    let v5 = constructor_put_in_xmm(ctx, arg2);
    let v6 = &C::put_in_xmm_mem(ctx, arg3);
    let v7 = constructor_x64_vfmadd213(ctx, arg0, v4, v5, v6);
    // Rule at src/isa/x64/lower.isle line 2999.
    return v7;
}

// Generated as internal constructor for term fnmadd.
pub fn constructor_fnmadd<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
    arg3: Value,
) -> Xmm {
    let v14 = &C::sinkable_load(ctx, arg2);
    if let Some(v15) = v14 {
        let v4 = constructor_put_in_xmm(ctx, arg1);
        let v11 = constructor_put_in_xmm(ctx, arg3);
        let v16 = &constructor_sink_load_to_xmm_mem(ctx, v15);
        let v17 = constructor_x64_vfnmadd132(ctx, arg0, v4, v11, v16);
        // Rule at src/isa/x64/lower.isle line 3014.
        return v17;
    }
    let v8 = &C::sinkable_load(ctx, arg1);
    if let Some(v9) = v8 {
        let v10 = constructor_put_in_xmm(ctx, arg2);
        let v11 = constructor_put_in_xmm(ctx, arg3);
        let v12 = &constructor_sink_load_to_xmm_mem(ctx, v9);
        let v13 = constructor_x64_vfnmadd132(ctx, arg0, v10, v11, v12);
        // Rule at src/isa/x64/lower.isle line 3013.
        return v13;
    }
    let v4 = constructor_put_in_xmm(ctx, arg1);
    let v5 = constructor_put_in_xmm(ctx, arg2);
    let v6 = &C::put_in_xmm_mem(ctx, arg3);
    let v7 = constructor_x64_vfnmadd213(ctx, arg0, v4, v5, v6);
    // Rule at src/isa/x64/lower.isle line 3012.
    return v7;
}

// Generated as internal constructor for term fmsub.
pub fn constructor_fmsub<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
    arg3: Value,
) -> Xmm {
    let v24 = C::def_inst(ctx, arg2);
    if let Some(v25) = v24 {
        let v26 = &C::inst_data_value(ctx, v25);
        if let &InstructionData::Unary {
            opcode: ref v27,
            arg: v28,
        } = v26 {
            if let &Opcode::Fneg = v27 {
                let v29 = constructor_fnmsub(ctx, arg0, arg1, v28, arg3);
                // Rule at src/isa/x64/lower.isle line 3037.
                return v29;
            }
        }
    }
    let v18 = C::def_inst(ctx, arg1);
    if let Some(v19) = v18 {
        let v20 = &C::inst_data_value(ctx, v19);
        if let &InstructionData::Unary {
            opcode: ref v21,
            arg: v22,
        } = v20 {
            if let &Opcode::Fneg = v21 {
                let v23 = constructor_fnmsub(ctx, arg0, v22, arg2, arg3);
                // Rule at src/isa/x64/lower.isle line 3036.
                return v23;
            }
        }
    }
    let v14 = &C::sinkable_load(ctx, arg2);
    if let Some(v15) = v14 {
        let v4 = constructor_put_in_xmm(ctx, arg1);
        let v11 = constructor_put_in_xmm(ctx, arg3);
        let v16 = &constructor_sink_load_to_xmm_mem(ctx, v15);
        let v17 = constructor_x64_vfmsub132(ctx, arg0, v4, v11, v16);
        // Rule at src/isa/x64/lower.isle line 3032.
        return v17;
    }
    let v8 = &C::sinkable_load(ctx, arg1);
    if let Some(v9) = v8 {
        let v10 = constructor_put_in_xmm(ctx, arg2);
        let v11 = constructor_put_in_xmm(ctx, arg3);
        let v12 = &constructor_sink_load_to_xmm_mem(ctx, v9);
        let v13 = constructor_x64_vfmsub132(ctx, arg0, v10, v11, v12);
        // Rule at src/isa/x64/lower.isle line 3031.
        return v13;
    }
    let v4 = constructor_put_in_xmm(ctx, arg1);
    let v5 = constructor_put_in_xmm(ctx, arg2);
    let v6 = &C::put_in_xmm_mem(ctx, arg3);
    let v7 = constructor_x64_vfmsub213(ctx, arg0, v4, v5, v6);
    // Rule at src/isa/x64/lower.isle line 3026.
    return v7;
}

// Generated as internal constructor for term fnmsub.
pub fn constructor_fnmsub<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
    arg3: Value,
) -> Xmm {
    let v14 = &C::sinkable_load(ctx, arg2);
    if let Some(v15) = v14 {
        let v4 = constructor_put_in_xmm(ctx, arg1);
        let v11 = constructor_put_in_xmm(ctx, arg3);
        let v16 = &constructor_sink_load_to_xmm_mem(ctx, v15);
        let v17 = constructor_x64_vfnmsub132(ctx, arg0, v4, v11, v16);
        // Rule at src/isa/x64/lower.isle line 3041.
        return v17;
    }
    let v8 = &C::sinkable_load(ctx, arg1);
    if let Some(v9) = v8 {
        let v10 = constructor_put_in_xmm(ctx, arg2);
        let v11 = constructor_put_in_xmm(ctx, arg3);
        let v12 = &constructor_sink_load_to_xmm_mem(ctx, v9);
        let v13 = constructor_x64_vfnmsub132(ctx, arg0, v10, v11, v12);
        // Rule at src/isa/x64/lower.isle line 3040.
        return v13;
    }
    let v4 = constructor_put_in_xmm(ctx, arg1);
    let v5 = constructor_put_in_xmm(ctx, arg2);
    let v6 = &C::put_in_xmm_mem(ctx, arg3);
    let v7 = constructor_x64_vfnmsub213(ctx, arg0, v4, v5, v6);
    // Rule at src/isa/x64/lower.isle line 3039.
    return v7;
}

// Generated as internal constructor for term lower_select_spectre_gpr.
pub fn constructor_lower_select_spectre_gpr<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: &CondResult,
    arg2: Gpr,
    arg3: Gpr,
) -> Gpr {
    if let &CondResult::And {
        producer: ref v6,
        cc1: ref v7,
        cc2: ref v8,
    } = arg1 {
        let v9 = &constructor_cond_invert(ctx, arg1);
        let v10 = &C::gpr_to_gpr_mem(ctx, arg3);
        let v11 = constructor_lower_select_gpr(ctx, arg0, v9, v10, arg2);
        // Rule at src/isa/x64/lower.isle line 3664.
        return v11;
    }
    let v4 = &C::gpr_to_gpr_mem(ctx, arg2);
    let v5 = constructor_lower_select_gpr(ctx, arg0, arg1, v4, arg3);
    // Rule at src/isa/x64/lower.isle line 3663.
    return v5;
}

// Generated as internal constructor for term lower_swiden_low.
pub fn constructor_lower_swiden_low<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Xmm,
) -> Xmm {
    match arg0 {
        I16X8 => {
            let v2 = &C::xmm_to_xmm_mem(ctx, arg1);
            let v3 = constructor_x64_punpcklbw(ctx, arg1, v2);
            let v5 = &C::xmi_imm(ctx, 0x8_u32);
            let v6 = constructor_x64_psraw(ctx, v3, v5);
            // Rule at src/isa/x64/lower.isle line 4101.
            return v6;
        }
        I32X4 => {
            let v2 = &C::xmm_to_xmm_mem(ctx, arg1);
            let v7 = constructor_x64_punpcklwd(ctx, arg1, v2);
            let v9 = &C::xmi_imm(ctx, 0x10_u32);
            let v10 = constructor_x64_psrad(ctx, v7, v9);
            // Rule at src/isa/x64/lower.isle line 4103.
            return v10;
        }
        I64X2 => {
            let v12 = constructor_xmm_zero(ctx, I32X4);
            let v13 = &constructor_xmm_to_xmm_mem_aligned(ctx, arg1);
            let v14 = constructor_x64_pcmpgtd_a(ctx, v12, v13);
            let v15 = &C::xmm_to_xmm_mem(ctx, v14);
            let v16 = constructor_x64_punpckldq(ctx, arg1, v15);
            // Rule at src/isa/x64/lower.isle line 4109.
            return v16;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "lower_swiden_low", "src/isa/x64/lower.isle line 4096")
}

// Generated as internal constructor for term lower_uwiden_low.
pub fn constructor_lower_uwiden_low<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Xmm,
) -> Xmm {
    match arg0 {
        I16X8 => {
            let v3 = constructor_xmm_zero(ctx, I8X16);
            let v4 = &C::xmm_to_xmm_mem(ctx, v3);
            let v5 = constructor_x64_punpcklbw(ctx, arg1, v4);
            // Rule at src/isa/x64/lower.isle line 4164.
            return v5;
        }
        I32X4 => {
            let v3 = constructor_xmm_zero(ctx, I8X16);
            let v4 = &C::xmm_to_xmm_mem(ctx, v3);
            let v6 = constructor_x64_punpcklwd(ctx, arg1, v4);
            // Rule at src/isa/x64/lower.isle line 4165.
            return v6;
        }
        I64X2 => {
            let v8 = constructor_xmm_zero(ctx, F32X4);
            let v9 = &C::xmm_to_xmm_mem(ctx, v8);
            let v10 = constructor_x64_unpcklps(ctx, arg1, v9);
            // Rule at src/isa/x64/lower.isle line 4166.
            return v10;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "lower_uwiden_low", "src/isa/x64/lower.isle line 4163")
}

// Generated as internal constructor for term unarrow_i32x4_lanes_to_low_u16_lanes.
pub fn constructor_unarrow_i32x4_lanes_to_low_u16_lanes<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
) -> Xmm {
    let v2 = constructor_xmm_zero(ctx, I32X4);
    let v3 = &C::xmm_to_xmm_mem(ctx, v2);
    let v4 = constructor_x64_pcmpgtd_a_or_avx(ctx, arg0, v3);
    let v5 = &C::xmm_to_xmm_mem(ctx, v4);
    let v6 = constructor_x64_pand(ctx, arg0, v5);
    let v8 = C::emit_u128_le_const(ctx, 0xffff0000ffff0000ffff0000ffff_u128);
    let v9 = &constructor_const_to_xmm_mem(ctx, v8);
    let v10 = constructor_x64_movdqu_load(ctx, v9);
    let v11 = &C::xmm_to_xmm_mem(ctx, v6);
    let v12 = constructor_x64_pcmpgtd_a_or_avx(ctx, v10, v11);
    let v13 = &C::xmm_to_xmm_mem(ctx, v12);
    let v14 = constructor_x64_pand(ctx, v6, v13);
    let v15 = &C::xmm_to_xmm_mem(ctx, v10);
    let v16 = constructor_x64_pandn(ctx, v12, v15);
    let v17 = &C::xmm_to_xmm_mem(ctx, v16);
    let v18 = constructor_x64_por(ctx, v14, v17);
    let v19 = &C::xmm_to_xmm_mem(ctx, v18);
    let v21 = constructor_x64_pshuflw(ctx, v19, 0x8_u8);
    let v22 = &C::xmm_to_xmm_mem(ctx, v21);
    let v23 = constructor_x64_pshufhw(ctx, v22, 0x8_u8);
    let v24 = &C::xmm_to_xmm_mem(ctx, v23);
    let v25 = constructor_x64_pshufd(ctx, v24, 0x8_u8);
    // Rule at src/isa/x64/lower.isle line 4246.
    return v25;
}

// Generated as internal constructor for term x64_round.
pub fn constructor_x64_round<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: &RegMem,
    arg2: &RoundImm,
) -> Xmm {
    match arg0 {
        F32 => {
            let v3 = C::has_sse41(ctx);
            if v3 == true {
                let v4 = &C::reg_mem_to_xmm_mem(ctx, arg1);
                let v5 = constructor_x64_roundss(ctx, v4, arg2);
                // Rule at src/isa/x64/lower.isle line 4322.
                return v5;
            }
            if let &RegMem::Reg {
                reg: v9,
            } = arg1 {
                let v11 = &constructor_round_libcall(ctx, F32, arg2);
                let v12 = C::libcall_1(ctx, v11, v9);
                let v13 = C::xmm_new(ctx, v12);
                // Rule at src/isa/x64/lower.isle line 4335.
                return v13;
            }
        }
        F64 => {
            let v3 = C::has_sse41(ctx);
            if v3 == true {
                let v4 = &C::reg_mem_to_xmm_mem(ctx, arg1);
                let v6 = constructor_x64_roundsd(ctx, v4, arg2);
                // Rule at src/isa/x64/lower.isle line 4325.
                return v6;
            }
            if let &RegMem::Reg {
                reg: v9,
            } = arg1 {
                let v15 = &constructor_round_libcall(ctx, F64, arg2);
                let v16 = C::libcall_1(ctx, v15, v9);
                let v17 = C::xmm_new(ctx, v16);
                // Rule at src/isa/x64/lower.isle line 4336.
                return v17;
            }
        }
        F32X4 => {
            let v3 = C::has_sse41(ctx);
            if v3 == true {
                let v4 = &C::reg_mem_to_xmm_mem(ctx, arg1);
                let v7 = constructor_x64_roundps(ctx, v4, arg2);
                // Rule at src/isa/x64/lower.isle line 4328.
                return v7;
            }
            if let &RegMem::Reg {
                reg: v9,
            } = arg1 {
                let v11 = &constructor_round_libcall(ctx, F32, arg2);
                let v12 = C::libcall_1(ctx, v11, v9);
                let v13 = C::xmm_new(ctx, v12);
                let v18 = &constructor_reg_to_xmm_mem(ctx, v9);
                let v20 = constructor_x64_pshufd(ctx, v18, 0x1_u8);
                let v21 = C::xmm_to_reg(ctx, v20);
                let v22 = C::libcall_1(ctx, v11, v21);
                let v23 = C::xmm_new(ctx, v22);
                let v24 = constructor_f32x4_insertlane(ctx, v13, v23, 0x1_u8);
                let v25 = &constructor_reg_to_xmm_mem(ctx, v9);
                let v27 = constructor_x64_pshufd(ctx, v25, 0x2_u8);
                let v28 = C::xmm_to_reg(ctx, v27);
                let v29 = C::libcall_1(ctx, v11, v28);
                let v30 = C::xmm_new(ctx, v29);
                let v31 = constructor_f32x4_insertlane(ctx, v24, v30, 0x2_u8);
                let v32 = &constructor_reg_to_xmm_mem(ctx, v9);
                let v34 = constructor_x64_pshufd(ctx, v32, 0x3_u8);
                let v35 = C::xmm_to_reg(ctx, v34);
                let v36 = C::libcall_1(ctx, v11, v35);
                let v37 = C::xmm_new(ctx, v36);
                let v38 = constructor_f32x4_insertlane(ctx, v31, v37, 0x3_u8);
                // Rule at src/isa/x64/lower.isle line 4337.
                return v38;
            }
        }
        F64X2 => {
            let v3 = C::has_sse41(ctx);
            if v3 == true {
                let v4 = &C::reg_mem_to_xmm_mem(ctx, arg1);
                let v8 = constructor_x64_roundpd(ctx, v4, arg2);
                // Rule at src/isa/x64/lower.isle line 4331.
                return v8;
            }
            if let &RegMem::Reg {
                reg: v9,
            } = arg1 {
                let v15 = &constructor_round_libcall(ctx, F64, arg2);
                let v16 = C::libcall_1(ctx, v15, v9);
                let v17 = C::xmm_new(ctx, v16);
                let v18 = &constructor_reg_to_xmm_mem(ctx, v9);
                let v40 = constructor_x64_pshufd(ctx, v18, 0xe_u8);
                let v41 = C::xmm_to_reg(ctx, v40);
                let v42 = C::libcall_1(ctx, v15, v41);
                let v43 = C::xmm_new(ctx, v42);
                let v44 = constructor_x64_movlhps(ctx, v17, v43);
                // Rule at src/isa/x64/lower.isle line 4349.
                return v44;
            }
        }
        _ => {}
    }
    if let &RegMem::Mem {
        addr: ref v45,
    } = arg1 {
        let v47 = constructor_x64_load(ctx, arg0, v45, &ExtKind::ZeroExtend);
        let v48 = RegMem::Reg {
            reg: v47,
        };
        let v49 = constructor_x64_round(ctx, arg0, &v48, arg2);
        // Rule at src/isa/x64/lower.isle line 4356.
        return v49;
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_round", "src/isa/x64/lower.isle line 4321")
}

// Generated as internal constructor for term round_libcall.
pub fn constructor_round_libcall<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: &RoundImm,
) -> LibCall {
    match arg0 {
        F32 => {
            match arg1 {
                &RoundImm::RoundNearest => {
                    // Rule at src/isa/x64/lower.isle line 4364.
                    return LibCall::NearestF32;
                }
                &RoundImm::RoundDown => {
                    // Rule at src/isa/x64/lower.isle line 4362.
                    return LibCall::FloorF32;
                }
                &RoundImm::RoundUp => {
                    // Rule at src/isa/x64/lower.isle line 4360.
                    return LibCall::CeilF32;
                }
                &RoundImm::RoundZero => {
                    // Rule at src/isa/x64/lower.isle line 4366.
                    return LibCall::TruncF32;
                }
                _ => {}
            }
        }
        F64 => {
            match arg1 {
                &RoundImm::RoundNearest => {
                    // Rule at src/isa/x64/lower.isle line 4365.
                    return LibCall::NearestF64;
                }
                &RoundImm::RoundDown => {
                    // Rule at src/isa/x64/lower.isle line 4363.
                    return LibCall::FloorF64;
                }
                &RoundImm::RoundUp => {
                    // Rule at src/isa/x64/lower.isle line 4361.
                    return LibCall::CeilF64;
                }
                &RoundImm::RoundZero => {
                    // Rule at src/isa/x64/lower.isle line 4367.
                    return LibCall::TruncF64;
                }
                _ => {}
            }
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "round_libcall", "src/isa/x64/lower.isle line 4359")
}

// Generated as internal constructor for term repeat_sign_bit.
pub fn constructor_repeat_sign_bit<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Gpr,
) -> Gpr {
    match arg0 {
        I16 => {
            let v2 = constructor_x64_cwtd_zo(ctx, arg1);
            // Rule at src/isa/x64/lower.isle line 4438.
            return v2;
        }
        I32 => {
            let v3 = constructor_x64_cltd_zo(ctx, arg1);
            // Rule at src/isa/x64/lower.isle line 4439.
            return v3;
        }
        I64 => {
            let v4 = constructor_x64_cqto_zo(ctx, arg1);
            // Rule at src/isa/x64/lower.isle line 4440.
            return v4;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "repeat_sign_bit", "src/isa/x64/lower.isle line 4437")
}

// Generated as internal constructor for term nonzero_sdiv_divisor.
pub fn constructor_nonzero_sdiv_divisor<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
) -> Reg {
    let v2 = C::def_inst(ctx, arg1);
    if let Some(v3) = v2 {
        let v4 = &C::inst_data_value(ctx, v3);
        if let &InstructionData::UnaryImm {
            opcode: ref v5,
            imm: v6,
        } = v4 {
            if let &Opcode::Iconst = v5 {
                let v7 = C::safe_divisor_from_imm64(ctx, arg0, v6);
                if let Some(v8) = v7 {
                    let v9 = constructor_imm(ctx, arg0, v8);
                    // Rule at src/isa/x64/lower.isle line 4447.
                    return v9;
                }
            }
        }
    }
    let v10 = C::put_in_reg(ctx, arg1);
    let v11 = C::gpr_new(ctx, v10);
    let v12 = &constructor_reg_to_gpr_mem_imm(ctx, v10);
    let v13 = &constructor_x64_test(ctx, arg0, v11, v12);
    let v16 = &constructor_trap_if(ctx, &CC::Z, &TrapCode::INTEGER_DIVISION_BY_ZERO);
    let v17 = &constructor_with_flags_side_effect(ctx, v13, v16);
    let v18 = constructor_side_effect(ctx, v17);
    // Rule at src/isa/x64/lower.isle line 4450.
    return v10;
}

// Generated as internal constructor for term lower_pshufb.
pub fn constructor_lower_pshufb<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &RegMem,
) -> Xmm {
    let v2 = C::has_ssse3(ctx);
    if v2 == true {
        let v3 = &C::reg_mem_to_xmm_mem(ctx, arg1);
        let v4 = constructor_x64_pshufb(ctx, arg0, v3);
        // Rule at src/isa/x64/lower.isle line 4731.
        return v4;
    }
    match arg1 {
        &RegMem::Reg {
            reg: v5,
        } => {
            let v7 = C::xmm_to_reg(ctx, arg0);
            let v8 = C::libcall_2(ctx, &LibCall::X86Pshufb, v7, v5);
            let v9 = C::xmm_new(ctx, v8);
            // Rule at src/isa/x64/lower.isle line 4734.
            return v9;
        }
        &RegMem::Mem {
            addr: ref v10,
        } => {
            let v11 = &constructor_synthetic_amode_to_xmm_mem(ctx, v10);
            let v12 = constructor_x64_movdqu_load(ctx, v11);
            let v13 = C::xmm_to_reg(ctx, v12);
            let v14 = &constructor_xmm_to_reg_mem(ctx, v13);
            let v15 = &C::xmm_mem_to_reg_mem(ctx, v14);
            let v16 = constructor_lower_pshufb(ctx, arg0, v15);
            // Rule at src/isa/x64/lower.isle line 4736.
            return v16;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "lower_pshufb", "src/isa/x64/lower.isle line 4730")
}

// Generated as internal constructor for term is_vany_true.
pub fn constructor_is_vany_true<C: Context>(
    ctx: &mut C,
    arg0: Value,
) -> CondResult {
    let v12 = C::has_sse41(ctx);
    if v12 == true {
        let v1 = constructor_put_in_xmm(ctx, arg0);
        let v13 = &C::xmm_to_xmm_mem(ctx, v1);
        let v14 = &constructor_x64_ptest(ctx, v1, v13);
        let v15 = CondResult::CC {
            producer: v14.clone(),
            cc: CC::NZ,
        };
        // Rule at src/isa/x64/lower.isle line 4927.
        return v15;
    }
    let v1 = constructor_put_in_xmm(ctx, arg0);
    let v3 = constructor_xmm_zero(ctx, I8X16);
    let v4 = &C::xmm_to_xmm_mem(ctx, v3);
    let v5 = constructor_x64_pcmpeqb(ctx, v1, v4);
    let v6 = constructor_x64_pmovmskb(ctx, v5);
    let v7 = &C::gpr_to_gpr_mem(ctx, v6);
    let v9 = &constructor_x64_cmpl_mi(ctx, v7, 0xffff_u32);
    let v11 = CondResult::CC {
        producer: v9.clone(),
        cc: CC::NZ,
    };
    // Rule at src/isa/x64/lower.isle line 4921.
    return v11;
}

// Generated as internal constructor for term is_vall_true.
pub fn constructor_is_vall_true<C: Context>(
    ctx: &mut C,
    arg0: Value,
) -> CondResult {
    let v2 = C::has_sse41(ctx);
    if v2 == true {
        let v3 = constructor_put_in_xmm(ctx, arg0);
        let v1 = C::value_type(ctx, arg0);
        let v4 = constructor_xmm_zero(ctx, v1);
        let v5 = constructor_vec_int_type(ctx, v1);
        let v6 = &C::xmm_to_xmm_mem(ctx, v4);
        let v7 = constructor_x64_pcmpeq(ctx, v5, v3, v6);
        let v8 = &C::xmm_to_xmm_mem(ctx, v7);
        let v9 = &constructor_x64_ptest(ctx, v7, v8);
        let v11 = CondResult::CC {
            producer: v9.clone(),
            cc: CC::Z,
        };
        // Rule at src/isa/x64/lower.isle line 4937.
        return v11;
    }
    let v1 = C::value_type(ctx, arg0);
    let v12 = constructor_vec_int_type(ctx, v1);
    let v13 = constructor_put_in_xmm(ctx, arg0);
    let v14 = constructor_xmm_zero(ctx, v1);
    let v15 = &C::xmm_to_xmm_mem(ctx, v14);
    let v16 = constructor_x64_pcmpeq(ctx, v12, v13, v15);
    let v17 = constructor_x64_pmovmskb(ctx, v16);
    let v18 = &C::gpr_to_gpr_mem(ctx, v17);
    let v19 = &constructor_x64_testl_mr(ctx, v18, v17);
    let v20 = CondResult::CC {
        producer: v19.clone(),
        cc: CC::Z,
    };
    // Rule at src/isa/x64/lower.isle line 4947.
    return v20;
}

// Generated as internal constructor for term emit_ret_gpr.
pub fn constructor_emit_ret_gpr<C: Context>(
    ctx: &mut C,
    arg0: &AssemblerOutputs,
) -> Gpr {
    if let &AssemblerOutputs::RetGpr {
        inst: ref v1,
        gpr: v2,
    } = arg0 {
        let v3 = C::emit(ctx, v1);
        // Rule at <OUT_DIR>/assembler.isle line 19.
        return v2;
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "emit_ret_gpr", "<OUT_DIR>/assembler.isle line 18")
}

// Generated as internal constructor for term emit_ret_xmm.
pub fn constructor_emit_ret_xmm<C: Context>(
    ctx: &mut C,
    arg0: &AssemblerOutputs,
) -> Xmm {
    if let &AssemblerOutputs::RetXmm {
        inst: ref v1,
        xmm: v2,
    } = arg0 {
        let v3 = C::emit(ctx, v1);
        // Rule at <OUT_DIR>/assembler.isle line 25.
        return v2;
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "emit_ret_xmm", "<OUT_DIR>/assembler.isle line 24")
}

// Generated as internal constructor for term emit_ret_value_regs.
pub fn constructor_emit_ret_value_regs<C: Context>(
    ctx: &mut C,
    arg0: &AssemblerOutputs,
) -> ValueRegs {
    if let &AssemblerOutputs::RetValueRegs {
        inst: ref v1,
        regs: v2,
    } = arg0 {
        let v3 = C::emit(ctx, v1);
        // Rule at <OUT_DIR>/assembler.isle line 31.
        return v2;
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "emit_ret_value_regs", "<OUT_DIR>/assembler.isle line 30")
}

// Generated as internal constructor for term defer_side_effect.
pub fn constructor_defer_side_effect<C: Context>(
    ctx: &mut C,
    arg0: &AssemblerOutputs,
) -> SideEffectNoResult {
    if let &AssemblerOutputs::SideEffect {
        inst: ref v1,
    } = arg0 {
        let v2 = SideEffectNoResult::Inst {
            inst: v1.clone(),
        };
        // Rule at <OUT_DIR>/assembler.isle line 37.
        return v2;
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "defer_side_effect", "<OUT_DIR>/assembler.isle line 36")
}

// Generated as internal constructor for term x64_pabsb_a.
pub fn constructor_x64_pabsb_a<C: Context>(
    ctx: &mut C,
    arg0: &XmmMemAligned,
) -> Xmm {
    let v1 = &C::x64_pabsb_a_raw(ctx, arg0);
    let v2 = constructor_emit_ret_xmm(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 43.
    return v2;
}

// Generated as internal constructor for term x64_pabsb_a_or_avx.
pub fn constructor_x64_pabsb_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = C::has_avx(ctx);
    if v1 == true {
        let v2 = constructor_x64_vpabsb_a(ctx, arg0);
        // Rule at <OUT_DIR>/assembler.isle line 45.
        return v2;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg0);
    let v4 = constructor_x64_pabsb_a(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 48.
    return v4;
}

// Generated as internal constructor for term x64_vpabsb_a.
pub fn constructor_x64_vpabsb_a<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = &C::x64_vpabsb_a_raw(ctx, arg0);
    let v2 = constructor_emit_ret_xmm(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 53.
    return v2;
}

// Generated as internal constructor for term x64_pabsw_a.
pub fn constructor_x64_pabsw_a<C: Context>(
    ctx: &mut C,
    arg0: &XmmMemAligned,
) -> Xmm {
    let v1 = &C::x64_pabsw_a_raw(ctx, arg0);
    let v2 = constructor_emit_ret_xmm(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 58.
    return v2;
}

// Generated as internal constructor for term x64_pabsw_a_or_avx.
pub fn constructor_x64_pabsw_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = C::has_avx(ctx);
    if v1 == true {
        let v2 = constructor_x64_vpabsw_a(ctx, arg0);
        // Rule at <OUT_DIR>/assembler.isle line 60.
        return v2;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg0);
    let v4 = constructor_x64_pabsw_a(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 63.
    return v4;
}

// Generated as internal constructor for term x64_vpabsw_a.
pub fn constructor_x64_vpabsw_a<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = &C::x64_vpabsw_a_raw(ctx, arg0);
    let v2 = constructor_emit_ret_xmm(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 68.
    return v2;
}

// Generated as internal constructor for term x64_pabsd_a.
pub fn constructor_x64_pabsd_a<C: Context>(
    ctx: &mut C,
    arg0: &XmmMemAligned,
) -> Xmm {
    let v1 = &C::x64_pabsd_a_raw(ctx, arg0);
    let v2 = constructor_emit_ret_xmm(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 73.
    return v2;
}

// Generated as internal constructor for term x64_pabsd_a_or_avx.
pub fn constructor_x64_pabsd_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = C::has_avx(ctx);
    if v1 == true {
        let v2 = constructor_x64_vpabsd_a(ctx, arg0);
        // Rule at <OUT_DIR>/assembler.isle line 75.
        return v2;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg0);
    let v4 = constructor_x64_pabsd_a(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 78.
    return v4;
}

// Generated as internal constructor for term x64_vpabsd_a.
pub fn constructor_x64_vpabsd_a<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = &C::x64_vpabsd_a_raw(ctx, arg0);
    let v2 = constructor_emit_ret_xmm(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 83.
    return v2;
}

// Generated as internal constructor for term x64_vpabsd_c.
pub fn constructor_x64_vpabsd_c<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = &C::x64_vpabsd_c_raw(ctx, arg0);
    let v2 = constructor_emit_ret_xmm(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 88.
    return v2;
}

// Generated as internal constructor for term x64_vpabsq_c.
pub fn constructor_x64_vpabsq_c<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = &C::x64_vpabsq_c_raw(ctx, arg0);
    let v2 = constructor_emit_ret_xmm(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 93.
    return v2;
}

// Generated as internal constructor for term x64_addb_i.
pub fn constructor_x64_addb_i<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: u8,
) -> Gpr {
    let v2 = &C::x64_addb_i_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 98.
    return v3;
}

// Generated as internal constructor for term x64_addw_i.
pub fn constructor_x64_addw_i<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: u16,
) -> Gpr {
    let v2 = &C::x64_addw_i_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 103.
    return v3;
}

// Generated as internal constructor for term x64_addl_i.
pub fn constructor_x64_addl_i<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: u32,
) -> Gpr {
    let v2 = &C::x64_addl_i_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 108.
    return v3;
}

// Generated as internal constructor for term x64_addq_i_sxl.
pub fn constructor_x64_addq_i_sxl<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: i32,
) -> Gpr {
    let v2 = &C::x64_addq_i_sxl_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 113.
    return v3;
}

// Generated as internal constructor for term x64_addb_mi.
pub fn constructor_x64_addb_mi<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: u8,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_addb_mi_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 118.
    return v4;
}

// Generated as internal constructor for term x64_addb_mi_mem.
pub fn constructor_x64_addb_mi_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: u8,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_addb_mi_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 120.
    return v4.clone();
}

// Generated as internal constructor for term x64_addw_mi.
pub fn constructor_x64_addw_mi<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: u16,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_addw_mi_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 125.
    return v4;
}

// Generated as internal constructor for term x64_addw_mi_mem.
pub fn constructor_x64_addw_mi_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: u16,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_addw_mi_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 127.
    return v4.clone();
}

// Generated as internal constructor for term x64_addl_mi.
pub fn constructor_x64_addl_mi<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: u32,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_addl_mi_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 132.
    return v4;
}

// Generated as internal constructor for term x64_addl_mi_mem.
pub fn constructor_x64_addl_mi_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: u32,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_addl_mi_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 134.
    return v4.clone();
}

// Generated as internal constructor for term x64_addq_mi_sxl.
pub fn constructor_x64_addq_mi_sxl<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: i32,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_addq_mi_sxl_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 139.
    return v4;
}

// Generated as internal constructor for term x64_addq_mi_sxl_mem.
pub fn constructor_x64_addq_mi_sxl_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: i32,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_addq_mi_sxl_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 141.
    return v4.clone();
}

// Generated as internal constructor for term x64_addl_mi_sxb.
pub fn constructor_x64_addl_mi_sxb<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: i8,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_addl_mi_sxb_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 146.
    return v4;
}

// Generated as internal constructor for term x64_addl_mi_sxb_mem.
pub fn constructor_x64_addl_mi_sxb_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: i8,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_addl_mi_sxb_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 148.
    return v4.clone();
}

// Generated as internal constructor for term x64_addq_mi_sxb.
pub fn constructor_x64_addq_mi_sxb<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: i8,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_addq_mi_sxb_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 153.
    return v4;
}

// Generated as internal constructor for term x64_addq_mi_sxb_mem.
pub fn constructor_x64_addq_mi_sxb_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: i8,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_addq_mi_sxb_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 155.
    return v4.clone();
}

// Generated as internal constructor for term x64_addb_mr.
pub fn constructor_x64_addb_mr<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: Gpr,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_addb_mr_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 160.
    return v4;
}

// Generated as internal constructor for term x64_addb_mr_mem.
pub fn constructor_x64_addb_mr_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Gpr,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_addb_mr_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 162.
    return v4.clone();
}

// Generated as internal constructor for term x64_addw_mr.
pub fn constructor_x64_addw_mr<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: Gpr,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_addw_mr_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 167.
    return v4;
}

// Generated as internal constructor for term x64_addw_mr_mem.
pub fn constructor_x64_addw_mr_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Gpr,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_addw_mr_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 169.
    return v4.clone();
}

// Generated as internal constructor for term x64_addl_mr.
pub fn constructor_x64_addl_mr<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: Gpr,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_addl_mr_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 174.
    return v4;
}

// Generated as internal constructor for term x64_addl_mr_mem.
pub fn constructor_x64_addl_mr_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Gpr,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_addl_mr_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 176.
    return v4.clone();
}

// Generated as internal constructor for term x64_addq_mr.
pub fn constructor_x64_addq_mr<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: Gpr,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_addq_mr_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 181.
    return v4;
}

// Generated as internal constructor for term x64_addq_mr_mem.
pub fn constructor_x64_addq_mr_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Gpr,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_addq_mr_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 183.
    return v4.clone();
}

// Generated as internal constructor for term x64_addb_rm.
pub fn constructor_x64_addb_rm<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
) -> Gpr {
    let v2 = &C::x64_addb_rm_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 188.
    return v3;
}

// Generated as internal constructor for term x64_addw_rm.
pub fn constructor_x64_addw_rm<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
) -> Gpr {
    let v2 = &C::x64_addw_rm_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 193.
    return v3;
}

// Generated as internal constructor for term x64_addl_rm.
pub fn constructor_x64_addl_rm<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
) -> Gpr {
    let v2 = &C::x64_addl_rm_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 198.
    return v3;
}

// Generated as internal constructor for term x64_addq_rm.
pub fn constructor_x64_addq_rm<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
) -> Gpr {
    let v2 = &C::x64_addq_rm_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 203.
    return v3;
}

// Generated as internal constructor for term x64_adcb_i.
pub fn constructor_x64_adcb_i<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: u8,
) -> Gpr {
    let v2 = &C::x64_adcb_i_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 208.
    return v3;
}

// Generated as internal constructor for term x64_adcw_i.
pub fn constructor_x64_adcw_i<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: u16,
) -> Gpr {
    let v2 = &C::x64_adcw_i_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 213.
    return v3;
}

// Generated as internal constructor for term x64_adcl_i.
pub fn constructor_x64_adcl_i<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: u32,
) -> Gpr {
    let v2 = &C::x64_adcl_i_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 218.
    return v3;
}

// Generated as internal constructor for term x64_adcq_i_sxl.
pub fn constructor_x64_adcq_i_sxl<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: i32,
) -> Gpr {
    let v2 = &C::x64_adcq_i_sxl_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 223.
    return v3;
}

// Generated as internal constructor for term x64_adcb_mi.
pub fn constructor_x64_adcb_mi<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: u8,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_adcb_mi_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 228.
    return v4;
}

// Generated as internal constructor for term x64_adcb_mi_mem.
pub fn constructor_x64_adcb_mi_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: u8,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_adcb_mi_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 230.
    return v4.clone();
}

// Generated as internal constructor for term x64_adcw_mi.
pub fn constructor_x64_adcw_mi<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: u16,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_adcw_mi_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 235.
    return v4;
}

// Generated as internal constructor for term x64_adcw_mi_mem.
pub fn constructor_x64_adcw_mi_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: u16,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_adcw_mi_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 237.
    return v4.clone();
}

// Generated as internal constructor for term x64_adcl_mi.
pub fn constructor_x64_adcl_mi<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: u32,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_adcl_mi_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 242.
    return v4;
}

// Generated as internal constructor for term x64_adcl_mi_mem.
pub fn constructor_x64_adcl_mi_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: u32,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_adcl_mi_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 244.
    return v4.clone();
}

// Generated as internal constructor for term x64_adcq_mi_sxl.
pub fn constructor_x64_adcq_mi_sxl<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: i32,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_adcq_mi_sxl_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 249.
    return v4;
}

// Generated as internal constructor for term x64_adcq_mi_sxl_mem.
pub fn constructor_x64_adcq_mi_sxl_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: i32,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_adcq_mi_sxl_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 251.
    return v4.clone();
}

// Generated as internal constructor for term x64_adcl_mi_sxb.
pub fn constructor_x64_adcl_mi_sxb<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: i8,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_adcl_mi_sxb_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 256.
    return v4;
}

// Generated as internal constructor for term x64_adcl_mi_sxb_mem.
pub fn constructor_x64_adcl_mi_sxb_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: i8,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_adcl_mi_sxb_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 258.
    return v4.clone();
}

// Generated as internal constructor for term x64_adcq_mi_sxb.
pub fn constructor_x64_adcq_mi_sxb<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: i8,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_adcq_mi_sxb_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 263.
    return v4;
}

// Generated as internal constructor for term x64_adcq_mi_sxb_mem.
pub fn constructor_x64_adcq_mi_sxb_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: i8,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_adcq_mi_sxb_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 265.
    return v4.clone();
}

// Generated as internal constructor for term x64_adcb_mr.
pub fn constructor_x64_adcb_mr<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: Gpr,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_adcb_mr_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 270.
    return v4;
}

// Generated as internal constructor for term x64_adcb_mr_mem.
pub fn constructor_x64_adcb_mr_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Gpr,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_adcb_mr_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 272.
    return v4.clone();
}

// Generated as internal constructor for term x64_adcw_mr.
pub fn constructor_x64_adcw_mr<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: Gpr,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_adcw_mr_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 277.
    return v4;
}

// Generated as internal constructor for term x64_adcw_mr_mem.
pub fn constructor_x64_adcw_mr_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Gpr,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_adcw_mr_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 279.
    return v4.clone();
}

// Generated as internal constructor for term x64_adcl_mr.
pub fn constructor_x64_adcl_mr<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: Gpr,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_adcl_mr_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 284.
    return v4;
}

// Generated as internal constructor for term x64_adcl_mr_mem.
pub fn constructor_x64_adcl_mr_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Gpr,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_adcl_mr_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 286.
    return v4.clone();
}

// Generated as internal constructor for term x64_adcq_mr.
pub fn constructor_x64_adcq_mr<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: Gpr,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_adcq_mr_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 291.
    return v4;
}

// Generated as internal constructor for term x64_adcq_mr_mem.
pub fn constructor_x64_adcq_mr_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Gpr,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_adcq_mr_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 293.
    return v4.clone();
}

// Generated as internal constructor for term x64_adcb_rm.
pub fn constructor_x64_adcb_rm<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
) -> Gpr {
    let v2 = &C::x64_adcb_rm_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 298.
    return v3;
}

// Generated as internal constructor for term x64_adcw_rm.
pub fn constructor_x64_adcw_rm<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
) -> Gpr {
    let v2 = &C::x64_adcw_rm_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 303.
    return v3;
}

// Generated as internal constructor for term x64_adcl_rm.
pub fn constructor_x64_adcl_rm<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
) -> Gpr {
    let v2 = &C::x64_adcl_rm_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 308.
    return v3;
}

// Generated as internal constructor for term x64_adcq_rm.
pub fn constructor_x64_adcq_rm<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
) -> Gpr {
    let v2 = &C::x64_adcq_rm_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 313.
    return v3;
}

// Generated as internal constructor for term x64_lock_addb_mi_mem.
pub fn constructor_x64_lock_addb_mi_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: u8,
) -> SideEffectNoResult {
    let v2 = &C::x64_lock_addb_mi_raw(ctx, arg0, arg1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 318.
    return v3.clone();
}

// Generated as internal constructor for term x64_lock_addw_mi_mem.
pub fn constructor_x64_lock_addw_mi_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: u16,
) -> SideEffectNoResult {
    let v2 = &C::x64_lock_addw_mi_raw(ctx, arg0, arg1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 323.
    return v3.clone();
}

// Generated as internal constructor for term x64_lock_addl_mi_mem.
pub fn constructor_x64_lock_addl_mi_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: u32,
) -> SideEffectNoResult {
    let v2 = &C::x64_lock_addl_mi_raw(ctx, arg0, arg1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 328.
    return v3.clone();
}

// Generated as internal constructor for term x64_lock_addq_mi_sxl_mem.
pub fn constructor_x64_lock_addq_mi_sxl_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: i32,
) -> SideEffectNoResult {
    let v2 = &C::x64_lock_addq_mi_sxl_raw(ctx, arg0, arg1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 333.
    return v3.clone();
}

// Generated as internal constructor for term x64_lock_addl_mi_sxb_mem.
pub fn constructor_x64_lock_addl_mi_sxb_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: i8,
) -> SideEffectNoResult {
    let v2 = &C::x64_lock_addl_mi_sxb_raw(ctx, arg0, arg1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 338.
    return v3.clone();
}

// Generated as internal constructor for term x64_lock_addq_mi_sxb_mem.
pub fn constructor_x64_lock_addq_mi_sxb_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: i8,
) -> SideEffectNoResult {
    let v2 = &C::x64_lock_addq_mi_sxb_raw(ctx, arg0, arg1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 343.
    return v3.clone();
}

// Generated as internal constructor for term x64_lock_addb_mr_mem.
pub fn constructor_x64_lock_addb_mr_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Gpr,
) -> SideEffectNoResult {
    let v2 = &C::x64_lock_addb_mr_raw(ctx, arg0, arg1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 348.
    return v3.clone();
}

// Generated as internal constructor for term x64_lock_addw_mr_mem.
pub fn constructor_x64_lock_addw_mr_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Gpr,
) -> SideEffectNoResult {
    let v2 = &C::x64_lock_addw_mr_raw(ctx, arg0, arg1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 353.
    return v3.clone();
}

// Generated as internal constructor for term x64_lock_addl_mr_mem.
pub fn constructor_x64_lock_addl_mr_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Gpr,
) -> SideEffectNoResult {
    let v2 = &C::x64_lock_addl_mr_raw(ctx, arg0, arg1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 358.
    return v3.clone();
}

// Generated as internal constructor for term x64_lock_addq_mr_mem.
pub fn constructor_x64_lock_addq_mr_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Gpr,
) -> SideEffectNoResult {
    let v2 = &C::x64_lock_addq_mr_raw(ctx, arg0, arg1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 363.
    return v3.clone();
}

// Generated as internal constructor for term x64_lock_adcb_mi_mem.
pub fn constructor_x64_lock_adcb_mi_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: u8,
) -> SideEffectNoResult {
    let v2 = &C::x64_lock_adcb_mi_raw(ctx, arg0, arg1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 368.
    return v3.clone();
}

// Generated as internal constructor for term x64_lock_adcw_mi_mem.
pub fn constructor_x64_lock_adcw_mi_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: u16,
) -> SideEffectNoResult {
    let v2 = &C::x64_lock_adcw_mi_raw(ctx, arg0, arg1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 373.
    return v3.clone();
}

// Generated as internal constructor for term x64_lock_adcl_mi_mem.
pub fn constructor_x64_lock_adcl_mi_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: u32,
) -> SideEffectNoResult {
    let v2 = &C::x64_lock_adcl_mi_raw(ctx, arg0, arg1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 378.
    return v3.clone();
}

// Generated as internal constructor for term x64_lock_adcq_mi_sxl_mem.
pub fn constructor_x64_lock_adcq_mi_sxl_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: i32,
) -> SideEffectNoResult {
    let v2 = &C::x64_lock_adcq_mi_sxl_raw(ctx, arg0, arg1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 383.
    return v3.clone();
}

// Generated as internal constructor for term x64_lock_adcl_mi_sxb_mem.
pub fn constructor_x64_lock_adcl_mi_sxb_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: i8,
) -> SideEffectNoResult {
    let v2 = &C::x64_lock_adcl_mi_sxb_raw(ctx, arg0, arg1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 388.
    return v3.clone();
}

// Generated as internal constructor for term x64_lock_adcq_mi_sxb_mem.
pub fn constructor_x64_lock_adcq_mi_sxb_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: i8,
) -> SideEffectNoResult {
    let v2 = &C::x64_lock_adcq_mi_sxb_raw(ctx, arg0, arg1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 393.
    return v3.clone();
}

// Generated as internal constructor for term x64_lock_adcb_mr_mem.
pub fn constructor_x64_lock_adcb_mr_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Gpr,
) -> SideEffectNoResult {
    let v2 = &C::x64_lock_adcb_mr_raw(ctx, arg0, arg1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 398.
    return v3.clone();
}

// Generated as internal constructor for term x64_lock_adcw_mr_mem.
pub fn constructor_x64_lock_adcw_mr_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Gpr,
) -> SideEffectNoResult {
    let v2 = &C::x64_lock_adcw_mr_raw(ctx, arg0, arg1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 403.
    return v3.clone();
}

// Generated as internal constructor for term x64_lock_adcl_mr_mem.
pub fn constructor_x64_lock_adcl_mr_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Gpr,
) -> SideEffectNoResult {
    let v2 = &C::x64_lock_adcl_mr_raw(ctx, arg0, arg1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 408.
    return v3.clone();
}

// Generated as internal constructor for term x64_lock_adcq_mr_mem.
pub fn constructor_x64_lock_adcq_mr_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Gpr,
) -> SideEffectNoResult {
    let v2 = &C::x64_lock_adcq_mr_raw(ctx, arg0, arg1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 413.
    return v3.clone();
}

// Generated as internal constructor for term x64_lock_xaddb_mr.
pub fn constructor_x64_lock_xaddb_mr<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Gpr,
) -> Gpr {
    let v2 = &C::x64_lock_xaddb_mr_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 418.
    return v3;
}

// Generated as internal constructor for term x64_lock_xaddw_mr.
pub fn constructor_x64_lock_xaddw_mr<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Gpr,
) -> Gpr {
    let v2 = &C::x64_lock_xaddw_mr_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 423.
    return v3;
}

// Generated as internal constructor for term x64_lock_xaddl_mr.
pub fn constructor_x64_lock_xaddl_mr<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Gpr,
) -> Gpr {
    let v2 = &C::x64_lock_xaddl_mr_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 428.
    return v3;
}

// Generated as internal constructor for term x64_lock_xaddq_mr.
pub fn constructor_x64_lock_xaddq_mr<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Gpr,
) -> Gpr {
    let v2 = &C::x64_lock_xaddq_mr_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 433.
    return v3;
}

// Generated as internal constructor for term x64_addss_a.
pub fn constructor_x64_addss_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_addss_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 438.
    return v3;
}

// Generated as internal constructor for term x64_addss_a_or_avx.
pub fn constructor_x64_addss_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vaddss_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 440.
        return v3;
    }
    let v4 = constructor_x64_addss_a(ctx, arg0, arg1);
    // Rule at <OUT_DIR>/assembler.isle line 443.
    return v4;
}

// Generated as internal constructor for term x64_addsd_a.
pub fn constructor_x64_addsd_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_addsd_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 448.
    return v3;
}

// Generated as internal constructor for term x64_addsd_a_or_avx.
pub fn constructor_x64_addsd_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vaddsd_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 450.
        return v3;
    }
    let v4 = constructor_x64_addsd_a(ctx, arg0, arg1);
    // Rule at <OUT_DIR>/assembler.isle line 453.
    return v4;
}

// Generated as internal constructor for term x64_addps_a.
pub fn constructor_x64_addps_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_addps_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 458.
    return v3;
}

// Generated as internal constructor for term x64_addps_a_or_avx.
pub fn constructor_x64_addps_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vaddps_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 460.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_addps_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 463.
    return v5;
}

// Generated as internal constructor for term x64_addpd_a.
pub fn constructor_x64_addpd_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_addpd_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 468.
    return v3;
}

// Generated as internal constructor for term x64_addpd_a_or_avx.
pub fn constructor_x64_addpd_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vaddpd_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 470.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_addpd_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 473.
    return v5;
}

// Generated as internal constructor for term x64_paddb_a.
pub fn constructor_x64_paddb_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_paddb_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 478.
    return v3;
}

// Generated as internal constructor for term x64_paddb_a_or_avx.
pub fn constructor_x64_paddb_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vpaddb_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 480.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_paddb_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 483.
    return v5;
}

// Generated as internal constructor for term x64_paddw_a.
pub fn constructor_x64_paddw_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_paddw_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 488.
    return v3;
}

// Generated as internal constructor for term x64_paddw_a_or_avx.
pub fn constructor_x64_paddw_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vpaddw_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 490.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_paddw_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 493.
    return v5;
}

// Generated as internal constructor for term x64_paddd_a.
pub fn constructor_x64_paddd_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_paddd_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 498.
    return v3;
}

// Generated as internal constructor for term x64_paddd_a_or_avx.
pub fn constructor_x64_paddd_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vpaddd_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 500.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_paddd_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 503.
    return v5;
}

// Generated as internal constructor for term x64_paddq_a.
pub fn constructor_x64_paddq_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_paddq_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 508.
    return v3;
}

// Generated as internal constructor for term x64_paddq_a_or_avx.
pub fn constructor_x64_paddq_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vpaddq_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 510.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_paddq_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 513.
    return v5;
}

// Generated as internal constructor for term x64_paddsb_a.
pub fn constructor_x64_paddsb_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_paddsb_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 518.
    return v3;
}

// Generated as internal constructor for term x64_paddsb_a_or_avx.
pub fn constructor_x64_paddsb_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vpaddsb_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 520.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_paddsb_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 523.
    return v5;
}

// Generated as internal constructor for term x64_paddsw_a.
pub fn constructor_x64_paddsw_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_paddsw_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 528.
    return v3;
}

// Generated as internal constructor for term x64_paddsw_a_or_avx.
pub fn constructor_x64_paddsw_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vpaddsw_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 530.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_paddsw_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 533.
    return v5;
}

// Generated as internal constructor for term x64_paddusb_a.
pub fn constructor_x64_paddusb_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_paddusb_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 538.
    return v3;
}

// Generated as internal constructor for term x64_paddusb_a_or_avx.
pub fn constructor_x64_paddusb_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vpaddusb_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 540.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_paddusb_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 543.
    return v5;
}

// Generated as internal constructor for term x64_paddusw_a.
pub fn constructor_x64_paddusw_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_paddusw_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 548.
    return v3;
}

// Generated as internal constructor for term x64_paddusw_a_or_avx.
pub fn constructor_x64_paddusw_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vpaddusw_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 550.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_paddusw_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 553.
    return v5;
}

// Generated as internal constructor for term x64_phaddw_a.
pub fn constructor_x64_phaddw_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_phaddw_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 558.
    return v3;
}

// Generated as internal constructor for term x64_phaddw_a_or_avx.
pub fn constructor_x64_phaddw_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vphaddw_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 560.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_phaddw_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 563.
    return v5;
}

// Generated as internal constructor for term x64_phaddd_a.
pub fn constructor_x64_phaddd_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_phaddd_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 568.
    return v3;
}

// Generated as internal constructor for term x64_phaddd_a_or_avx.
pub fn constructor_x64_phaddd_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vphaddd_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 570.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_phaddd_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 573.
    return v5;
}

// Generated as internal constructor for term x64_vaddss_b.
pub fn constructor_x64_vaddss_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vaddss_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 578.
    return v3;
}

// Generated as internal constructor for term x64_vaddsd_b.
pub fn constructor_x64_vaddsd_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vaddsd_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 583.
    return v3;
}

// Generated as internal constructor for term x64_vaddps_b.
pub fn constructor_x64_vaddps_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vaddps_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 588.
    return v3;
}

// Generated as internal constructor for term x64_vaddpd_b.
pub fn constructor_x64_vaddpd_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vaddpd_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 593.
    return v3;
}

// Generated as internal constructor for term x64_vpaddb_b.
pub fn constructor_x64_vpaddb_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vpaddb_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 598.
    return v3;
}

// Generated as internal constructor for term x64_vpaddw_b.
pub fn constructor_x64_vpaddw_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vpaddw_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 603.
    return v3;
}

// Generated as internal constructor for term x64_vpaddd_b.
pub fn constructor_x64_vpaddd_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vpaddd_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 608.
    return v3;
}

// Generated as internal constructor for term x64_vpaddq_b.
pub fn constructor_x64_vpaddq_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vpaddq_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 613.
    return v3;
}

// Generated as internal constructor for term x64_vpaddsb_b.
pub fn constructor_x64_vpaddsb_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vpaddsb_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 618.
    return v3;
}

// Generated as internal constructor for term x64_vpaddsw_b.
pub fn constructor_x64_vpaddsw_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vpaddsw_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 623.
    return v3;
}

// Generated as internal constructor for term x64_vpaddusb_b.
pub fn constructor_x64_vpaddusb_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vpaddusb_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 628.
    return v3;
}

// Generated as internal constructor for term x64_vpaddusw_b.
pub fn constructor_x64_vpaddusw_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vpaddusw_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 633.
    return v3;
}

// Generated as internal constructor for term x64_vphaddw_b.
pub fn constructor_x64_vphaddw_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vphaddw_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 638.
    return v3;
}

// Generated as internal constructor for term x64_vphaddd_b.
pub fn constructor_x64_vphaddd_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vphaddd_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 643.
    return v3;
}

// Generated as internal constructor for term x64_vaddpd_c.
pub fn constructor_x64_vaddpd_c<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vaddpd_c_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 648.
    return v3;
}

// Generated as internal constructor for term x64_palignr_a.
pub fn constructor_x64_palignr_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
    arg2: u8,
) -> Xmm {
    let v3 = &C::x64_palignr_a_raw(ctx, arg0, arg1, arg2);
    let v4 = constructor_emit_ret_xmm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 653.
    return v4;
}

// Generated as internal constructor for term x64_palignr_a_or_avx.
pub fn constructor_x64_palignr_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
    arg2: u8,
) -> Xmm {
    let v3 = C::has_avx(ctx);
    if v3 == true {
        let v4 = constructor_x64_vpalignr_b(ctx, arg0, arg1, arg2);
        // Rule at <OUT_DIR>/assembler.isle line 655.
        return v4;
    }
    let v5 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v6 = constructor_x64_palignr_a(ctx, arg0, v5, arg2);
    // Rule at <OUT_DIR>/assembler.isle line 658.
    return v6;
}

// Generated as internal constructor for term x64_vpalignr_b.
pub fn constructor_x64_vpalignr_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
    arg2: u8,
) -> Xmm {
    let v3 = &C::x64_vpalignr_b_raw(ctx, arg0, arg1, arg2);
    let v4 = constructor_emit_ret_xmm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 663.
    return v4;
}

// Generated as internal constructor for term x64_andb_i.
pub fn constructor_x64_andb_i<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: u8,
) -> Gpr {
    let v2 = &C::x64_andb_i_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 668.
    return v3;
}

// Generated as internal constructor for term x64_andw_i.
pub fn constructor_x64_andw_i<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: u16,
) -> Gpr {
    let v2 = &C::x64_andw_i_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 673.
    return v3;
}

// Generated as internal constructor for term x64_andl_i.
pub fn constructor_x64_andl_i<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: u32,
) -> Gpr {
    let v2 = &C::x64_andl_i_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 678.
    return v3;
}

// Generated as internal constructor for term x64_andq_i_sxl.
pub fn constructor_x64_andq_i_sxl<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: i32,
) -> Gpr {
    let v2 = &C::x64_andq_i_sxl_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 683.
    return v3;
}

// Generated as internal constructor for term x64_andb_mi.
pub fn constructor_x64_andb_mi<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: u8,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_andb_mi_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 688.
    return v4;
}

// Generated as internal constructor for term x64_andb_mi_mem.
pub fn constructor_x64_andb_mi_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: u8,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_andb_mi_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 690.
    return v4.clone();
}

// Generated as internal constructor for term x64_andw_mi.
pub fn constructor_x64_andw_mi<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: u16,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_andw_mi_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 695.
    return v4;
}

// Generated as internal constructor for term x64_andw_mi_mem.
pub fn constructor_x64_andw_mi_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: u16,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_andw_mi_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 697.
    return v4.clone();
}

// Generated as internal constructor for term x64_andl_mi.
pub fn constructor_x64_andl_mi<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: u32,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_andl_mi_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 702.
    return v4;
}

// Generated as internal constructor for term x64_andl_mi_mem.
pub fn constructor_x64_andl_mi_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: u32,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_andl_mi_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 704.
    return v4.clone();
}

// Generated as internal constructor for term x64_andq_mi_sxl.
pub fn constructor_x64_andq_mi_sxl<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: i32,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_andq_mi_sxl_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 709.
    return v4;
}

// Generated as internal constructor for term x64_andq_mi_sxl_mem.
pub fn constructor_x64_andq_mi_sxl_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: i32,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_andq_mi_sxl_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 711.
    return v4.clone();
}

// Generated as internal constructor for term x64_andl_mi_sxb.
pub fn constructor_x64_andl_mi_sxb<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: i8,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_andl_mi_sxb_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 716.
    return v4;
}

// Generated as internal constructor for term x64_andl_mi_sxb_mem.
pub fn constructor_x64_andl_mi_sxb_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: i8,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_andl_mi_sxb_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 718.
    return v4.clone();
}

// Generated as internal constructor for term x64_andq_mi_sxb.
pub fn constructor_x64_andq_mi_sxb<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: i8,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_andq_mi_sxb_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 723.
    return v4;
}

// Generated as internal constructor for term x64_andq_mi_sxb_mem.
pub fn constructor_x64_andq_mi_sxb_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: i8,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_andq_mi_sxb_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 725.
    return v4.clone();
}

// Generated as internal constructor for term x64_andb_mr.
pub fn constructor_x64_andb_mr<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: Gpr,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_andb_mr_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 730.
    return v4;
}

// Generated as internal constructor for term x64_andb_mr_mem.
pub fn constructor_x64_andb_mr_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Gpr,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_andb_mr_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 732.
    return v4.clone();
}

// Generated as internal constructor for term x64_andw_mr.
pub fn constructor_x64_andw_mr<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: Gpr,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_andw_mr_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 737.
    return v4;
}

// Generated as internal constructor for term x64_andw_mr_mem.
pub fn constructor_x64_andw_mr_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Gpr,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_andw_mr_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 739.
    return v4.clone();
}

// Generated as internal constructor for term x64_andl_mr.
pub fn constructor_x64_andl_mr<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: Gpr,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_andl_mr_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 744.
    return v4;
}

// Generated as internal constructor for term x64_andl_mr_mem.
pub fn constructor_x64_andl_mr_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Gpr,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_andl_mr_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 746.
    return v4.clone();
}

// Generated as internal constructor for term x64_andq_mr.
pub fn constructor_x64_andq_mr<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: Gpr,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_andq_mr_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 751.
    return v4;
}

// Generated as internal constructor for term x64_andq_mr_mem.
pub fn constructor_x64_andq_mr_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Gpr,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_andq_mr_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 753.
    return v4.clone();
}

// Generated as internal constructor for term x64_andb_rm.
pub fn constructor_x64_andb_rm<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
) -> Gpr {
    let v2 = &C::x64_andb_rm_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 758.
    return v3;
}

// Generated as internal constructor for term x64_andw_rm.
pub fn constructor_x64_andw_rm<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
) -> Gpr {
    let v2 = &C::x64_andw_rm_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 763.
    return v3;
}

// Generated as internal constructor for term x64_andl_rm.
pub fn constructor_x64_andl_rm<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
) -> Gpr {
    let v2 = &C::x64_andl_rm_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 768.
    return v3;
}

// Generated as internal constructor for term x64_andq_rm.
pub fn constructor_x64_andq_rm<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
) -> Gpr {
    let v2 = &C::x64_andq_rm_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 773.
    return v3;
}

// Generated as internal constructor for term x64_andnl_rvm.
pub fn constructor_x64_andnl_rvm<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
) -> Gpr {
    let v2 = &C::x64_andnl_rvm_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 778.
    return v3;
}

// Generated as internal constructor for term x64_andnq_rvm.
pub fn constructor_x64_andnq_rvm<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
) -> Gpr {
    let v2 = &C::x64_andnq_rvm_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 783.
    return v3;
}

// Generated as internal constructor for term x64_lock_andb_mi_mem.
pub fn constructor_x64_lock_andb_mi_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: u8,
) -> SideEffectNoResult {
    let v2 = &C::x64_lock_andb_mi_raw(ctx, arg0, arg1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 788.
    return v3.clone();
}

// Generated as internal constructor for term x64_lock_andw_mi_mem.
pub fn constructor_x64_lock_andw_mi_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: u16,
) -> SideEffectNoResult {
    let v2 = &C::x64_lock_andw_mi_raw(ctx, arg0, arg1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 793.
    return v3.clone();
}

// Generated as internal constructor for term x64_lock_andl_mi_mem.
pub fn constructor_x64_lock_andl_mi_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: u32,
) -> SideEffectNoResult {
    let v2 = &C::x64_lock_andl_mi_raw(ctx, arg0, arg1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 798.
    return v3.clone();
}

// Generated as internal constructor for term x64_lock_andq_mi_sxl_mem.
pub fn constructor_x64_lock_andq_mi_sxl_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: i32,
) -> SideEffectNoResult {
    let v2 = &C::x64_lock_andq_mi_sxl_raw(ctx, arg0, arg1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 803.
    return v3.clone();
}

// Generated as internal constructor for term x64_lock_andl_mi_sxb_mem.
pub fn constructor_x64_lock_andl_mi_sxb_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: i8,
) -> SideEffectNoResult {
    let v2 = &C::x64_lock_andl_mi_sxb_raw(ctx, arg0, arg1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 808.
    return v3.clone();
}

// Generated as internal constructor for term x64_lock_andq_mi_sxb_mem.
pub fn constructor_x64_lock_andq_mi_sxb_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: i8,
) -> SideEffectNoResult {
    let v2 = &C::x64_lock_andq_mi_sxb_raw(ctx, arg0, arg1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 813.
    return v3.clone();
}

// Generated as internal constructor for term x64_lock_andb_mr_mem.
pub fn constructor_x64_lock_andb_mr_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Gpr,
) -> SideEffectNoResult {
    let v2 = &C::x64_lock_andb_mr_raw(ctx, arg0, arg1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 818.
    return v3.clone();
}

// Generated as internal constructor for term x64_lock_andw_mr_mem.
pub fn constructor_x64_lock_andw_mr_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Gpr,
) -> SideEffectNoResult {
    let v2 = &C::x64_lock_andw_mr_raw(ctx, arg0, arg1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 823.
    return v3.clone();
}

// Generated as internal constructor for term x64_lock_andl_mr_mem.
pub fn constructor_x64_lock_andl_mr_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Gpr,
) -> SideEffectNoResult {
    let v2 = &C::x64_lock_andl_mr_raw(ctx, arg0, arg1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 828.
    return v3.clone();
}

// Generated as internal constructor for term x64_lock_andq_mr_mem.
pub fn constructor_x64_lock_andq_mr_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Gpr,
) -> SideEffectNoResult {
    let v2 = &C::x64_lock_andq_mr_raw(ctx, arg0, arg1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 833.
    return v3.clone();
}

// Generated as internal constructor for term x64_andps_a.
pub fn constructor_x64_andps_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_andps_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 838.
    return v3;
}

// Generated as internal constructor for term x64_andps_a_or_avx.
pub fn constructor_x64_andps_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vandps_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 840.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_andps_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 843.
    return v5;
}

// Generated as internal constructor for term x64_andpd_a.
pub fn constructor_x64_andpd_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_andpd_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 848.
    return v3;
}

// Generated as internal constructor for term x64_andpd_a_or_avx.
pub fn constructor_x64_andpd_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vandpd_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 850.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_andpd_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 853.
    return v5;
}

// Generated as internal constructor for term x64_andnps_a.
pub fn constructor_x64_andnps_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_andnps_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 858.
    return v3;
}

// Generated as internal constructor for term x64_andnps_a_or_avx.
pub fn constructor_x64_andnps_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vandnps_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 860.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_andnps_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 863.
    return v5;
}

// Generated as internal constructor for term x64_andnpd_a.
pub fn constructor_x64_andnpd_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_andnpd_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 868.
    return v3;
}

// Generated as internal constructor for term x64_andnpd_a_or_avx.
pub fn constructor_x64_andnpd_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vandnpd_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 870.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_andnpd_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 873.
    return v5;
}

// Generated as internal constructor for term x64_pand_a.
pub fn constructor_x64_pand_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_pand_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 878.
    return v3;
}

// Generated as internal constructor for term x64_pand_a_or_avx.
pub fn constructor_x64_pand_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vpand_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 880.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_pand_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 883.
    return v5;
}

// Generated as internal constructor for term x64_pandn_a.
pub fn constructor_x64_pandn_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_pandn_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 888.
    return v3;
}

// Generated as internal constructor for term x64_pandn_a_or_avx.
pub fn constructor_x64_pandn_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vpandn_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 890.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_pandn_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 893.
    return v5;
}

// Generated as internal constructor for term x64_vandps_b.
pub fn constructor_x64_vandps_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vandps_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 898.
    return v3;
}

// Generated as internal constructor for term x64_vandpd_b.
pub fn constructor_x64_vandpd_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vandpd_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 903.
    return v3;
}

// Generated as internal constructor for term x64_vandnps_b.
pub fn constructor_x64_vandnps_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vandnps_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 908.
    return v3;
}

// Generated as internal constructor for term x64_vandnpd_b.
pub fn constructor_x64_vandnpd_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vandnpd_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 913.
    return v3;
}

// Generated as internal constructor for term x64_vpand_b.
pub fn constructor_x64_vpand_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vpand_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 918.
    return v3;
}

// Generated as internal constructor for term x64_vpandn_b.
pub fn constructor_x64_vpandn_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vpandn_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 923.
    return v3;
}

// Generated as internal constructor for term x64_xchgb_rm.
pub fn constructor_x64_xchgb_rm<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &SyntheticAmode,
) -> Gpr {
    let v2 = &C::x64_xchgb_rm_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 928.
    return v3;
}

// Generated as internal constructor for term x64_xchgw_rm.
pub fn constructor_x64_xchgw_rm<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &SyntheticAmode,
) -> Gpr {
    let v2 = &C::x64_xchgw_rm_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 933.
    return v3;
}

// Generated as internal constructor for term x64_xchgl_rm.
pub fn constructor_x64_xchgl_rm<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &SyntheticAmode,
) -> Gpr {
    let v2 = &C::x64_xchgl_rm_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 938.
    return v3;
}

// Generated as internal constructor for term x64_xchgq_rm.
pub fn constructor_x64_xchgq_rm<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &SyntheticAmode,
) -> Gpr {
    let v2 = &C::x64_xchgq_rm_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 943.
    return v3;
}

// Generated as internal constructor for term x64_cmpxchg16b_m.
pub fn constructor_x64_cmpxchg16b_m<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: Gpr,
    arg2: Gpr,
    arg3: Gpr,
    arg4: &SyntheticAmode,
) -> ValueRegs {
    let v5 = &C::x64_cmpxchg16b_m_raw(ctx, arg0, arg1, arg2, arg3, arg4);
    let v6 = constructor_emit_ret_value_regs(ctx, v5);
    // Rule at <OUT_DIR>/assembler.isle line 948.
    return v6;
}

// Generated as internal constructor for term x64_lock_cmpxchg16b_m.
pub fn constructor_x64_lock_cmpxchg16b_m<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: Gpr,
    arg2: Gpr,
    arg3: Gpr,
    arg4: &SyntheticAmode,
) -> ValueRegs {
    let v5 = &C::x64_lock_cmpxchg16b_m_raw(ctx, arg0, arg1, arg2, arg3, arg4);
    let v6 = constructor_emit_ret_value_regs(ctx, v5);
    // Rule at <OUT_DIR>/assembler.isle line 953.
    return v6;
}

// Generated as internal constructor for term x64_cmpxchgb_mr.
pub fn constructor_x64_cmpxchgb_mr<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: Gpr,
    arg2: Gpr,
) -> Gpr {
    let v3 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v4 = &C::x64_cmpxchgb_mr_raw(ctx, v3, arg1, arg2);
    let v5 = constructor_emit_ret_gpr(ctx, v4);
    // Rule at <OUT_DIR>/assembler.isle line 958.
    return v5;
}

// Generated as internal constructor for term x64_cmpxchgw_mr.
pub fn constructor_x64_cmpxchgw_mr<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: Gpr,
    arg2: Gpr,
) -> Gpr {
    let v3 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v4 = &C::x64_cmpxchgw_mr_raw(ctx, v3, arg1, arg2);
    let v5 = constructor_emit_ret_gpr(ctx, v4);
    // Rule at <OUT_DIR>/assembler.isle line 963.
    return v5;
}

// Generated as internal constructor for term x64_cmpxchgl_mr.
pub fn constructor_x64_cmpxchgl_mr<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: Gpr,
    arg2: Gpr,
) -> Gpr {
    let v3 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v4 = &C::x64_cmpxchgl_mr_raw(ctx, v3, arg1, arg2);
    let v5 = constructor_emit_ret_gpr(ctx, v4);
    // Rule at <OUT_DIR>/assembler.isle line 968.
    return v5;
}

// Generated as internal constructor for term x64_cmpxchgq_mr.
pub fn constructor_x64_cmpxchgq_mr<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: Gpr,
    arg2: Gpr,
) -> Gpr {
    let v3 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v4 = &C::x64_cmpxchgq_mr_raw(ctx, v3, arg1, arg2);
    let v5 = constructor_emit_ret_gpr(ctx, v4);
    // Rule at <OUT_DIR>/assembler.isle line 973.
    return v5;
}

// Generated as internal constructor for term x64_lock_cmpxchgb_mr.
pub fn constructor_x64_lock_cmpxchgb_mr<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Gpr,
    arg2: Gpr,
) -> Gpr {
    let v3 = &C::x64_lock_cmpxchgb_mr_raw(ctx, arg0, arg1, arg2);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 978.
    return v4;
}

// Generated as internal constructor for term x64_lock_cmpxchgw_mr.
pub fn constructor_x64_lock_cmpxchgw_mr<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Gpr,
    arg2: Gpr,
) -> Gpr {
    let v3 = &C::x64_lock_cmpxchgw_mr_raw(ctx, arg0, arg1, arg2);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 983.
    return v4;
}

// Generated as internal constructor for term x64_lock_cmpxchgl_mr.
pub fn constructor_x64_lock_cmpxchgl_mr<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Gpr,
    arg2: Gpr,
) -> Gpr {
    let v3 = &C::x64_lock_cmpxchgl_mr_raw(ctx, arg0, arg1, arg2);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 988.
    return v4;
}

// Generated as internal constructor for term x64_lock_cmpxchgq_mr.
pub fn constructor_x64_lock_cmpxchgq_mr<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Gpr,
    arg2: Gpr,
) -> Gpr {
    let v3 = &C::x64_lock_cmpxchgq_mr_raw(ctx, arg0, arg1, arg2);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 993.
    return v4;
}

// Generated as internal constructor for term x64_pavgb_a.
pub fn constructor_x64_pavgb_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_pavgb_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 998.
    return v3;
}

// Generated as internal constructor for term x64_pavgb_a_or_avx.
pub fn constructor_x64_pavgb_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vpavgb_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 1000.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_pavgb_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 1003.
    return v5;
}

// Generated as internal constructor for term x64_pavgw_a.
pub fn constructor_x64_pavgw_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_pavgw_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1008.
    return v3;
}

// Generated as internal constructor for term x64_pavgw_a_or_avx.
pub fn constructor_x64_pavgw_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vpavgw_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 1010.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_pavgw_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 1013.
    return v5;
}

// Generated as internal constructor for term x64_vpavgb_b.
pub fn constructor_x64_vpavgb_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vpavgb_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1018.
    return v3;
}

// Generated as internal constructor for term x64_vpavgw_b.
pub fn constructor_x64_vpavgw_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vpavgw_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1023.
    return v3;
}

// Generated as internal constructor for term x64_bsfw_rm.
pub fn constructor_x64_bsfw_rm<C: Context>(
    ctx: &mut C,
    arg0: &GprMem,
) -> Gpr {
    let v1 = &C::x64_bsfw_rm_raw(ctx, arg0);
    let v2 = constructor_emit_ret_gpr(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 1028.
    return v2;
}

// Generated as internal constructor for term x64_bsfl_rm.
pub fn constructor_x64_bsfl_rm<C: Context>(
    ctx: &mut C,
    arg0: &GprMem,
) -> Gpr {
    let v1 = &C::x64_bsfl_rm_raw(ctx, arg0);
    let v2 = constructor_emit_ret_gpr(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 1033.
    return v2;
}

// Generated as internal constructor for term x64_bsfq_rm.
pub fn constructor_x64_bsfq_rm<C: Context>(
    ctx: &mut C,
    arg0: &GprMem,
) -> Gpr {
    let v1 = &C::x64_bsfq_rm_raw(ctx, arg0);
    let v2 = constructor_emit_ret_gpr(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 1038.
    return v2;
}

// Generated as internal constructor for term x64_bsrw_rm.
pub fn constructor_x64_bsrw_rm<C: Context>(
    ctx: &mut C,
    arg0: &GprMem,
) -> Gpr {
    let v1 = &C::x64_bsrw_rm_raw(ctx, arg0);
    let v2 = constructor_emit_ret_gpr(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 1043.
    return v2;
}

// Generated as internal constructor for term x64_bsrl_rm.
pub fn constructor_x64_bsrl_rm<C: Context>(
    ctx: &mut C,
    arg0: &GprMem,
) -> Gpr {
    let v1 = &C::x64_bsrl_rm_raw(ctx, arg0);
    let v2 = constructor_emit_ret_gpr(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 1048.
    return v2;
}

// Generated as internal constructor for term x64_bsrq_rm.
pub fn constructor_x64_bsrq_rm<C: Context>(
    ctx: &mut C,
    arg0: &GprMem,
) -> Gpr {
    let v1 = &C::x64_bsrq_rm_raw(ctx, arg0);
    let v2 = constructor_emit_ret_gpr(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 1053.
    return v2;
}

// Generated as internal constructor for term x64_tzcntw_a.
pub fn constructor_x64_tzcntw_a<C: Context>(
    ctx: &mut C,
    arg0: &GprMem,
) -> Gpr {
    let v1 = &C::x64_tzcntw_a_raw(ctx, arg0);
    let v2 = constructor_emit_ret_gpr(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 1058.
    return v2;
}

// Generated as internal constructor for term x64_tzcntl_a.
pub fn constructor_x64_tzcntl_a<C: Context>(
    ctx: &mut C,
    arg0: &GprMem,
) -> Gpr {
    let v1 = &C::x64_tzcntl_a_raw(ctx, arg0);
    let v2 = constructor_emit_ret_gpr(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 1063.
    return v2;
}

// Generated as internal constructor for term x64_tzcntq_a.
pub fn constructor_x64_tzcntq_a<C: Context>(
    ctx: &mut C,
    arg0: &GprMem,
) -> Gpr {
    let v1 = &C::x64_tzcntq_a_raw(ctx, arg0);
    let v2 = constructor_emit_ret_gpr(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 1068.
    return v2;
}

// Generated as internal constructor for term x64_lzcntw_rm.
pub fn constructor_x64_lzcntw_rm<C: Context>(
    ctx: &mut C,
    arg0: &GprMem,
) -> Gpr {
    let v1 = &C::x64_lzcntw_rm_raw(ctx, arg0);
    let v2 = constructor_emit_ret_gpr(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 1073.
    return v2;
}

// Generated as internal constructor for term x64_lzcntl_rm.
pub fn constructor_x64_lzcntl_rm<C: Context>(
    ctx: &mut C,
    arg0: &GprMem,
) -> Gpr {
    let v1 = &C::x64_lzcntl_rm_raw(ctx, arg0);
    let v2 = constructor_emit_ret_gpr(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 1078.
    return v2;
}

// Generated as internal constructor for term x64_lzcntq_rm.
pub fn constructor_x64_lzcntq_rm<C: Context>(
    ctx: &mut C,
    arg0: &GprMem,
) -> Gpr {
    let v1 = &C::x64_lzcntq_rm_raw(ctx, arg0);
    let v2 = constructor_emit_ret_gpr(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 1083.
    return v2;
}

// Generated as internal constructor for term x64_popcntw_rm.
pub fn constructor_x64_popcntw_rm<C: Context>(
    ctx: &mut C,
    arg0: &GprMem,
) -> Gpr {
    let v1 = &C::x64_popcntw_rm_raw(ctx, arg0);
    let v2 = constructor_emit_ret_gpr(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 1088.
    return v2;
}

// Generated as internal constructor for term x64_popcntl_rm.
pub fn constructor_x64_popcntl_rm<C: Context>(
    ctx: &mut C,
    arg0: &GprMem,
) -> Gpr {
    let v1 = &C::x64_popcntl_rm_raw(ctx, arg0);
    let v2 = constructor_emit_ret_gpr(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 1093.
    return v2;
}

// Generated as internal constructor for term x64_popcntq_rm.
pub fn constructor_x64_popcntq_rm<C: Context>(
    ctx: &mut C,
    arg0: &GprMem,
) -> Gpr {
    let v1 = &C::x64_popcntq_rm_raw(ctx, arg0);
    let v2 = constructor_emit_ret_gpr(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 1098.
    return v2;
}

// Generated as internal constructor for term x64_btw_mr.
pub fn constructor_x64_btw_mr<C: Context>(
    ctx: &mut C,
    arg0: &GprMem,
    arg1: Gpr,
) -> ProducesFlags {
    let v2 = &C::x64_btw_mr_raw(ctx, arg0, arg1);
    let v3 = &constructor_asm_produce_flags_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1103.
    return v3.clone();
}

// Generated as internal constructor for term x64_btl_mr.
pub fn constructor_x64_btl_mr<C: Context>(
    ctx: &mut C,
    arg0: &GprMem,
    arg1: Gpr,
) -> ProducesFlags {
    let v2 = &C::x64_btl_mr_raw(ctx, arg0, arg1);
    let v3 = &constructor_asm_produce_flags_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1108.
    return v3.clone();
}

// Generated as internal constructor for term x64_btq_mr.
pub fn constructor_x64_btq_mr<C: Context>(
    ctx: &mut C,
    arg0: &GprMem,
    arg1: Gpr,
) -> ProducesFlags {
    let v2 = &C::x64_btq_mr_raw(ctx, arg0, arg1);
    let v3 = &constructor_asm_produce_flags_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1113.
    return v3.clone();
}

// Generated as internal constructor for term x64_btw_mi.
pub fn constructor_x64_btw_mi<C: Context>(
    ctx: &mut C,
    arg0: &GprMem,
    arg1: u8,
) -> ProducesFlags {
    let v2 = &C::x64_btw_mi_raw(ctx, arg0, arg1);
    let v3 = &constructor_asm_produce_flags_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1118.
    return v3.clone();
}

// Generated as internal constructor for term x64_btl_mi.
pub fn constructor_x64_btl_mi<C: Context>(
    ctx: &mut C,
    arg0: &GprMem,
    arg1: u8,
) -> ProducesFlags {
    let v2 = &C::x64_btl_mi_raw(ctx, arg0, arg1);
    let v3 = &constructor_asm_produce_flags_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1123.
    return v3.clone();
}

// Generated as internal constructor for term x64_btq_mi.
pub fn constructor_x64_btq_mi<C: Context>(
    ctx: &mut C,
    arg0: &GprMem,
    arg1: u8,
) -> ProducesFlags {
    let v2 = &C::x64_btq_mi_raw(ctx, arg0, arg1);
    let v3 = &constructor_asm_produce_flags_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1128.
    return v3.clone();
}

// Generated as internal constructor for term x64_cbtw_zo.
pub fn constructor_x64_cbtw_zo<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
) -> Gpr {
    let v1 = &C::x64_cbtw_zo_raw(ctx, arg0);
    let v2 = constructor_emit_ret_gpr(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 1133.
    return v2;
}

// Generated as internal constructor for term x64_cwtl_zo.
pub fn constructor_x64_cwtl_zo<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
) -> Gpr {
    let v1 = &C::x64_cwtl_zo_raw(ctx, arg0);
    let v2 = constructor_emit_ret_gpr(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 1138.
    return v2;
}

// Generated as internal constructor for term x64_cltq_zo.
pub fn constructor_x64_cltq_zo<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
) -> Gpr {
    let v1 = &C::x64_cltq_zo_raw(ctx, arg0);
    let v2 = constructor_emit_ret_gpr(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 1143.
    return v2;
}

// Generated as internal constructor for term x64_cwtd_zo.
pub fn constructor_x64_cwtd_zo<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
) -> Gpr {
    let v1 = &C::x64_cwtd_zo_raw(ctx, arg0);
    let v2 = constructor_emit_ret_gpr(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 1148.
    return v2;
}

// Generated as internal constructor for term x64_cltd_zo.
pub fn constructor_x64_cltd_zo<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
) -> Gpr {
    let v1 = &C::x64_cltd_zo_raw(ctx, arg0);
    let v2 = constructor_emit_ret_gpr(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 1153.
    return v2;
}

// Generated as internal constructor for term x64_cqto_zo.
pub fn constructor_x64_cqto_zo<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
) -> Gpr {
    let v1 = &C::x64_cqto_zo_raw(ctx, arg0);
    let v2 = constructor_emit_ret_gpr(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 1158.
    return v2;
}

// Generated as internal constructor for term x64_bswapl_o.
pub fn constructor_x64_bswapl_o<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
) -> Gpr {
    let v1 = &C::x64_bswapl_o_raw(ctx, arg0);
    let v2 = constructor_emit_ret_gpr(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 1163.
    return v2;
}

// Generated as internal constructor for term x64_bswapq_o.
pub fn constructor_x64_bswapq_o<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
) -> Gpr {
    let v1 = &C::x64_bswapq_o_raw(ctx, arg0);
    let v2 = constructor_emit_ret_gpr(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 1168.
    return v2;
}

// Generated as internal constructor for term x64_blsrl_vm.
pub fn constructor_x64_blsrl_vm<C: Context>(
    ctx: &mut C,
    arg0: &GprMem,
) -> Gpr {
    let v1 = &C::x64_blsrl_vm_raw(ctx, arg0);
    let v2 = constructor_emit_ret_gpr(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 1173.
    return v2;
}

// Generated as internal constructor for term x64_blsrq_vm.
pub fn constructor_x64_blsrq_vm<C: Context>(
    ctx: &mut C,
    arg0: &GprMem,
) -> Gpr {
    let v1 = &C::x64_blsrq_vm_raw(ctx, arg0);
    let v2 = constructor_emit_ret_gpr(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 1178.
    return v2;
}

// Generated as internal constructor for term x64_blsmskl_vm.
pub fn constructor_x64_blsmskl_vm<C: Context>(
    ctx: &mut C,
    arg0: &GprMem,
) -> Gpr {
    let v1 = &C::x64_blsmskl_vm_raw(ctx, arg0);
    let v2 = constructor_emit_ret_gpr(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 1183.
    return v2;
}

// Generated as internal constructor for term x64_blsmskq_vm.
pub fn constructor_x64_blsmskq_vm<C: Context>(
    ctx: &mut C,
    arg0: &GprMem,
) -> Gpr {
    let v1 = &C::x64_blsmskq_vm_raw(ctx, arg0);
    let v2 = constructor_emit_ret_gpr(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 1188.
    return v2;
}

// Generated as internal constructor for term x64_blsil_vm.
pub fn constructor_x64_blsil_vm<C: Context>(
    ctx: &mut C,
    arg0: &GprMem,
) -> Gpr {
    let v1 = &C::x64_blsil_vm_raw(ctx, arg0);
    let v2 = constructor_emit_ret_gpr(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 1193.
    return v2;
}

// Generated as internal constructor for term x64_blsiq_vm.
pub fn constructor_x64_blsiq_vm<C: Context>(
    ctx: &mut C,
    arg0: &GprMem,
) -> Gpr {
    let v1 = &C::x64_blsiq_vm_raw(ctx, arg0);
    let v2 = constructor_emit_ret_gpr(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 1198.
    return v2;
}

// Generated as internal constructor for term x64_bzhil_rmv.
pub fn constructor_x64_bzhil_rmv<C: Context>(
    ctx: &mut C,
    arg0: &GprMem,
    arg1: Gpr,
) -> Gpr {
    let v2 = &C::x64_bzhil_rmv_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1203.
    return v3;
}

// Generated as internal constructor for term x64_bzhiq_rmv.
pub fn constructor_x64_bzhiq_rmv<C: Context>(
    ctx: &mut C,
    arg0: &GprMem,
    arg1: Gpr,
) -> Gpr {
    let v2 = &C::x64_bzhiq_rmv_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1208.
    return v3;
}

// Generated as internal constructor for term x64_vpopcntb_a.
pub fn constructor_x64_vpopcntb_a<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = &C::x64_vpopcntb_a_raw(ctx, arg0);
    let v2 = constructor_emit_ret_xmm(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 1213.
    return v2;
}

// Generated as internal constructor for term x64_vpopcntw_a.
pub fn constructor_x64_vpopcntw_a<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = &C::x64_vpopcntw_a_raw(ctx, arg0);
    let v2 = constructor_emit_ret_xmm(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 1218.
    return v2;
}

// Generated as internal constructor for term x64_cmovaw_rm.
pub fn constructor_x64_cmovaw_rm<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
) -> ConsumesFlags {
    let v2 = &C::x64_cmovaw_rm_raw(ctx, arg0, arg1);
    let v3 = &constructor_asm_consumes_flags_returns_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1223.
    return v3.clone();
}

// Generated as internal constructor for term x64_cmoval_rm.
pub fn constructor_x64_cmoval_rm<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
) -> ConsumesFlags {
    let v2 = &C::x64_cmoval_rm_raw(ctx, arg0, arg1);
    let v3 = &constructor_asm_consumes_flags_returns_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1228.
    return v3.clone();
}

// Generated as internal constructor for term x64_cmovaq_rm.
pub fn constructor_x64_cmovaq_rm<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
) -> ConsumesFlags {
    let v2 = &C::x64_cmovaq_rm_raw(ctx, arg0, arg1);
    let v3 = &constructor_asm_consumes_flags_returns_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1233.
    return v3.clone();
}

// Generated as internal constructor for term x64_cmovaew_rm.
pub fn constructor_x64_cmovaew_rm<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
) -> ConsumesFlags {
    let v2 = &C::x64_cmovaew_rm_raw(ctx, arg0, arg1);
    let v3 = &constructor_asm_consumes_flags_returns_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1238.
    return v3.clone();
}

// Generated as internal constructor for term x64_cmovael_rm.
pub fn constructor_x64_cmovael_rm<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
) -> ConsumesFlags {
    let v2 = &C::x64_cmovael_rm_raw(ctx, arg0, arg1);
    let v3 = &constructor_asm_consumes_flags_returns_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1243.
    return v3.clone();
}

// Generated as internal constructor for term x64_cmovaeq_rm.
pub fn constructor_x64_cmovaeq_rm<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
) -> ConsumesFlags {
    let v2 = &C::x64_cmovaeq_rm_raw(ctx, arg0, arg1);
    let v3 = &constructor_asm_consumes_flags_returns_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1248.
    return v3.clone();
}

// Generated as internal constructor for term x64_cmovbw_rm.
pub fn constructor_x64_cmovbw_rm<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
) -> ConsumesFlags {
    let v2 = &C::x64_cmovbw_rm_raw(ctx, arg0, arg1);
    let v3 = &constructor_asm_consumes_flags_returns_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1253.
    return v3.clone();
}

// Generated as internal constructor for term x64_cmovbl_rm.
pub fn constructor_x64_cmovbl_rm<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
) -> ConsumesFlags {
    let v2 = &C::x64_cmovbl_rm_raw(ctx, arg0, arg1);
    let v3 = &constructor_asm_consumes_flags_returns_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1258.
    return v3.clone();
}

// Generated as internal constructor for term x64_cmovbq_rm.
pub fn constructor_x64_cmovbq_rm<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
) -> ConsumesFlags {
    let v2 = &C::x64_cmovbq_rm_raw(ctx, arg0, arg1);
    let v3 = &constructor_asm_consumes_flags_returns_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1263.
    return v3.clone();
}

// Generated as internal constructor for term x64_cmovbew_rm.
pub fn constructor_x64_cmovbew_rm<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
) -> ConsumesFlags {
    let v2 = &C::x64_cmovbew_rm_raw(ctx, arg0, arg1);
    let v3 = &constructor_asm_consumes_flags_returns_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1268.
    return v3.clone();
}

// Generated as internal constructor for term x64_cmovbel_rm.
pub fn constructor_x64_cmovbel_rm<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
) -> ConsumesFlags {
    let v2 = &C::x64_cmovbel_rm_raw(ctx, arg0, arg1);
    let v3 = &constructor_asm_consumes_flags_returns_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1273.
    return v3.clone();
}

// Generated as internal constructor for term x64_cmovbeq_rm.
pub fn constructor_x64_cmovbeq_rm<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
) -> ConsumesFlags {
    let v2 = &C::x64_cmovbeq_rm_raw(ctx, arg0, arg1);
    let v3 = &constructor_asm_consumes_flags_returns_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1278.
    return v3.clone();
}

// Generated as internal constructor for term x64_cmovew_rm.
pub fn constructor_x64_cmovew_rm<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
) -> ConsumesFlags {
    let v2 = &C::x64_cmovew_rm_raw(ctx, arg0, arg1);
    let v3 = &constructor_asm_consumes_flags_returns_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1283.
    return v3.clone();
}

// Generated as internal constructor for term x64_cmovel_rm.
pub fn constructor_x64_cmovel_rm<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
) -> ConsumesFlags {
    let v2 = &C::x64_cmovel_rm_raw(ctx, arg0, arg1);
    let v3 = &constructor_asm_consumes_flags_returns_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1288.
    return v3.clone();
}

// Generated as internal constructor for term x64_cmoveq_rm.
pub fn constructor_x64_cmoveq_rm<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
) -> ConsumesFlags {
    let v2 = &C::x64_cmoveq_rm_raw(ctx, arg0, arg1);
    let v3 = &constructor_asm_consumes_flags_returns_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1293.
    return v3.clone();
}

// Generated as internal constructor for term x64_cmovgw_rm.
pub fn constructor_x64_cmovgw_rm<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
) -> ConsumesFlags {
    let v2 = &C::x64_cmovgw_rm_raw(ctx, arg0, arg1);
    let v3 = &constructor_asm_consumes_flags_returns_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1298.
    return v3.clone();
}

// Generated as internal constructor for term x64_cmovgl_rm.
pub fn constructor_x64_cmovgl_rm<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
) -> ConsumesFlags {
    let v2 = &C::x64_cmovgl_rm_raw(ctx, arg0, arg1);
    let v3 = &constructor_asm_consumes_flags_returns_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1303.
    return v3.clone();
}

// Generated as internal constructor for term x64_cmovgq_rm.
pub fn constructor_x64_cmovgq_rm<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
) -> ConsumesFlags {
    let v2 = &C::x64_cmovgq_rm_raw(ctx, arg0, arg1);
    let v3 = &constructor_asm_consumes_flags_returns_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1308.
    return v3.clone();
}

// Generated as internal constructor for term x64_cmovgew_rm.
pub fn constructor_x64_cmovgew_rm<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
) -> ConsumesFlags {
    let v2 = &C::x64_cmovgew_rm_raw(ctx, arg0, arg1);
    let v3 = &constructor_asm_consumes_flags_returns_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1313.
    return v3.clone();
}

// Generated as internal constructor for term x64_cmovgel_rm.
pub fn constructor_x64_cmovgel_rm<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
) -> ConsumesFlags {
    let v2 = &C::x64_cmovgel_rm_raw(ctx, arg0, arg1);
    let v3 = &constructor_asm_consumes_flags_returns_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1318.
    return v3.clone();
}

// Generated as internal constructor for term x64_cmovgeq_rm.
pub fn constructor_x64_cmovgeq_rm<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
) -> ConsumesFlags {
    let v2 = &C::x64_cmovgeq_rm_raw(ctx, arg0, arg1);
    let v3 = &constructor_asm_consumes_flags_returns_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1323.
    return v3.clone();
}

// Generated as internal constructor for term x64_cmovlw_rm.
pub fn constructor_x64_cmovlw_rm<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
) -> ConsumesFlags {
    let v2 = &C::x64_cmovlw_rm_raw(ctx, arg0, arg1);
    let v3 = &constructor_asm_consumes_flags_returns_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1328.
    return v3.clone();
}

// Generated as internal constructor for term x64_cmovll_rm.
pub fn constructor_x64_cmovll_rm<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
) -> ConsumesFlags {
    let v2 = &C::x64_cmovll_rm_raw(ctx, arg0, arg1);
    let v3 = &constructor_asm_consumes_flags_returns_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1333.
    return v3.clone();
}

// Generated as internal constructor for term x64_cmovlq_rm.
pub fn constructor_x64_cmovlq_rm<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
) -> ConsumesFlags {
    let v2 = &C::x64_cmovlq_rm_raw(ctx, arg0, arg1);
    let v3 = &constructor_asm_consumes_flags_returns_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1338.
    return v3.clone();
}

// Generated as internal constructor for term x64_cmovlew_rm.
pub fn constructor_x64_cmovlew_rm<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
) -> ConsumesFlags {
    let v2 = &C::x64_cmovlew_rm_raw(ctx, arg0, arg1);
    let v3 = &constructor_asm_consumes_flags_returns_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1343.
    return v3.clone();
}

// Generated as internal constructor for term x64_cmovlel_rm.
pub fn constructor_x64_cmovlel_rm<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
) -> ConsumesFlags {
    let v2 = &C::x64_cmovlel_rm_raw(ctx, arg0, arg1);
    let v3 = &constructor_asm_consumes_flags_returns_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1348.
    return v3.clone();
}

// Generated as internal constructor for term x64_cmovleq_rm.
pub fn constructor_x64_cmovleq_rm<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
) -> ConsumesFlags {
    let v2 = &C::x64_cmovleq_rm_raw(ctx, arg0, arg1);
    let v3 = &constructor_asm_consumes_flags_returns_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1353.
    return v3.clone();
}

// Generated as internal constructor for term x64_cmovnew_rm.
pub fn constructor_x64_cmovnew_rm<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
) -> ConsumesFlags {
    let v2 = &C::x64_cmovnew_rm_raw(ctx, arg0, arg1);
    let v3 = &constructor_asm_consumes_flags_returns_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1358.
    return v3.clone();
}

// Generated as internal constructor for term x64_cmovnel_rm.
pub fn constructor_x64_cmovnel_rm<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
) -> ConsumesFlags {
    let v2 = &C::x64_cmovnel_rm_raw(ctx, arg0, arg1);
    let v3 = &constructor_asm_consumes_flags_returns_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1363.
    return v3.clone();
}

// Generated as internal constructor for term x64_cmovneq_rm.
pub fn constructor_x64_cmovneq_rm<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
) -> ConsumesFlags {
    let v2 = &C::x64_cmovneq_rm_raw(ctx, arg0, arg1);
    let v3 = &constructor_asm_consumes_flags_returns_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1368.
    return v3.clone();
}

// Generated as internal constructor for term x64_cmovnow_rm.
pub fn constructor_x64_cmovnow_rm<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
) -> ConsumesFlags {
    let v2 = &C::x64_cmovnow_rm_raw(ctx, arg0, arg1);
    let v3 = &constructor_asm_consumes_flags_returns_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1373.
    return v3.clone();
}

// Generated as internal constructor for term x64_cmovnol_rm.
pub fn constructor_x64_cmovnol_rm<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
) -> ConsumesFlags {
    let v2 = &C::x64_cmovnol_rm_raw(ctx, arg0, arg1);
    let v3 = &constructor_asm_consumes_flags_returns_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1378.
    return v3.clone();
}

// Generated as internal constructor for term x64_cmovnoq_rm.
pub fn constructor_x64_cmovnoq_rm<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
) -> ConsumesFlags {
    let v2 = &C::x64_cmovnoq_rm_raw(ctx, arg0, arg1);
    let v3 = &constructor_asm_consumes_flags_returns_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1383.
    return v3.clone();
}

// Generated as internal constructor for term x64_cmovnpw_rm.
pub fn constructor_x64_cmovnpw_rm<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
) -> ConsumesFlags {
    let v2 = &C::x64_cmovnpw_rm_raw(ctx, arg0, arg1);
    let v3 = &constructor_asm_consumes_flags_returns_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1388.
    return v3.clone();
}

// Generated as internal constructor for term x64_cmovnpl_rm.
pub fn constructor_x64_cmovnpl_rm<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
) -> ConsumesFlags {
    let v2 = &C::x64_cmovnpl_rm_raw(ctx, arg0, arg1);
    let v3 = &constructor_asm_consumes_flags_returns_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1393.
    return v3.clone();
}

// Generated as internal constructor for term x64_cmovnpq_rm.
pub fn constructor_x64_cmovnpq_rm<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
) -> ConsumesFlags {
    let v2 = &C::x64_cmovnpq_rm_raw(ctx, arg0, arg1);
    let v3 = &constructor_asm_consumes_flags_returns_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1398.
    return v3.clone();
}

// Generated as internal constructor for term x64_cmovnsw_rm.
pub fn constructor_x64_cmovnsw_rm<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
) -> ConsumesFlags {
    let v2 = &C::x64_cmovnsw_rm_raw(ctx, arg0, arg1);
    let v3 = &constructor_asm_consumes_flags_returns_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1403.
    return v3.clone();
}

// Generated as internal constructor for term x64_cmovnsl_rm.
pub fn constructor_x64_cmovnsl_rm<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
) -> ConsumesFlags {
    let v2 = &C::x64_cmovnsl_rm_raw(ctx, arg0, arg1);
    let v3 = &constructor_asm_consumes_flags_returns_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1408.
    return v3.clone();
}

// Generated as internal constructor for term x64_cmovnsq_rm.
pub fn constructor_x64_cmovnsq_rm<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
) -> ConsumesFlags {
    let v2 = &C::x64_cmovnsq_rm_raw(ctx, arg0, arg1);
    let v3 = &constructor_asm_consumes_flags_returns_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1413.
    return v3.clone();
}

// Generated as internal constructor for term x64_cmovow_rm.
pub fn constructor_x64_cmovow_rm<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
) -> ConsumesFlags {
    let v2 = &C::x64_cmovow_rm_raw(ctx, arg0, arg1);
    let v3 = &constructor_asm_consumes_flags_returns_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1418.
    return v3.clone();
}

// Generated as internal constructor for term x64_cmovol_rm.
pub fn constructor_x64_cmovol_rm<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
) -> ConsumesFlags {
    let v2 = &C::x64_cmovol_rm_raw(ctx, arg0, arg1);
    let v3 = &constructor_asm_consumes_flags_returns_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1423.
    return v3.clone();
}

// Generated as internal constructor for term x64_cmovoq_rm.
pub fn constructor_x64_cmovoq_rm<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
) -> ConsumesFlags {
    let v2 = &C::x64_cmovoq_rm_raw(ctx, arg0, arg1);
    let v3 = &constructor_asm_consumes_flags_returns_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1428.
    return v3.clone();
}

// Generated as internal constructor for term x64_cmovpw_rm.
pub fn constructor_x64_cmovpw_rm<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
) -> ConsumesFlags {
    let v2 = &C::x64_cmovpw_rm_raw(ctx, arg0, arg1);
    let v3 = &constructor_asm_consumes_flags_returns_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1433.
    return v3.clone();
}

// Generated as internal constructor for term x64_cmovpl_rm.
pub fn constructor_x64_cmovpl_rm<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
) -> ConsumesFlags {
    let v2 = &C::x64_cmovpl_rm_raw(ctx, arg0, arg1);
    let v3 = &constructor_asm_consumes_flags_returns_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1438.
    return v3.clone();
}

// Generated as internal constructor for term x64_cmovpq_rm.
pub fn constructor_x64_cmovpq_rm<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
) -> ConsumesFlags {
    let v2 = &C::x64_cmovpq_rm_raw(ctx, arg0, arg1);
    let v3 = &constructor_asm_consumes_flags_returns_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1443.
    return v3.clone();
}

// Generated as internal constructor for term x64_cmovsw_rm.
pub fn constructor_x64_cmovsw_rm<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
) -> ConsumesFlags {
    let v2 = &C::x64_cmovsw_rm_raw(ctx, arg0, arg1);
    let v3 = &constructor_asm_consumes_flags_returns_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1448.
    return v3.clone();
}

// Generated as internal constructor for term x64_cmovsl_rm.
pub fn constructor_x64_cmovsl_rm<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
) -> ConsumesFlags {
    let v2 = &C::x64_cmovsl_rm_raw(ctx, arg0, arg1);
    let v3 = &constructor_asm_consumes_flags_returns_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1453.
    return v3.clone();
}

// Generated as internal constructor for term x64_cmovsq_rm.
pub fn constructor_x64_cmovsq_rm<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
) -> ConsumesFlags {
    let v2 = &C::x64_cmovsq_rm_raw(ctx, arg0, arg1);
    let v3 = &constructor_asm_consumes_flags_returns_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1458.
    return v3.clone();
}

// Generated as internal constructor for term x64_cmpb_i.
pub fn constructor_x64_cmpb_i<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: u8,
) -> ProducesFlags {
    let v2 = &C::x64_cmpb_i_raw(ctx, arg0, arg1);
    let v3 = &constructor_asm_produce_flags_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1463.
    return v3.clone();
}

// Generated as internal constructor for term x64_cmpw_i.
pub fn constructor_x64_cmpw_i<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: u16,
) -> ProducesFlags {
    let v2 = &C::x64_cmpw_i_raw(ctx, arg0, arg1);
    let v3 = &constructor_asm_produce_flags_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1468.
    return v3.clone();
}

// Generated as internal constructor for term x64_cmpl_i.
pub fn constructor_x64_cmpl_i<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: u32,
) -> ProducesFlags {
    let v2 = &C::x64_cmpl_i_raw(ctx, arg0, arg1);
    let v3 = &constructor_asm_produce_flags_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1473.
    return v3.clone();
}

// Generated as internal constructor for term x64_cmpq_i.
pub fn constructor_x64_cmpq_i<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: i32,
) -> ProducesFlags {
    let v2 = &C::x64_cmpq_i_raw(ctx, arg0, arg1);
    let v3 = &constructor_asm_produce_flags_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1478.
    return v3.clone();
}

// Generated as internal constructor for term x64_cmpb_mi.
pub fn constructor_x64_cmpb_mi<C: Context>(
    ctx: &mut C,
    arg0: &GprMem,
    arg1: u8,
) -> ProducesFlags {
    let v2 = &C::x64_cmpb_mi_raw(ctx, arg0, arg1);
    let v3 = &constructor_asm_produce_flags_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1483.
    return v3.clone();
}

// Generated as internal constructor for term x64_cmpw_mi.
pub fn constructor_x64_cmpw_mi<C: Context>(
    ctx: &mut C,
    arg0: &GprMem,
    arg1: u16,
) -> ProducesFlags {
    let v2 = &C::x64_cmpw_mi_raw(ctx, arg0, arg1);
    let v3 = &constructor_asm_produce_flags_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1488.
    return v3.clone();
}

// Generated as internal constructor for term x64_cmpl_mi.
pub fn constructor_x64_cmpl_mi<C: Context>(
    ctx: &mut C,
    arg0: &GprMem,
    arg1: u32,
) -> ProducesFlags {
    let v2 = &C::x64_cmpl_mi_raw(ctx, arg0, arg1);
    let v3 = &constructor_asm_produce_flags_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1493.
    return v3.clone();
}

// Generated as internal constructor for term x64_cmpq_mi.
pub fn constructor_x64_cmpq_mi<C: Context>(
    ctx: &mut C,
    arg0: &GprMem,
    arg1: i32,
) -> ProducesFlags {
    let v2 = &C::x64_cmpq_mi_raw(ctx, arg0, arg1);
    let v3 = &constructor_asm_produce_flags_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1498.
    return v3.clone();
}

// Generated as internal constructor for term x64_cmpw_mi_sxb.
pub fn constructor_x64_cmpw_mi_sxb<C: Context>(
    ctx: &mut C,
    arg0: &GprMem,
    arg1: i8,
) -> ProducesFlags {
    let v2 = &C::x64_cmpw_mi_sxb_raw(ctx, arg0, arg1);
    let v3 = &constructor_asm_produce_flags_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1503.
    return v3.clone();
}

// Generated as internal constructor for term x64_cmpl_mi_sxb.
pub fn constructor_x64_cmpl_mi_sxb<C: Context>(
    ctx: &mut C,
    arg0: &GprMem,
    arg1: i8,
) -> ProducesFlags {
    let v2 = &C::x64_cmpl_mi_sxb_raw(ctx, arg0, arg1);
    let v3 = &constructor_asm_produce_flags_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1508.
    return v3.clone();
}

// Generated as internal constructor for term x64_cmpq_mi_sxb.
pub fn constructor_x64_cmpq_mi_sxb<C: Context>(
    ctx: &mut C,
    arg0: &GprMem,
    arg1: i8,
) -> ProducesFlags {
    let v2 = &C::x64_cmpq_mi_sxb_raw(ctx, arg0, arg1);
    let v3 = &constructor_asm_produce_flags_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1513.
    return v3.clone();
}

// Generated as internal constructor for term x64_cmpb_mr.
pub fn constructor_x64_cmpb_mr<C: Context>(
    ctx: &mut C,
    arg0: &GprMem,
    arg1: Gpr,
) -> ProducesFlags {
    let v2 = &C::x64_cmpb_mr_raw(ctx, arg0, arg1);
    let v3 = &constructor_asm_produce_flags_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1518.
    return v3.clone();
}

// Generated as internal constructor for term x64_cmpw_mr.
pub fn constructor_x64_cmpw_mr<C: Context>(
    ctx: &mut C,
    arg0: &GprMem,
    arg1: Gpr,
) -> ProducesFlags {
    let v2 = &C::x64_cmpw_mr_raw(ctx, arg0, arg1);
    let v3 = &constructor_asm_produce_flags_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1523.
    return v3.clone();
}

// Generated as internal constructor for term x64_cmpl_mr.
pub fn constructor_x64_cmpl_mr<C: Context>(
    ctx: &mut C,
    arg0: &GprMem,
    arg1: Gpr,
) -> ProducesFlags {
    let v2 = &C::x64_cmpl_mr_raw(ctx, arg0, arg1);
    let v3 = &constructor_asm_produce_flags_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1528.
    return v3.clone();
}

// Generated as internal constructor for term x64_cmpq_mr.
pub fn constructor_x64_cmpq_mr<C: Context>(
    ctx: &mut C,
    arg0: &GprMem,
    arg1: Gpr,
) -> ProducesFlags {
    let v2 = &C::x64_cmpq_mr_raw(ctx, arg0, arg1);
    let v3 = &constructor_asm_produce_flags_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1533.
    return v3.clone();
}

// Generated as internal constructor for term x64_cmpb_rm.
pub fn constructor_x64_cmpb_rm<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
) -> ProducesFlags {
    let v2 = &C::x64_cmpb_rm_raw(ctx, arg0, arg1);
    let v3 = &constructor_asm_produce_flags_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1538.
    return v3.clone();
}

// Generated as internal constructor for term x64_cmpw_rm.
pub fn constructor_x64_cmpw_rm<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
) -> ProducesFlags {
    let v2 = &C::x64_cmpw_rm_raw(ctx, arg0, arg1);
    let v3 = &constructor_asm_produce_flags_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1543.
    return v3.clone();
}

// Generated as internal constructor for term x64_cmpl_rm.
pub fn constructor_x64_cmpl_rm<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
) -> ProducesFlags {
    let v2 = &C::x64_cmpl_rm_raw(ctx, arg0, arg1);
    let v3 = &constructor_asm_produce_flags_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1548.
    return v3.clone();
}

// Generated as internal constructor for term x64_cmpq_rm.
pub fn constructor_x64_cmpq_rm<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
) -> ProducesFlags {
    let v2 = &C::x64_cmpq_rm_raw(ctx, arg0, arg1);
    let v3 = &constructor_asm_produce_flags_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1553.
    return v3.clone();
}

// Generated as internal constructor for term x64_testb_i.
pub fn constructor_x64_testb_i<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: u8,
) -> ProducesFlags {
    let v2 = &C::x64_testb_i_raw(ctx, arg0, arg1);
    let v3 = &constructor_asm_produce_flags_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1558.
    return v3.clone();
}

// Generated as internal constructor for term x64_testw_i.
pub fn constructor_x64_testw_i<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: u16,
) -> ProducesFlags {
    let v2 = &C::x64_testw_i_raw(ctx, arg0, arg1);
    let v3 = &constructor_asm_produce_flags_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1563.
    return v3.clone();
}

// Generated as internal constructor for term x64_testl_i.
pub fn constructor_x64_testl_i<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: u32,
) -> ProducesFlags {
    let v2 = &C::x64_testl_i_raw(ctx, arg0, arg1);
    let v3 = &constructor_asm_produce_flags_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1568.
    return v3.clone();
}

// Generated as internal constructor for term x64_testq_i.
pub fn constructor_x64_testq_i<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: i32,
) -> ProducesFlags {
    let v2 = &C::x64_testq_i_raw(ctx, arg0, arg1);
    let v3 = &constructor_asm_produce_flags_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1573.
    return v3.clone();
}

// Generated as internal constructor for term x64_testb_mi.
pub fn constructor_x64_testb_mi<C: Context>(
    ctx: &mut C,
    arg0: &GprMem,
    arg1: u8,
) -> ProducesFlags {
    let v2 = &C::x64_testb_mi_raw(ctx, arg0, arg1);
    let v3 = &constructor_asm_produce_flags_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1578.
    return v3.clone();
}

// Generated as internal constructor for term x64_testw_mi.
pub fn constructor_x64_testw_mi<C: Context>(
    ctx: &mut C,
    arg0: &GprMem,
    arg1: u16,
) -> ProducesFlags {
    let v2 = &C::x64_testw_mi_raw(ctx, arg0, arg1);
    let v3 = &constructor_asm_produce_flags_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1583.
    return v3.clone();
}

// Generated as internal constructor for term x64_testl_mi.
pub fn constructor_x64_testl_mi<C: Context>(
    ctx: &mut C,
    arg0: &GprMem,
    arg1: u32,
) -> ProducesFlags {
    let v2 = &C::x64_testl_mi_raw(ctx, arg0, arg1);
    let v3 = &constructor_asm_produce_flags_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1588.
    return v3.clone();
}

// Generated as internal constructor for term x64_testq_mi.
pub fn constructor_x64_testq_mi<C: Context>(
    ctx: &mut C,
    arg0: &GprMem,
    arg1: i32,
) -> ProducesFlags {
    let v2 = &C::x64_testq_mi_raw(ctx, arg0, arg1);
    let v3 = &constructor_asm_produce_flags_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1593.
    return v3.clone();
}

// Generated as internal constructor for term x64_testb_mr.
pub fn constructor_x64_testb_mr<C: Context>(
    ctx: &mut C,
    arg0: &GprMem,
    arg1: Gpr,
) -> ProducesFlags {
    let v2 = &C::x64_testb_mr_raw(ctx, arg0, arg1);
    let v3 = &constructor_asm_produce_flags_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1598.
    return v3.clone();
}

// Generated as internal constructor for term x64_testw_mr.
pub fn constructor_x64_testw_mr<C: Context>(
    ctx: &mut C,
    arg0: &GprMem,
    arg1: Gpr,
) -> ProducesFlags {
    let v2 = &C::x64_testw_mr_raw(ctx, arg0, arg1);
    let v3 = &constructor_asm_produce_flags_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1603.
    return v3.clone();
}

// Generated as internal constructor for term x64_testl_mr.
pub fn constructor_x64_testl_mr<C: Context>(
    ctx: &mut C,
    arg0: &GprMem,
    arg1: Gpr,
) -> ProducesFlags {
    let v2 = &C::x64_testl_mr_raw(ctx, arg0, arg1);
    let v3 = &constructor_asm_produce_flags_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1608.
    return v3.clone();
}

// Generated as internal constructor for term x64_testq_mr.
pub fn constructor_x64_testq_mr<C: Context>(
    ctx: &mut C,
    arg0: &GprMem,
    arg1: Gpr,
) -> ProducesFlags {
    let v2 = &C::x64_testq_mr_raw(ctx, arg0, arg1);
    let v3 = &constructor_asm_produce_flags_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1613.
    return v3.clone();
}

// Generated as internal constructor for term x64_ptest_rm.
pub fn constructor_x64_ptest_rm<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> ProducesFlags {
    let v2 = &C::x64_ptest_rm_raw(ctx, arg0, arg1);
    let v3 = &constructor_asm_produce_flags_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1618.
    return v3.clone();
}

// Generated as internal constructor for term x64_ptest_rm_or_avx.
pub fn constructor_x64_ptest_rm_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> ProducesFlags {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = &constructor_x64_vptest_rm(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 1620.
        return v3.clone();
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = &constructor_x64_ptest_rm(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 1623.
    return v5.clone();
}

// Generated as internal constructor for term x64_vptest_rm.
pub fn constructor_x64_vptest_rm<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> ProducesFlags {
    let v2 = &C::x64_vptest_rm_raw(ctx, arg0, arg1);
    let v3 = &constructor_asm_produce_flags_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1628.
    return v3.clone();
}

// Generated as internal constructor for term x64_ucomiss_a.
pub fn constructor_x64_ucomiss_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> ProducesFlags {
    let v2 = &C::x64_ucomiss_a_raw(ctx, arg0, arg1);
    let v3 = &constructor_asm_produce_flags_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1633.
    return v3.clone();
}

// Generated as internal constructor for term x64_ucomiss_a_or_avx.
pub fn constructor_x64_ucomiss_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> ProducesFlags {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = &constructor_x64_vucomiss_a(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 1635.
        return v3.clone();
    }
    let v4 = &constructor_x64_ucomiss_a(ctx, arg0, arg1);
    // Rule at <OUT_DIR>/assembler.isle line 1638.
    return v4.clone();
}

// Generated as internal constructor for term x64_ucomisd_a.
pub fn constructor_x64_ucomisd_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> ProducesFlags {
    let v2 = &C::x64_ucomisd_a_raw(ctx, arg0, arg1);
    let v3 = &constructor_asm_produce_flags_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1643.
    return v3.clone();
}

// Generated as internal constructor for term x64_ucomisd_a_or_avx.
pub fn constructor_x64_ucomisd_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> ProducesFlags {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = &constructor_x64_vucomisd_a(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 1645.
        return v3.clone();
    }
    let v4 = &constructor_x64_ucomisd_a(ctx, arg0, arg1);
    // Rule at <OUT_DIR>/assembler.isle line 1648.
    return v4.clone();
}

// Generated as internal constructor for term x64_vucomiss_a.
pub fn constructor_x64_vucomiss_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> ProducesFlags {
    let v2 = &C::x64_vucomiss_a_raw(ctx, arg0, arg1);
    let v3 = &constructor_asm_produce_flags_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1653.
    return v3.clone();
}

// Generated as internal constructor for term x64_vucomisd_a.
pub fn constructor_x64_vucomisd_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> ProducesFlags {
    let v2 = &C::x64_vucomisd_a_raw(ctx, arg0, arg1);
    let v3 = &constructor_asm_produce_flags_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1658.
    return v3.clone();
}

// Generated as internal constructor for term x64_cmpss_a.
pub fn constructor_x64_cmpss_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
    arg2: u8,
) -> Xmm {
    let v3 = &C::x64_cmpss_a_raw(ctx, arg0, arg1, arg2);
    let v4 = constructor_emit_ret_xmm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 1663.
    return v4;
}

// Generated as internal constructor for term x64_cmpsd_a.
pub fn constructor_x64_cmpsd_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
    arg2: u8,
) -> Xmm {
    let v3 = &C::x64_cmpsd_a_raw(ctx, arg0, arg1, arg2);
    let v4 = constructor_emit_ret_xmm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 1668.
    return v4;
}

// Generated as internal constructor for term x64_cmpps_a.
pub fn constructor_x64_cmpps_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
    arg2: u8,
) -> Xmm {
    let v3 = &C::x64_cmpps_a_raw(ctx, arg0, arg1, arg2);
    let v4 = constructor_emit_ret_xmm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 1673.
    return v4;
}

// Generated as internal constructor for term x64_cmppd_a.
pub fn constructor_x64_cmppd_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
    arg2: u8,
) -> Xmm {
    let v3 = &C::x64_cmppd_a_raw(ctx, arg0, arg1, arg2);
    let v4 = constructor_emit_ret_xmm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 1678.
    return v4;
}

// Generated as internal constructor for term x64_vcmpss_b.
pub fn constructor_x64_vcmpss_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
    arg2: u8,
) -> Xmm {
    let v3 = &C::x64_vcmpss_b_raw(ctx, arg0, arg1, arg2);
    let v4 = constructor_emit_ret_xmm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 1683.
    return v4;
}

// Generated as internal constructor for term x64_vcmpsd_b.
pub fn constructor_x64_vcmpsd_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
    arg2: u8,
) -> Xmm {
    let v3 = &C::x64_vcmpsd_b_raw(ctx, arg0, arg1, arg2);
    let v4 = constructor_emit_ret_xmm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 1688.
    return v4;
}

// Generated as internal constructor for term x64_vcmpps_b.
pub fn constructor_x64_vcmpps_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
    arg2: u8,
) -> Xmm {
    let v3 = &C::x64_vcmpps_b_raw(ctx, arg0, arg1, arg2);
    let v4 = constructor_emit_ret_xmm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 1693.
    return v4;
}

// Generated as internal constructor for term x64_vcmppd_b.
pub fn constructor_x64_vcmppd_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
    arg2: u8,
) -> Xmm {
    let v3 = &C::x64_vcmppd_b_raw(ctx, arg0, arg1, arg2);
    let v4 = constructor_emit_ret_xmm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 1698.
    return v4;
}

// Generated as internal constructor for term x64_pcmpeqb_a.
pub fn constructor_x64_pcmpeqb_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_pcmpeqb_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1703.
    return v3;
}

// Generated as internal constructor for term x64_pcmpeqb_a_or_avx.
pub fn constructor_x64_pcmpeqb_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vpcmpeqb_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 1705.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_pcmpeqb_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 1708.
    return v5;
}

// Generated as internal constructor for term x64_pcmpeqw_a.
pub fn constructor_x64_pcmpeqw_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_pcmpeqw_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1713.
    return v3;
}

// Generated as internal constructor for term x64_pcmpeqw_a_or_avx.
pub fn constructor_x64_pcmpeqw_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vpcmpeqw_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 1715.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_pcmpeqw_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 1718.
    return v5;
}

// Generated as internal constructor for term x64_pcmpeqd_a.
pub fn constructor_x64_pcmpeqd_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_pcmpeqd_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1723.
    return v3;
}

// Generated as internal constructor for term x64_pcmpeqd_a_or_avx.
pub fn constructor_x64_pcmpeqd_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vpcmpeqd_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 1725.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_pcmpeqd_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 1728.
    return v5;
}

// Generated as internal constructor for term x64_pcmpeqq_a.
pub fn constructor_x64_pcmpeqq_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_pcmpeqq_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1733.
    return v3;
}

// Generated as internal constructor for term x64_pcmpeqq_a_or_avx.
pub fn constructor_x64_pcmpeqq_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vpcmpeqq_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 1735.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_pcmpeqq_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 1738.
    return v5;
}

// Generated as internal constructor for term x64_pcmpgtb_a.
pub fn constructor_x64_pcmpgtb_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_pcmpgtb_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1743.
    return v3;
}

// Generated as internal constructor for term x64_pcmpgtb_a_or_avx.
pub fn constructor_x64_pcmpgtb_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vpcmpgtb_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 1745.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_pcmpgtb_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 1748.
    return v5;
}

// Generated as internal constructor for term x64_pcmpgtw_a.
pub fn constructor_x64_pcmpgtw_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_pcmpgtw_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1753.
    return v3;
}

// Generated as internal constructor for term x64_pcmpgtw_a_or_avx.
pub fn constructor_x64_pcmpgtw_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vpcmpgtw_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 1755.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_pcmpgtw_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 1758.
    return v5;
}

// Generated as internal constructor for term x64_pcmpgtd_a.
pub fn constructor_x64_pcmpgtd_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_pcmpgtd_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1763.
    return v3;
}

// Generated as internal constructor for term x64_pcmpgtd_a_or_avx.
pub fn constructor_x64_pcmpgtd_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vpcmpgtd_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 1765.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_pcmpgtd_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 1768.
    return v5;
}

// Generated as internal constructor for term x64_pcmpgtq_a.
pub fn constructor_x64_pcmpgtq_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_pcmpgtq_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1773.
    return v3;
}

// Generated as internal constructor for term x64_pcmpgtq_a_or_avx.
pub fn constructor_x64_pcmpgtq_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vpcmpgtq_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 1775.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_pcmpgtq_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 1778.
    return v5;
}

// Generated as internal constructor for term x64_vpcmpeqb_b.
pub fn constructor_x64_vpcmpeqb_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vpcmpeqb_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1783.
    return v3;
}

// Generated as internal constructor for term x64_vpcmpeqw_b.
pub fn constructor_x64_vpcmpeqw_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vpcmpeqw_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1788.
    return v3;
}

// Generated as internal constructor for term x64_vpcmpeqd_b.
pub fn constructor_x64_vpcmpeqd_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vpcmpeqd_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1793.
    return v3;
}

// Generated as internal constructor for term x64_vpcmpeqq_b.
pub fn constructor_x64_vpcmpeqq_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vpcmpeqq_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1798.
    return v3;
}

// Generated as internal constructor for term x64_vpcmpgtb_b.
pub fn constructor_x64_vpcmpgtb_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vpcmpgtb_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1803.
    return v3;
}

// Generated as internal constructor for term x64_vpcmpgtw_b.
pub fn constructor_x64_vpcmpgtw_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vpcmpgtw_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1808.
    return v3;
}

// Generated as internal constructor for term x64_vpcmpgtd_b.
pub fn constructor_x64_vpcmpgtd_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vpcmpgtd_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1813.
    return v3;
}

// Generated as internal constructor for term x64_vpcmpgtq_b.
pub fn constructor_x64_vpcmpgtq_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vpcmpgtq_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1818.
    return v3;
}

// Generated as internal constructor for term x64_cvtps2pd_a.
pub fn constructor_x64_cvtps2pd_a<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = &C::x64_cvtps2pd_a_raw(ctx, arg0);
    let v2 = constructor_emit_ret_xmm(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 1823.
    return v2;
}

// Generated as internal constructor for term x64_cvttps2dq_a.
pub fn constructor_x64_cvttps2dq_a<C: Context>(
    ctx: &mut C,
    arg0: &XmmMemAligned,
) -> Xmm {
    let v1 = &C::x64_cvttps2dq_a_raw(ctx, arg0);
    let v2 = constructor_emit_ret_xmm(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 1828.
    return v2;
}

// Generated as internal constructor for term x64_cvtss2sd_a.
pub fn constructor_x64_cvtss2sd_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_cvtss2sd_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1833.
    return v3;
}

// Generated as internal constructor for term x64_cvtss2si_a.
pub fn constructor_x64_cvtss2si_a<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Gpr {
    let v1 = &C::x64_cvtss2si_a_raw(ctx, arg0);
    let v2 = constructor_emit_ret_gpr(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 1838.
    return v2;
}

// Generated as internal constructor for term x64_cvtss2si_aq.
pub fn constructor_x64_cvtss2si_aq<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Gpr {
    let v1 = &C::x64_cvtss2si_aq_raw(ctx, arg0);
    let v2 = constructor_emit_ret_gpr(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 1843.
    return v2;
}

// Generated as internal constructor for term x64_cvttss2si_a.
pub fn constructor_x64_cvttss2si_a<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Gpr {
    let v1 = &C::x64_cvttss2si_a_raw(ctx, arg0);
    let v2 = constructor_emit_ret_gpr(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 1848.
    return v2;
}

// Generated as internal constructor for term x64_cvttss2si_aq.
pub fn constructor_x64_cvttss2si_aq<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Gpr {
    let v1 = &C::x64_cvttss2si_aq_raw(ctx, arg0);
    let v2 = constructor_emit_ret_gpr(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 1853.
    return v2;
}

// Generated as internal constructor for term x64_vcvtps2pd_a.
pub fn constructor_x64_vcvtps2pd_a<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = &C::x64_vcvtps2pd_a_raw(ctx, arg0);
    let v2 = constructor_emit_ret_xmm(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 1858.
    return v2;
}

// Generated as internal constructor for term x64_vcvttps2dq_a.
pub fn constructor_x64_vcvttps2dq_a<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = &C::x64_vcvttps2dq_a_raw(ctx, arg0);
    let v2 = constructor_emit_ret_xmm(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 1863.
    return v2;
}

// Generated as internal constructor for term x64_vcvtss2sd_b.
pub fn constructor_x64_vcvtss2sd_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vcvtss2sd_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1868.
    return v3;
}

// Generated as internal constructor for term x64_vcvtss2si_a.
pub fn constructor_x64_vcvtss2si_a<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Gpr {
    let v1 = &C::x64_vcvtss2si_a_raw(ctx, arg0);
    let v2 = constructor_emit_ret_gpr(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 1873.
    return v2;
}

// Generated as internal constructor for term x64_vcvtss2si_aq.
pub fn constructor_x64_vcvtss2si_aq<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Gpr {
    let v1 = &C::x64_vcvtss2si_aq_raw(ctx, arg0);
    let v2 = constructor_emit_ret_gpr(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 1878.
    return v2;
}

// Generated as internal constructor for term x64_vcvttss2si_a.
pub fn constructor_x64_vcvttss2si_a<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Gpr {
    let v1 = &C::x64_vcvttss2si_a_raw(ctx, arg0);
    let v2 = constructor_emit_ret_gpr(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 1883.
    return v2;
}

// Generated as internal constructor for term x64_vcvttss2si_aq.
pub fn constructor_x64_vcvttss2si_aq<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Gpr {
    let v1 = &C::x64_vcvttss2si_aq_raw(ctx, arg0);
    let v2 = constructor_emit_ret_gpr(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 1888.
    return v2;
}

// Generated as internal constructor for term x64_cvtpd2ps_a.
pub fn constructor_x64_cvtpd2ps_a<C: Context>(
    ctx: &mut C,
    arg0: &XmmMemAligned,
) -> Xmm {
    let v1 = &C::x64_cvtpd2ps_a_raw(ctx, arg0);
    let v2 = constructor_emit_ret_xmm(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 1893.
    return v2;
}

// Generated as internal constructor for term x64_cvttpd2dq_a.
pub fn constructor_x64_cvttpd2dq_a<C: Context>(
    ctx: &mut C,
    arg0: &XmmMemAligned,
) -> Xmm {
    let v1 = &C::x64_cvttpd2dq_a_raw(ctx, arg0);
    let v2 = constructor_emit_ret_xmm(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 1898.
    return v2;
}

// Generated as internal constructor for term x64_cvtsd2ss_a.
pub fn constructor_x64_cvtsd2ss_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_cvtsd2ss_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1903.
    return v3;
}

// Generated as internal constructor for term x64_cvtsd2si_a.
pub fn constructor_x64_cvtsd2si_a<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Gpr {
    let v1 = &C::x64_cvtsd2si_a_raw(ctx, arg0);
    let v2 = constructor_emit_ret_gpr(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 1908.
    return v2;
}

// Generated as internal constructor for term x64_cvtsd2si_aq.
pub fn constructor_x64_cvtsd2si_aq<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Gpr {
    let v1 = &C::x64_cvtsd2si_aq_raw(ctx, arg0);
    let v2 = constructor_emit_ret_gpr(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 1913.
    return v2;
}

// Generated as internal constructor for term x64_cvttsd2si_a.
pub fn constructor_x64_cvttsd2si_a<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Gpr {
    let v1 = &C::x64_cvttsd2si_a_raw(ctx, arg0);
    let v2 = constructor_emit_ret_gpr(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 1918.
    return v2;
}

// Generated as internal constructor for term x64_cvttsd2si_aq.
pub fn constructor_x64_cvttsd2si_aq<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Gpr {
    let v1 = &C::x64_cvttsd2si_aq_raw(ctx, arg0);
    let v2 = constructor_emit_ret_gpr(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 1923.
    return v2;
}

// Generated as internal constructor for term x64_vcvtpd2ps_a.
pub fn constructor_x64_vcvtpd2ps_a<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = &C::x64_vcvtpd2ps_a_raw(ctx, arg0);
    let v2 = constructor_emit_ret_xmm(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 1928.
    return v2;
}

// Generated as internal constructor for term x64_vcvttpd2dq_a.
pub fn constructor_x64_vcvttpd2dq_a<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = &C::x64_vcvttpd2dq_a_raw(ctx, arg0);
    let v2 = constructor_emit_ret_xmm(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 1933.
    return v2;
}

// Generated as internal constructor for term x64_vcvtsd2ss_b.
pub fn constructor_x64_vcvtsd2ss_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vcvtsd2ss_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1938.
    return v3;
}

// Generated as internal constructor for term x64_vcvtsd2si_a.
pub fn constructor_x64_vcvtsd2si_a<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Gpr {
    let v1 = &C::x64_vcvtsd2si_a_raw(ctx, arg0);
    let v2 = constructor_emit_ret_gpr(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 1943.
    return v2;
}

// Generated as internal constructor for term x64_vcvtsd2si_aq.
pub fn constructor_x64_vcvtsd2si_aq<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Gpr {
    let v1 = &C::x64_vcvtsd2si_aq_raw(ctx, arg0);
    let v2 = constructor_emit_ret_gpr(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 1948.
    return v2;
}

// Generated as internal constructor for term x64_vcvttsd2si_a.
pub fn constructor_x64_vcvttsd2si_a<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Gpr {
    let v1 = &C::x64_vcvttsd2si_a_raw(ctx, arg0);
    let v2 = constructor_emit_ret_gpr(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 1953.
    return v2;
}

// Generated as internal constructor for term x64_vcvttsd2si_aq.
pub fn constructor_x64_vcvttsd2si_aq<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Gpr {
    let v1 = &C::x64_vcvttsd2si_aq_raw(ctx, arg0);
    let v2 = constructor_emit_ret_gpr(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 1958.
    return v2;
}

// Generated as internal constructor for term x64_cvtdq2ps_a.
pub fn constructor_x64_cvtdq2ps_a<C: Context>(
    ctx: &mut C,
    arg0: &XmmMemAligned,
) -> Xmm {
    let v1 = &C::x64_cvtdq2ps_a_raw(ctx, arg0);
    let v2 = constructor_emit_ret_xmm(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 1963.
    return v2;
}

// Generated as internal constructor for term x64_cvtdq2pd_a.
pub fn constructor_x64_cvtdq2pd_a<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = &C::x64_cvtdq2pd_a_raw(ctx, arg0);
    let v2 = constructor_emit_ret_xmm(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 1968.
    return v2;
}

// Generated as internal constructor for term x64_cvtsi2ssl_a.
pub fn constructor_x64_cvtsi2ssl_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &GprMem,
) -> Xmm {
    let v2 = &C::x64_cvtsi2ssl_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1973.
    return v3;
}

// Generated as internal constructor for term x64_cvtsi2ssq_a.
pub fn constructor_x64_cvtsi2ssq_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &GprMem,
) -> Xmm {
    let v2 = &C::x64_cvtsi2ssq_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1978.
    return v3;
}

// Generated as internal constructor for term x64_cvtsi2sdl_a.
pub fn constructor_x64_cvtsi2sdl_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &GprMem,
) -> Xmm {
    let v2 = &C::x64_cvtsi2sdl_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1983.
    return v3;
}

// Generated as internal constructor for term x64_cvtsi2sdq_a.
pub fn constructor_x64_cvtsi2sdq_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &GprMem,
) -> Xmm {
    let v2 = &C::x64_cvtsi2sdq_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 1988.
    return v3;
}

// Generated as internal constructor for term x64_vcvtdq2pd_a.
pub fn constructor_x64_vcvtdq2pd_a<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = &C::x64_vcvtdq2pd_a_raw(ctx, arg0);
    let v2 = constructor_emit_ret_xmm(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 1993.
    return v2;
}

// Generated as internal constructor for term x64_vcvtdq2ps_a.
pub fn constructor_x64_vcvtdq2ps_a<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = &C::x64_vcvtdq2ps_a_raw(ctx, arg0);
    let v2 = constructor_emit_ret_xmm(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 1998.
    return v2;
}

// Generated as internal constructor for term x64_vcvtsi2sdl_b.
pub fn constructor_x64_vcvtsi2sdl_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &GprMem,
) -> Xmm {
    let v2 = &C::x64_vcvtsi2sdl_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 2003.
    return v3;
}

// Generated as internal constructor for term x64_vcvtsi2sdq_b.
pub fn constructor_x64_vcvtsi2sdq_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &GprMem,
) -> Xmm {
    let v2 = &C::x64_vcvtsi2sdq_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 2008.
    return v3;
}

// Generated as internal constructor for term x64_vcvtsi2ssl_b.
pub fn constructor_x64_vcvtsi2ssl_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &GprMem,
) -> Xmm {
    let v2 = &C::x64_vcvtsi2ssl_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 2013.
    return v3;
}

// Generated as internal constructor for term x64_vcvtsi2ssq_b.
pub fn constructor_x64_vcvtsi2ssq_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &GprMem,
) -> Xmm {
    let v2 = &C::x64_vcvtsi2ssq_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 2018.
    return v3;
}

// Generated as internal constructor for term x64_vcvtudq2ps_a.
pub fn constructor_x64_vcvtudq2ps_a<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = &C::x64_vcvtudq2ps_a_raw(ctx, arg0);
    let v2 = constructor_emit_ret_xmm(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 2023.
    return v2;
}

// Generated as internal constructor for term x64_divb_m.
pub fn constructor_x64_divb_m<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
    arg2: &TrapCode,
) -> Gpr {
    let v3 = &C::x64_divb_m_raw(ctx, arg0, arg1, arg2);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 2028.
    return v4;
}

// Generated as internal constructor for term x64_divw_m.
pub fn constructor_x64_divw_m<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: Gpr,
    arg2: &GprMem,
    arg3: &TrapCode,
) -> ValueRegs {
    let v4 = &C::x64_divw_m_raw(ctx, arg0, arg1, arg2, arg3);
    let v5 = constructor_emit_ret_value_regs(ctx, v4);
    // Rule at <OUT_DIR>/assembler.isle line 2033.
    return v5;
}

// Generated as internal constructor for term x64_divl_m.
pub fn constructor_x64_divl_m<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: Gpr,
    arg2: &GprMem,
    arg3: &TrapCode,
) -> ValueRegs {
    let v4 = &C::x64_divl_m_raw(ctx, arg0, arg1, arg2, arg3);
    let v5 = constructor_emit_ret_value_regs(ctx, v4);
    // Rule at <OUT_DIR>/assembler.isle line 2038.
    return v5;
}

// Generated as internal constructor for term x64_divq_m.
pub fn constructor_x64_divq_m<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: Gpr,
    arg2: &GprMem,
    arg3: &TrapCode,
) -> ValueRegs {
    let v4 = &C::x64_divq_m_raw(ctx, arg0, arg1, arg2, arg3);
    let v5 = constructor_emit_ret_value_regs(ctx, v4);
    // Rule at <OUT_DIR>/assembler.isle line 2043.
    return v5;
}

// Generated as internal constructor for term x64_idivb_m.
pub fn constructor_x64_idivb_m<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
    arg2: &TrapCode,
) -> Gpr {
    let v3 = &C::x64_idivb_m_raw(ctx, arg0, arg1, arg2);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 2048.
    return v4;
}

// Generated as internal constructor for term x64_idivw_m.
pub fn constructor_x64_idivw_m<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: Gpr,
    arg2: &GprMem,
    arg3: &TrapCode,
) -> ValueRegs {
    let v4 = &C::x64_idivw_m_raw(ctx, arg0, arg1, arg2, arg3);
    let v5 = constructor_emit_ret_value_regs(ctx, v4);
    // Rule at <OUT_DIR>/assembler.isle line 2053.
    return v5;
}

// Generated as internal constructor for term x64_idivl_m.
pub fn constructor_x64_idivl_m<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: Gpr,
    arg2: &GprMem,
    arg3: &TrapCode,
) -> ValueRegs {
    let v4 = &C::x64_idivl_m_raw(ctx, arg0, arg1, arg2, arg3);
    let v5 = constructor_emit_ret_value_regs(ctx, v4);
    // Rule at <OUT_DIR>/assembler.isle line 2058.
    return v5;
}

// Generated as internal constructor for term x64_idivq_m.
pub fn constructor_x64_idivq_m<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: Gpr,
    arg2: &GprMem,
    arg3: &TrapCode,
) -> ValueRegs {
    let v4 = &C::x64_idivq_m_raw(ctx, arg0, arg1, arg2, arg3);
    let v5 = constructor_emit_ret_value_regs(ctx, v4);
    // Rule at <OUT_DIR>/assembler.isle line 2063.
    return v5;
}

// Generated as internal constructor for term x64_divss_a.
pub fn constructor_x64_divss_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_divss_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 2068.
    return v3;
}

// Generated as internal constructor for term x64_divss_a_or_avx.
pub fn constructor_x64_divss_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vdivss_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 2070.
        return v3;
    }
    let v4 = constructor_x64_divss_a(ctx, arg0, arg1);
    // Rule at <OUT_DIR>/assembler.isle line 2073.
    return v4;
}

// Generated as internal constructor for term x64_divsd_a.
pub fn constructor_x64_divsd_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_divsd_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 2078.
    return v3;
}

// Generated as internal constructor for term x64_divsd_a_or_avx.
pub fn constructor_x64_divsd_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vdivsd_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 2080.
        return v3;
    }
    let v4 = constructor_x64_divsd_a(ctx, arg0, arg1);
    // Rule at <OUT_DIR>/assembler.isle line 2083.
    return v4;
}

// Generated as internal constructor for term x64_divps_a.
pub fn constructor_x64_divps_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_divps_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 2088.
    return v3;
}

// Generated as internal constructor for term x64_divps_a_or_avx.
pub fn constructor_x64_divps_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vdivps_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 2090.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_divps_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 2093.
    return v5;
}

// Generated as internal constructor for term x64_divpd_a.
pub fn constructor_x64_divpd_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_divpd_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 2098.
    return v3;
}

// Generated as internal constructor for term x64_divpd_a_or_avx.
pub fn constructor_x64_divpd_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vdivpd_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 2100.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_divpd_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 2103.
    return v5;
}

// Generated as internal constructor for term x64_vdivss_b.
pub fn constructor_x64_vdivss_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vdivss_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 2108.
    return v3;
}

// Generated as internal constructor for term x64_vdivsd_b.
pub fn constructor_x64_vdivsd_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vdivsd_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 2113.
    return v3;
}

// Generated as internal constructor for term x64_vdivps_b.
pub fn constructor_x64_vdivps_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vdivps_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 2118.
    return v3;
}

// Generated as internal constructor for term x64_vdivpd_b.
pub fn constructor_x64_vdivpd_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vdivpd_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 2123.
    return v3;
}

// Generated as internal constructor for term x64_vfmadd132ss_a.
pub fn constructor_x64_vfmadd132ss_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: Xmm,
    arg2: &XmmMem,
) -> Xmm {
    let v3 = &C::x64_vfmadd132ss_a_raw(ctx, arg0, arg1, arg2);
    let v4 = constructor_emit_ret_xmm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 2128.
    return v4;
}

// Generated as internal constructor for term x64_vfmadd213ss_a.
pub fn constructor_x64_vfmadd213ss_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: Xmm,
    arg2: &XmmMem,
) -> Xmm {
    let v3 = &C::x64_vfmadd213ss_a_raw(ctx, arg0, arg1, arg2);
    let v4 = constructor_emit_ret_xmm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 2133.
    return v4;
}

// Generated as internal constructor for term x64_vfmadd231ss_a.
pub fn constructor_x64_vfmadd231ss_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: Xmm,
    arg2: &XmmMem,
) -> Xmm {
    let v3 = &C::x64_vfmadd231ss_a_raw(ctx, arg0, arg1, arg2);
    let v4 = constructor_emit_ret_xmm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 2138.
    return v4;
}

// Generated as internal constructor for term x64_vfmadd132sd_a.
pub fn constructor_x64_vfmadd132sd_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: Xmm,
    arg2: &XmmMem,
) -> Xmm {
    let v3 = &C::x64_vfmadd132sd_a_raw(ctx, arg0, arg1, arg2);
    let v4 = constructor_emit_ret_xmm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 2143.
    return v4;
}

// Generated as internal constructor for term x64_vfmadd213sd_a.
pub fn constructor_x64_vfmadd213sd_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: Xmm,
    arg2: &XmmMem,
) -> Xmm {
    let v3 = &C::x64_vfmadd213sd_a_raw(ctx, arg0, arg1, arg2);
    let v4 = constructor_emit_ret_xmm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 2148.
    return v4;
}

// Generated as internal constructor for term x64_vfmadd231sd_a.
pub fn constructor_x64_vfmadd231sd_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: Xmm,
    arg2: &XmmMem,
) -> Xmm {
    let v3 = &C::x64_vfmadd231sd_a_raw(ctx, arg0, arg1, arg2);
    let v4 = constructor_emit_ret_xmm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 2153.
    return v4;
}

// Generated as internal constructor for term x64_vfmadd132ps_a.
pub fn constructor_x64_vfmadd132ps_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: Xmm,
    arg2: &XmmMem,
) -> Xmm {
    let v3 = &C::x64_vfmadd132ps_a_raw(ctx, arg0, arg1, arg2);
    let v4 = constructor_emit_ret_xmm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 2158.
    return v4;
}

// Generated as internal constructor for term x64_vfmadd213ps_a.
pub fn constructor_x64_vfmadd213ps_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: Xmm,
    arg2: &XmmMem,
) -> Xmm {
    let v3 = &C::x64_vfmadd213ps_a_raw(ctx, arg0, arg1, arg2);
    let v4 = constructor_emit_ret_xmm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 2163.
    return v4;
}

// Generated as internal constructor for term x64_vfmadd231ps_a.
pub fn constructor_x64_vfmadd231ps_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: Xmm,
    arg2: &XmmMem,
) -> Xmm {
    let v3 = &C::x64_vfmadd231ps_a_raw(ctx, arg0, arg1, arg2);
    let v4 = constructor_emit_ret_xmm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 2168.
    return v4;
}

// Generated as internal constructor for term x64_vfmadd132pd_a.
pub fn constructor_x64_vfmadd132pd_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: Xmm,
    arg2: &XmmMem,
) -> Xmm {
    let v3 = &C::x64_vfmadd132pd_a_raw(ctx, arg0, arg1, arg2);
    let v4 = constructor_emit_ret_xmm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 2173.
    return v4;
}

// Generated as internal constructor for term x64_vfmadd213pd_a.
pub fn constructor_x64_vfmadd213pd_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: Xmm,
    arg2: &XmmMem,
) -> Xmm {
    let v3 = &C::x64_vfmadd213pd_a_raw(ctx, arg0, arg1, arg2);
    let v4 = constructor_emit_ret_xmm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 2178.
    return v4;
}

// Generated as internal constructor for term x64_vfmadd231pd_a.
pub fn constructor_x64_vfmadd231pd_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: Xmm,
    arg2: &XmmMem,
) -> Xmm {
    let v3 = &C::x64_vfmadd231pd_a_raw(ctx, arg0, arg1, arg2);
    let v4 = constructor_emit_ret_xmm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 2183.
    return v4;
}

// Generated as internal constructor for term x64_vfnmadd132ss_a.
pub fn constructor_x64_vfnmadd132ss_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: Xmm,
    arg2: &XmmMem,
) -> Xmm {
    let v3 = &C::x64_vfnmadd132ss_a_raw(ctx, arg0, arg1, arg2);
    let v4 = constructor_emit_ret_xmm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 2188.
    return v4;
}

// Generated as internal constructor for term x64_vfnmadd213ss_a.
pub fn constructor_x64_vfnmadd213ss_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: Xmm,
    arg2: &XmmMem,
) -> Xmm {
    let v3 = &C::x64_vfnmadd213ss_a_raw(ctx, arg0, arg1, arg2);
    let v4 = constructor_emit_ret_xmm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 2193.
    return v4;
}

// Generated as internal constructor for term x64_vfnmadd231ss_a.
pub fn constructor_x64_vfnmadd231ss_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: Xmm,
    arg2: &XmmMem,
) -> Xmm {
    let v3 = &C::x64_vfnmadd231ss_a_raw(ctx, arg0, arg1, arg2);
    let v4 = constructor_emit_ret_xmm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 2198.
    return v4;
}

// Generated as internal constructor for term x64_vfnmadd132sd_a.
pub fn constructor_x64_vfnmadd132sd_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: Xmm,
    arg2: &XmmMem,
) -> Xmm {
    let v3 = &C::x64_vfnmadd132sd_a_raw(ctx, arg0, arg1, arg2);
    let v4 = constructor_emit_ret_xmm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 2203.
    return v4;
}

// Generated as internal constructor for term x64_vfnmadd213sd_a.
pub fn constructor_x64_vfnmadd213sd_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: Xmm,
    arg2: &XmmMem,
) -> Xmm {
    let v3 = &C::x64_vfnmadd213sd_a_raw(ctx, arg0, arg1, arg2);
    let v4 = constructor_emit_ret_xmm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 2208.
    return v4;
}

// Generated as internal constructor for term x64_vfnmadd231sd_a.
pub fn constructor_x64_vfnmadd231sd_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: Xmm,
    arg2: &XmmMem,
) -> Xmm {
    let v3 = &C::x64_vfnmadd231sd_a_raw(ctx, arg0, arg1, arg2);
    let v4 = constructor_emit_ret_xmm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 2213.
    return v4;
}

// Generated as internal constructor for term x64_vfnmadd132ps_a.
pub fn constructor_x64_vfnmadd132ps_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: Xmm,
    arg2: &XmmMem,
) -> Xmm {
    let v3 = &C::x64_vfnmadd132ps_a_raw(ctx, arg0, arg1, arg2);
    let v4 = constructor_emit_ret_xmm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 2218.
    return v4;
}

// Generated as internal constructor for term x64_vfnmadd213ps_a.
pub fn constructor_x64_vfnmadd213ps_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: Xmm,
    arg2: &XmmMem,
) -> Xmm {
    let v3 = &C::x64_vfnmadd213ps_a_raw(ctx, arg0, arg1, arg2);
    let v4 = constructor_emit_ret_xmm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 2223.
    return v4;
}

// Generated as internal constructor for term x64_vfnmadd231ps_a.
pub fn constructor_x64_vfnmadd231ps_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: Xmm,
    arg2: &XmmMem,
) -> Xmm {
    let v3 = &C::x64_vfnmadd231ps_a_raw(ctx, arg0, arg1, arg2);
    let v4 = constructor_emit_ret_xmm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 2228.
    return v4;
}

// Generated as internal constructor for term x64_vfnmadd132pd_a.
pub fn constructor_x64_vfnmadd132pd_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: Xmm,
    arg2: &XmmMem,
) -> Xmm {
    let v3 = &C::x64_vfnmadd132pd_a_raw(ctx, arg0, arg1, arg2);
    let v4 = constructor_emit_ret_xmm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 2233.
    return v4;
}

// Generated as internal constructor for term x64_vfnmadd213pd_a.
pub fn constructor_x64_vfnmadd213pd_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: Xmm,
    arg2: &XmmMem,
) -> Xmm {
    let v3 = &C::x64_vfnmadd213pd_a_raw(ctx, arg0, arg1, arg2);
    let v4 = constructor_emit_ret_xmm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 2238.
    return v4;
}

// Generated as internal constructor for term x64_vfnmadd231pd_a.
pub fn constructor_x64_vfnmadd231pd_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: Xmm,
    arg2: &XmmMem,
) -> Xmm {
    let v3 = &C::x64_vfnmadd231pd_a_raw(ctx, arg0, arg1, arg2);
    let v4 = constructor_emit_ret_xmm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 2243.
    return v4;
}

// Generated as internal constructor for term x64_vfmsub132ss_a.
pub fn constructor_x64_vfmsub132ss_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: Xmm,
    arg2: &XmmMem,
) -> Xmm {
    let v3 = &C::x64_vfmsub132ss_a_raw(ctx, arg0, arg1, arg2);
    let v4 = constructor_emit_ret_xmm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 2248.
    return v4;
}

// Generated as internal constructor for term x64_vfmsub213ss_a.
pub fn constructor_x64_vfmsub213ss_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: Xmm,
    arg2: &XmmMem,
) -> Xmm {
    let v3 = &C::x64_vfmsub213ss_a_raw(ctx, arg0, arg1, arg2);
    let v4 = constructor_emit_ret_xmm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 2253.
    return v4;
}

// Generated as internal constructor for term x64_vfmsub231ss_a.
pub fn constructor_x64_vfmsub231ss_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: Xmm,
    arg2: &XmmMem,
) -> Xmm {
    let v3 = &C::x64_vfmsub231ss_a_raw(ctx, arg0, arg1, arg2);
    let v4 = constructor_emit_ret_xmm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 2258.
    return v4;
}

// Generated as internal constructor for term x64_vfmsub132sd_a.
pub fn constructor_x64_vfmsub132sd_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: Xmm,
    arg2: &XmmMem,
) -> Xmm {
    let v3 = &C::x64_vfmsub132sd_a_raw(ctx, arg0, arg1, arg2);
    let v4 = constructor_emit_ret_xmm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 2263.
    return v4;
}

// Generated as internal constructor for term x64_vfmsub213sd_a.
pub fn constructor_x64_vfmsub213sd_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: Xmm,
    arg2: &XmmMem,
) -> Xmm {
    let v3 = &C::x64_vfmsub213sd_a_raw(ctx, arg0, arg1, arg2);
    let v4 = constructor_emit_ret_xmm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 2268.
    return v4;
}

// Generated as internal constructor for term x64_vfmsub231sd_a.
pub fn constructor_x64_vfmsub231sd_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: Xmm,
    arg2: &XmmMem,
) -> Xmm {
    let v3 = &C::x64_vfmsub231sd_a_raw(ctx, arg0, arg1, arg2);
    let v4 = constructor_emit_ret_xmm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 2273.
    return v4;
}

// Generated as internal constructor for term x64_vfmsub132ps_a.
pub fn constructor_x64_vfmsub132ps_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: Xmm,
    arg2: &XmmMem,
) -> Xmm {
    let v3 = &C::x64_vfmsub132ps_a_raw(ctx, arg0, arg1, arg2);
    let v4 = constructor_emit_ret_xmm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 2278.
    return v4;
}

// Generated as internal constructor for term x64_vfmsub213ps_a.
pub fn constructor_x64_vfmsub213ps_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: Xmm,
    arg2: &XmmMem,
) -> Xmm {
    let v3 = &C::x64_vfmsub213ps_a_raw(ctx, arg0, arg1, arg2);
    let v4 = constructor_emit_ret_xmm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 2283.
    return v4;
}

// Generated as internal constructor for term x64_vfmsub231ps_a.
pub fn constructor_x64_vfmsub231ps_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: Xmm,
    arg2: &XmmMem,
) -> Xmm {
    let v3 = &C::x64_vfmsub231ps_a_raw(ctx, arg0, arg1, arg2);
    let v4 = constructor_emit_ret_xmm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 2288.
    return v4;
}

// Generated as internal constructor for term x64_vfmsub132pd_a.
pub fn constructor_x64_vfmsub132pd_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: Xmm,
    arg2: &XmmMem,
) -> Xmm {
    let v3 = &C::x64_vfmsub132pd_a_raw(ctx, arg0, arg1, arg2);
    let v4 = constructor_emit_ret_xmm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 2293.
    return v4;
}

// Generated as internal constructor for term x64_vfmsub213pd_a.
pub fn constructor_x64_vfmsub213pd_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: Xmm,
    arg2: &XmmMem,
) -> Xmm {
    let v3 = &C::x64_vfmsub213pd_a_raw(ctx, arg0, arg1, arg2);
    let v4 = constructor_emit_ret_xmm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 2298.
    return v4;
}

// Generated as internal constructor for term x64_vfmsub231pd_a.
pub fn constructor_x64_vfmsub231pd_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: Xmm,
    arg2: &XmmMem,
) -> Xmm {
    let v3 = &C::x64_vfmsub231pd_a_raw(ctx, arg0, arg1, arg2);
    let v4 = constructor_emit_ret_xmm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 2303.
    return v4;
}

// Generated as internal constructor for term x64_vfnmsub132ss_a.
pub fn constructor_x64_vfnmsub132ss_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: Xmm,
    arg2: &XmmMem,
) -> Xmm {
    let v3 = &C::x64_vfnmsub132ss_a_raw(ctx, arg0, arg1, arg2);
    let v4 = constructor_emit_ret_xmm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 2308.
    return v4;
}

// Generated as internal constructor for term x64_vfnmsub213ss_a.
pub fn constructor_x64_vfnmsub213ss_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: Xmm,
    arg2: &XmmMem,
) -> Xmm {
    let v3 = &C::x64_vfnmsub213ss_a_raw(ctx, arg0, arg1, arg2);
    let v4 = constructor_emit_ret_xmm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 2313.
    return v4;
}

// Generated as internal constructor for term x64_vfnmsub231ss_a.
pub fn constructor_x64_vfnmsub231ss_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: Xmm,
    arg2: &XmmMem,
) -> Xmm {
    let v3 = &C::x64_vfnmsub231ss_a_raw(ctx, arg0, arg1, arg2);
    let v4 = constructor_emit_ret_xmm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 2318.
    return v4;
}

// Generated as internal constructor for term x64_vfnmsub132sd_a.
pub fn constructor_x64_vfnmsub132sd_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: Xmm,
    arg2: &XmmMem,
) -> Xmm {
    let v3 = &C::x64_vfnmsub132sd_a_raw(ctx, arg0, arg1, arg2);
    let v4 = constructor_emit_ret_xmm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 2323.
    return v4;
}

// Generated as internal constructor for term x64_vfnmsub213sd_a.
pub fn constructor_x64_vfnmsub213sd_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: Xmm,
    arg2: &XmmMem,
) -> Xmm {
    let v3 = &C::x64_vfnmsub213sd_a_raw(ctx, arg0, arg1, arg2);
    let v4 = constructor_emit_ret_xmm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 2328.
    return v4;
}

// Generated as internal constructor for term x64_vfnmsub231sd_a.
pub fn constructor_x64_vfnmsub231sd_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: Xmm,
    arg2: &XmmMem,
) -> Xmm {
    let v3 = &C::x64_vfnmsub231sd_a_raw(ctx, arg0, arg1, arg2);
    let v4 = constructor_emit_ret_xmm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 2333.
    return v4;
}

// Generated as internal constructor for term x64_vfnmsub132ps_a.
pub fn constructor_x64_vfnmsub132ps_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: Xmm,
    arg2: &XmmMem,
) -> Xmm {
    let v3 = &C::x64_vfnmsub132ps_a_raw(ctx, arg0, arg1, arg2);
    let v4 = constructor_emit_ret_xmm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 2338.
    return v4;
}

// Generated as internal constructor for term x64_vfnmsub213ps_a.
pub fn constructor_x64_vfnmsub213ps_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: Xmm,
    arg2: &XmmMem,
) -> Xmm {
    let v3 = &C::x64_vfnmsub213ps_a_raw(ctx, arg0, arg1, arg2);
    let v4 = constructor_emit_ret_xmm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 2343.
    return v4;
}

// Generated as internal constructor for term x64_vfnmsub231ps_a.
pub fn constructor_x64_vfnmsub231ps_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: Xmm,
    arg2: &XmmMem,
) -> Xmm {
    let v3 = &C::x64_vfnmsub231ps_a_raw(ctx, arg0, arg1, arg2);
    let v4 = constructor_emit_ret_xmm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 2348.
    return v4;
}

// Generated as internal constructor for term x64_vfnmsub132pd_a.
pub fn constructor_x64_vfnmsub132pd_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: Xmm,
    arg2: &XmmMem,
) -> Xmm {
    let v3 = &C::x64_vfnmsub132pd_a_raw(ctx, arg0, arg1, arg2);
    let v4 = constructor_emit_ret_xmm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 2353.
    return v4;
}

// Generated as internal constructor for term x64_vfnmsub213pd_a.
pub fn constructor_x64_vfnmsub213pd_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: Xmm,
    arg2: &XmmMem,
) -> Xmm {
    let v3 = &C::x64_vfnmsub213pd_a_raw(ctx, arg0, arg1, arg2);
    let v4 = constructor_emit_ret_xmm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 2358.
    return v4;
}

// Generated as internal constructor for term x64_vfnmsub231pd_a.
pub fn constructor_x64_vfnmsub231pd_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: Xmm,
    arg2: &XmmMem,
) -> Xmm {
    let v3 = &C::x64_vfnmsub231pd_a_raw(ctx, arg0, arg1, arg2);
    let v4 = constructor_emit_ret_xmm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 2363.
    return v4;
}

// Generated as internal constructor for term x64_jmpq_m.
pub fn constructor_x64_jmpq_m<C: Context>(
    ctx: &mut C,
    arg0: &GprMem,
) -> SideEffectNoResult {
    let v1 = &C::x64_jmpq_m_raw(ctx, arg0);
    let v2 = &constructor_defer_side_effect(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 2368.
    return v2.clone();
}

// Generated as internal constructor for term x64_jmp_d8.
pub fn constructor_x64_jmp_d8<C: Context>(
    ctx: &mut C,
    arg0: i8,
) -> SideEffectNoResult {
    let v1 = &C::x64_jmp_d8_raw(ctx, arg0);
    let v2 = &constructor_defer_side_effect(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 2373.
    return v2.clone();
}

// Generated as internal constructor for term x64_jmp_d32.
pub fn constructor_x64_jmp_d32<C: Context>(
    ctx: &mut C,
    arg0: i32,
) -> SideEffectNoResult {
    let v1 = &C::x64_jmp_d32_raw(ctx, arg0);
    let v2 = &constructor_defer_side_effect(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 2378.
    return v2.clone();
}

// Generated as internal constructor for term x64_ja_d8.
pub fn constructor_x64_ja_d8<C: Context>(
    ctx: &mut C,
    arg0: i8,
) -> SideEffectNoResult {
    let v1 = &C::x64_ja_d8_raw(ctx, arg0);
    let v2 = &constructor_defer_side_effect(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 2383.
    return v2.clone();
}

// Generated as internal constructor for term x64_ja_d32.
pub fn constructor_x64_ja_d32<C: Context>(
    ctx: &mut C,
    arg0: i32,
) -> SideEffectNoResult {
    let v1 = &C::x64_ja_d32_raw(ctx, arg0);
    let v2 = &constructor_defer_side_effect(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 2388.
    return v2.clone();
}

// Generated as internal constructor for term x64_jae_d8.
pub fn constructor_x64_jae_d8<C: Context>(
    ctx: &mut C,
    arg0: i8,
) -> SideEffectNoResult {
    let v1 = &C::x64_jae_d8_raw(ctx, arg0);
    let v2 = &constructor_defer_side_effect(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 2393.
    return v2.clone();
}

// Generated as internal constructor for term x64_jae_d32.
pub fn constructor_x64_jae_d32<C: Context>(
    ctx: &mut C,
    arg0: i32,
) -> SideEffectNoResult {
    let v1 = &C::x64_jae_d32_raw(ctx, arg0);
    let v2 = &constructor_defer_side_effect(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 2398.
    return v2.clone();
}

// Generated as internal constructor for term x64_jb_d8.
pub fn constructor_x64_jb_d8<C: Context>(
    ctx: &mut C,
    arg0: i8,
) -> SideEffectNoResult {
    let v1 = &C::x64_jb_d8_raw(ctx, arg0);
    let v2 = &constructor_defer_side_effect(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 2403.
    return v2.clone();
}

// Generated as internal constructor for term x64_jb_d32.
pub fn constructor_x64_jb_d32<C: Context>(
    ctx: &mut C,
    arg0: i32,
) -> SideEffectNoResult {
    let v1 = &C::x64_jb_d32_raw(ctx, arg0);
    let v2 = &constructor_defer_side_effect(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 2408.
    return v2.clone();
}

// Generated as internal constructor for term x64_jbe_d8.
pub fn constructor_x64_jbe_d8<C: Context>(
    ctx: &mut C,
    arg0: i8,
) -> SideEffectNoResult {
    let v1 = &C::x64_jbe_d8_raw(ctx, arg0);
    let v2 = &constructor_defer_side_effect(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 2413.
    return v2.clone();
}

// Generated as internal constructor for term x64_jbe_d32.
pub fn constructor_x64_jbe_d32<C: Context>(
    ctx: &mut C,
    arg0: i32,
) -> SideEffectNoResult {
    let v1 = &C::x64_jbe_d32_raw(ctx, arg0);
    let v2 = &constructor_defer_side_effect(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 2418.
    return v2.clone();
}

// Generated as internal constructor for term x64_je_d8.
pub fn constructor_x64_je_d8<C: Context>(
    ctx: &mut C,
    arg0: i8,
) -> SideEffectNoResult {
    let v1 = &C::x64_je_d8_raw(ctx, arg0);
    let v2 = &constructor_defer_side_effect(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 2423.
    return v2.clone();
}

// Generated as internal constructor for term x64_je_d32.
pub fn constructor_x64_je_d32<C: Context>(
    ctx: &mut C,
    arg0: i32,
) -> SideEffectNoResult {
    let v1 = &C::x64_je_d32_raw(ctx, arg0);
    let v2 = &constructor_defer_side_effect(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 2428.
    return v2.clone();
}

// Generated as internal constructor for term x64_jg_d8.
pub fn constructor_x64_jg_d8<C: Context>(
    ctx: &mut C,
    arg0: i8,
) -> SideEffectNoResult {
    let v1 = &C::x64_jg_d8_raw(ctx, arg0);
    let v2 = &constructor_defer_side_effect(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 2433.
    return v2.clone();
}

// Generated as internal constructor for term x64_jg_d32.
pub fn constructor_x64_jg_d32<C: Context>(
    ctx: &mut C,
    arg0: i32,
) -> SideEffectNoResult {
    let v1 = &C::x64_jg_d32_raw(ctx, arg0);
    let v2 = &constructor_defer_side_effect(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 2438.
    return v2.clone();
}

// Generated as internal constructor for term x64_jge_d8.
pub fn constructor_x64_jge_d8<C: Context>(
    ctx: &mut C,
    arg0: i8,
) -> SideEffectNoResult {
    let v1 = &C::x64_jge_d8_raw(ctx, arg0);
    let v2 = &constructor_defer_side_effect(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 2443.
    return v2.clone();
}

// Generated as internal constructor for term x64_jge_d32.
pub fn constructor_x64_jge_d32<C: Context>(
    ctx: &mut C,
    arg0: i32,
) -> SideEffectNoResult {
    let v1 = &C::x64_jge_d32_raw(ctx, arg0);
    let v2 = &constructor_defer_side_effect(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 2448.
    return v2.clone();
}

// Generated as internal constructor for term x64_jl_d8.
pub fn constructor_x64_jl_d8<C: Context>(
    ctx: &mut C,
    arg0: i8,
) -> SideEffectNoResult {
    let v1 = &C::x64_jl_d8_raw(ctx, arg0);
    let v2 = &constructor_defer_side_effect(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 2453.
    return v2.clone();
}

// Generated as internal constructor for term x64_jl_d32.
pub fn constructor_x64_jl_d32<C: Context>(
    ctx: &mut C,
    arg0: i32,
) -> SideEffectNoResult {
    let v1 = &C::x64_jl_d32_raw(ctx, arg0);
    let v2 = &constructor_defer_side_effect(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 2458.
    return v2.clone();
}

// Generated as internal constructor for term x64_jle_d8.
pub fn constructor_x64_jle_d8<C: Context>(
    ctx: &mut C,
    arg0: i8,
) -> SideEffectNoResult {
    let v1 = &C::x64_jle_d8_raw(ctx, arg0);
    let v2 = &constructor_defer_side_effect(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 2463.
    return v2.clone();
}

// Generated as internal constructor for term x64_jle_d32.
pub fn constructor_x64_jle_d32<C: Context>(
    ctx: &mut C,
    arg0: i32,
) -> SideEffectNoResult {
    let v1 = &C::x64_jle_d32_raw(ctx, arg0);
    let v2 = &constructor_defer_side_effect(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 2468.
    return v2.clone();
}

// Generated as internal constructor for term x64_jne_d8.
pub fn constructor_x64_jne_d8<C: Context>(
    ctx: &mut C,
    arg0: i8,
) -> SideEffectNoResult {
    let v1 = &C::x64_jne_d8_raw(ctx, arg0);
    let v2 = &constructor_defer_side_effect(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 2473.
    return v2.clone();
}

// Generated as internal constructor for term x64_jne_d32.
pub fn constructor_x64_jne_d32<C: Context>(
    ctx: &mut C,
    arg0: i32,
) -> SideEffectNoResult {
    let v1 = &C::x64_jne_d32_raw(ctx, arg0);
    let v2 = &constructor_defer_side_effect(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 2478.
    return v2.clone();
}

// Generated as internal constructor for term x64_jno_d8.
pub fn constructor_x64_jno_d8<C: Context>(
    ctx: &mut C,
    arg0: i8,
) -> SideEffectNoResult {
    let v1 = &C::x64_jno_d8_raw(ctx, arg0);
    let v2 = &constructor_defer_side_effect(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 2483.
    return v2.clone();
}

// Generated as internal constructor for term x64_jno_d32.
pub fn constructor_x64_jno_d32<C: Context>(
    ctx: &mut C,
    arg0: i32,
) -> SideEffectNoResult {
    let v1 = &C::x64_jno_d32_raw(ctx, arg0);
    let v2 = &constructor_defer_side_effect(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 2488.
    return v2.clone();
}

// Generated as internal constructor for term x64_jnp_d8.
pub fn constructor_x64_jnp_d8<C: Context>(
    ctx: &mut C,
    arg0: i8,
) -> SideEffectNoResult {
    let v1 = &C::x64_jnp_d8_raw(ctx, arg0);
    let v2 = &constructor_defer_side_effect(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 2493.
    return v2.clone();
}

// Generated as internal constructor for term x64_jnp_d32.
pub fn constructor_x64_jnp_d32<C: Context>(
    ctx: &mut C,
    arg0: i32,
) -> SideEffectNoResult {
    let v1 = &C::x64_jnp_d32_raw(ctx, arg0);
    let v2 = &constructor_defer_side_effect(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 2498.
    return v2.clone();
}

// Generated as internal constructor for term x64_jns_d8.
pub fn constructor_x64_jns_d8<C: Context>(
    ctx: &mut C,
    arg0: i8,
) -> SideEffectNoResult {
    let v1 = &C::x64_jns_d8_raw(ctx, arg0);
    let v2 = &constructor_defer_side_effect(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 2503.
    return v2.clone();
}

// Generated as internal constructor for term x64_jns_d32.
pub fn constructor_x64_jns_d32<C: Context>(
    ctx: &mut C,
    arg0: i32,
) -> SideEffectNoResult {
    let v1 = &C::x64_jns_d32_raw(ctx, arg0);
    let v2 = &constructor_defer_side_effect(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 2508.
    return v2.clone();
}

// Generated as internal constructor for term x64_jo_d8.
pub fn constructor_x64_jo_d8<C: Context>(
    ctx: &mut C,
    arg0: i8,
) -> SideEffectNoResult {
    let v1 = &C::x64_jo_d8_raw(ctx, arg0);
    let v2 = &constructor_defer_side_effect(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 2513.
    return v2.clone();
}

// Generated as internal constructor for term x64_jo_d32.
pub fn constructor_x64_jo_d32<C: Context>(
    ctx: &mut C,
    arg0: i32,
) -> SideEffectNoResult {
    let v1 = &C::x64_jo_d32_raw(ctx, arg0);
    let v2 = &constructor_defer_side_effect(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 2518.
    return v2.clone();
}

// Generated as internal constructor for term x64_jp_d8.
pub fn constructor_x64_jp_d8<C: Context>(
    ctx: &mut C,
    arg0: i8,
) -> SideEffectNoResult {
    let v1 = &C::x64_jp_d8_raw(ctx, arg0);
    let v2 = &constructor_defer_side_effect(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 2523.
    return v2.clone();
}

// Generated as internal constructor for term x64_jp_d32.
pub fn constructor_x64_jp_d32<C: Context>(
    ctx: &mut C,
    arg0: i32,
) -> SideEffectNoResult {
    let v1 = &C::x64_jp_d32_raw(ctx, arg0);
    let v2 = &constructor_defer_side_effect(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 2528.
    return v2.clone();
}

// Generated as internal constructor for term x64_js_d8.
pub fn constructor_x64_js_d8<C: Context>(
    ctx: &mut C,
    arg0: i8,
) -> SideEffectNoResult {
    let v1 = &C::x64_js_d8_raw(ctx, arg0);
    let v2 = &constructor_defer_side_effect(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 2533.
    return v2.clone();
}

// Generated as internal constructor for term x64_js_d32.
pub fn constructor_x64_js_d32<C: Context>(
    ctx: &mut C,
    arg0: i32,
) -> SideEffectNoResult {
    let v1 = &C::x64_js_d32_raw(ctx, arg0);
    let v2 = &constructor_defer_side_effect(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 2538.
    return v2.clone();
}

// Generated as internal constructor for term x64_extractps_a.
pub fn constructor_x64_extractps_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: u8,
) -> Gpr {
    let v2 = C::temp_writable_gpr(ctx);
    let v3 = &constructor_writable_gpr_to_gpr_mem(ctx, v2);
    let v4 = &C::x64_extractps_a_raw(ctx, v3, arg0, arg1);
    let v5 = constructor_emit_ret_gpr(ctx, v4);
    // Rule at <OUT_DIR>/assembler.isle line 2543.
    return v5;
}

// Generated as internal constructor for term x64_extractps_a_or_avx.
pub fn constructor_x64_extractps_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: u8,
) -> Gpr {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vextractps_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 2545.
        return v3;
    }
    let v4 = constructor_x64_extractps_a(ctx, arg0, arg1);
    // Rule at <OUT_DIR>/assembler.isle line 2548.
    return v4;
}

// Generated as internal constructor for term x64_extractps_a_mem.
pub fn constructor_x64_extractps_a_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Xmm,
    arg2: u8,
) -> SideEffectNoResult {
    let v3 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v4 = &C::x64_extractps_a_raw(ctx, v3, arg1, arg2);
    let v5 = &constructor_defer_side_effect(ctx, v4);
    // Rule at <OUT_DIR>/assembler.isle line 2550.
    return v5.clone();
}

// Generated as internal constructor for term x64_extractps_a_mem_or_avx.
pub fn constructor_x64_extractps_a_mem_or_avx<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Xmm,
    arg2: u8,
) -> SideEffectNoResult {
    let v3 = C::has_avx(ctx);
    if v3 == true {
        let v4 = &constructor_x64_vextractps_b_mem(ctx, arg0, arg1, arg2);
        // Rule at <OUT_DIR>/assembler.isle line 2552.
        return v4.clone();
    }
    let v5 = &constructor_x64_extractps_a_mem(ctx, arg0, arg1, arg2);
    // Rule at <OUT_DIR>/assembler.isle line 2555.
    return v5.clone();
}

// Generated as internal constructor for term x64_pextrb_a.
pub fn constructor_x64_pextrb_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: u8,
) -> Gpr {
    let v2 = C::temp_writable_gpr(ctx);
    let v3 = &constructor_writable_gpr_to_gpr_mem(ctx, v2);
    let v4 = &C::x64_pextrb_a_raw(ctx, v3, arg0, arg1);
    let v5 = constructor_emit_ret_gpr(ctx, v4);
    // Rule at <OUT_DIR>/assembler.isle line 2560.
    return v5;
}

// Generated as internal constructor for term x64_pextrb_a_or_avx.
pub fn constructor_x64_pextrb_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: u8,
) -> Gpr {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vpextrb_a(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 2562.
        return v3;
    }
    let v4 = constructor_x64_pextrb_a(ctx, arg0, arg1);
    // Rule at <OUT_DIR>/assembler.isle line 2565.
    return v4;
}

// Generated as internal constructor for term x64_pextrb_a_mem.
pub fn constructor_x64_pextrb_a_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Xmm,
    arg2: u8,
) -> SideEffectNoResult {
    let v3 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v4 = &C::x64_pextrb_a_raw(ctx, v3, arg1, arg2);
    let v5 = &constructor_defer_side_effect(ctx, v4);
    // Rule at <OUT_DIR>/assembler.isle line 2567.
    return v5.clone();
}

// Generated as internal constructor for term x64_pextrb_a_mem_or_avx.
pub fn constructor_x64_pextrb_a_mem_or_avx<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Xmm,
    arg2: u8,
) -> SideEffectNoResult {
    let v3 = C::has_avx(ctx);
    if v3 == true {
        let v4 = &constructor_x64_vpextrb_a_mem(ctx, arg0, arg1, arg2);
        // Rule at <OUT_DIR>/assembler.isle line 2569.
        return v4.clone();
    }
    let v5 = &constructor_x64_pextrb_a_mem(ctx, arg0, arg1, arg2);
    // Rule at <OUT_DIR>/assembler.isle line 2572.
    return v5.clone();
}

// Generated as internal constructor for term x64_pextrw_a.
pub fn constructor_x64_pextrw_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: u8,
) -> Gpr {
    let v2 = &C::x64_pextrw_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 2577.
    return v3;
}

// Generated as internal constructor for term x64_pextrw_a_or_avx.
pub fn constructor_x64_pextrw_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: u8,
) -> Gpr {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vpextrw_a(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 2579.
        return v3;
    }
    let v4 = constructor_x64_pextrw_a(ctx, arg0, arg1);
    // Rule at <OUT_DIR>/assembler.isle line 2582.
    return v4;
}

// Generated as internal constructor for term x64_pextrw_b.
pub fn constructor_x64_pextrw_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: u8,
) -> Gpr {
    let v2 = C::temp_writable_gpr(ctx);
    let v3 = &constructor_writable_gpr_to_gpr_mem(ctx, v2);
    let v4 = &C::x64_pextrw_b_raw(ctx, v3, arg0, arg1);
    let v5 = constructor_emit_ret_gpr(ctx, v4);
    // Rule at <OUT_DIR>/assembler.isle line 2587.
    return v5;
}

// Generated as internal constructor for term x64_pextrw_b_or_avx.
pub fn constructor_x64_pextrw_b_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: u8,
) -> Gpr {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vpextrw_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 2589.
        return v3;
    }
    let v4 = constructor_x64_pextrw_b(ctx, arg0, arg1);
    // Rule at <OUT_DIR>/assembler.isle line 2592.
    return v4;
}

// Generated as internal constructor for term x64_pextrw_b_mem.
pub fn constructor_x64_pextrw_b_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Xmm,
    arg2: u8,
) -> SideEffectNoResult {
    let v3 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v4 = &C::x64_pextrw_b_raw(ctx, v3, arg1, arg2);
    let v5 = &constructor_defer_side_effect(ctx, v4);
    // Rule at <OUT_DIR>/assembler.isle line 2594.
    return v5.clone();
}

// Generated as internal constructor for term x64_pextrw_b_mem_or_avx.
pub fn constructor_x64_pextrw_b_mem_or_avx<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Xmm,
    arg2: u8,
) -> SideEffectNoResult {
    let v3 = C::has_avx(ctx);
    if v3 == true {
        let v4 = &constructor_x64_vpextrw_b_mem(ctx, arg0, arg1, arg2);
        // Rule at <OUT_DIR>/assembler.isle line 2596.
        return v4.clone();
    }
    let v5 = &constructor_x64_pextrw_b_mem(ctx, arg0, arg1, arg2);
    // Rule at <OUT_DIR>/assembler.isle line 2599.
    return v5.clone();
}

// Generated as internal constructor for term x64_pextrd_a.
pub fn constructor_x64_pextrd_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: u8,
) -> Gpr {
    let v2 = C::temp_writable_gpr(ctx);
    let v3 = &constructor_writable_gpr_to_gpr_mem(ctx, v2);
    let v4 = &C::x64_pextrd_a_raw(ctx, v3, arg0, arg1);
    let v5 = constructor_emit_ret_gpr(ctx, v4);
    // Rule at <OUT_DIR>/assembler.isle line 2604.
    return v5;
}

// Generated as internal constructor for term x64_pextrd_a_or_avx.
pub fn constructor_x64_pextrd_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: u8,
) -> Gpr {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vpextrd_a(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 2606.
        return v3;
    }
    let v4 = constructor_x64_pextrd_a(ctx, arg0, arg1);
    // Rule at <OUT_DIR>/assembler.isle line 2609.
    return v4;
}

// Generated as internal constructor for term x64_pextrd_a_mem.
pub fn constructor_x64_pextrd_a_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Xmm,
    arg2: u8,
) -> SideEffectNoResult {
    let v3 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v4 = &C::x64_pextrd_a_raw(ctx, v3, arg1, arg2);
    let v5 = &constructor_defer_side_effect(ctx, v4);
    // Rule at <OUT_DIR>/assembler.isle line 2611.
    return v5.clone();
}

// Generated as internal constructor for term x64_pextrd_a_mem_or_avx.
pub fn constructor_x64_pextrd_a_mem_or_avx<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Xmm,
    arg2: u8,
) -> SideEffectNoResult {
    let v3 = C::has_avx(ctx);
    if v3 == true {
        let v4 = &constructor_x64_vpextrd_a_mem(ctx, arg0, arg1, arg2);
        // Rule at <OUT_DIR>/assembler.isle line 2613.
        return v4.clone();
    }
    let v5 = &constructor_x64_pextrd_a_mem(ctx, arg0, arg1, arg2);
    // Rule at <OUT_DIR>/assembler.isle line 2616.
    return v5.clone();
}

// Generated as internal constructor for term x64_pextrq_a.
pub fn constructor_x64_pextrq_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: u8,
) -> Gpr {
    let v2 = C::temp_writable_gpr(ctx);
    let v3 = &constructor_writable_gpr_to_gpr_mem(ctx, v2);
    let v4 = &C::x64_pextrq_a_raw(ctx, v3, arg0, arg1);
    let v5 = constructor_emit_ret_gpr(ctx, v4);
    // Rule at <OUT_DIR>/assembler.isle line 2621.
    return v5;
}

// Generated as internal constructor for term x64_pextrq_a_or_avx.
pub fn constructor_x64_pextrq_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: u8,
) -> Gpr {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vpextrq_a(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 2623.
        return v3;
    }
    let v4 = constructor_x64_pextrq_a(ctx, arg0, arg1);
    // Rule at <OUT_DIR>/assembler.isle line 2626.
    return v4;
}

// Generated as internal constructor for term x64_pextrq_a_mem.
pub fn constructor_x64_pextrq_a_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Xmm,
    arg2: u8,
) -> SideEffectNoResult {
    let v3 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v4 = &C::x64_pextrq_a_raw(ctx, v3, arg1, arg2);
    let v5 = &constructor_defer_side_effect(ctx, v4);
    // Rule at <OUT_DIR>/assembler.isle line 2628.
    return v5.clone();
}

// Generated as internal constructor for term x64_pextrq_a_mem_or_avx.
pub fn constructor_x64_pextrq_a_mem_or_avx<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Xmm,
    arg2: u8,
) -> SideEffectNoResult {
    let v3 = C::has_avx(ctx);
    if v3 == true {
        let v4 = &constructor_x64_vpextrq_a_mem(ctx, arg0, arg1, arg2);
        // Rule at <OUT_DIR>/assembler.isle line 2630.
        return v4.clone();
    }
    let v5 = &constructor_x64_pextrq_a_mem(ctx, arg0, arg1, arg2);
    // Rule at <OUT_DIR>/assembler.isle line 2633.
    return v5.clone();
}

// Generated as internal constructor for term x64_vextractps_b.
pub fn constructor_x64_vextractps_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: u8,
) -> Gpr {
    let v2 = C::temp_writable_gpr(ctx);
    let v3 = &constructor_writable_gpr_to_gpr_mem(ctx, v2);
    let v4 = &C::x64_vextractps_b_raw(ctx, v3, arg0, arg1);
    let v5 = constructor_emit_ret_gpr(ctx, v4);
    // Rule at <OUT_DIR>/assembler.isle line 2638.
    return v5;
}

// Generated as internal constructor for term x64_vextractps_b_mem.
pub fn constructor_x64_vextractps_b_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Xmm,
    arg2: u8,
) -> SideEffectNoResult {
    let v3 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v4 = &C::x64_vextractps_b_raw(ctx, v3, arg1, arg2);
    let v5 = &constructor_defer_side_effect(ctx, v4);
    // Rule at <OUT_DIR>/assembler.isle line 2640.
    return v5.clone();
}

// Generated as internal constructor for term x64_vpextrb_a.
pub fn constructor_x64_vpextrb_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: u8,
) -> Gpr {
    let v2 = C::temp_writable_gpr(ctx);
    let v3 = &constructor_writable_gpr_to_gpr_mem(ctx, v2);
    let v4 = &C::x64_vpextrb_a_raw(ctx, v3, arg0, arg1);
    let v5 = constructor_emit_ret_gpr(ctx, v4);
    // Rule at <OUT_DIR>/assembler.isle line 2645.
    return v5;
}

// Generated as internal constructor for term x64_vpextrb_a_mem.
pub fn constructor_x64_vpextrb_a_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Xmm,
    arg2: u8,
) -> SideEffectNoResult {
    let v3 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v4 = &C::x64_vpextrb_a_raw(ctx, v3, arg1, arg2);
    let v5 = &constructor_defer_side_effect(ctx, v4);
    // Rule at <OUT_DIR>/assembler.isle line 2647.
    return v5.clone();
}

// Generated as internal constructor for term x64_vpextrw_a.
pub fn constructor_x64_vpextrw_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: u8,
) -> Gpr {
    let v2 = &C::x64_vpextrw_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 2652.
    return v3;
}

// Generated as internal constructor for term x64_vpextrw_b.
pub fn constructor_x64_vpextrw_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: u8,
) -> Gpr {
    let v2 = C::temp_writable_gpr(ctx);
    let v3 = &constructor_writable_gpr_to_gpr_mem(ctx, v2);
    let v4 = &C::x64_vpextrw_b_raw(ctx, v3, arg0, arg1);
    let v5 = constructor_emit_ret_gpr(ctx, v4);
    // Rule at <OUT_DIR>/assembler.isle line 2657.
    return v5;
}

// Generated as internal constructor for term x64_vpextrw_b_mem.
pub fn constructor_x64_vpextrw_b_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Xmm,
    arg2: u8,
) -> SideEffectNoResult {
    let v3 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v4 = &C::x64_vpextrw_b_raw(ctx, v3, arg1, arg2);
    let v5 = &constructor_defer_side_effect(ctx, v4);
    // Rule at <OUT_DIR>/assembler.isle line 2659.
    return v5.clone();
}

// Generated as internal constructor for term x64_vpextrd_a.
pub fn constructor_x64_vpextrd_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: u8,
) -> Gpr {
    let v2 = C::temp_writable_gpr(ctx);
    let v3 = &constructor_writable_gpr_to_gpr_mem(ctx, v2);
    let v4 = &C::x64_vpextrd_a_raw(ctx, v3, arg0, arg1);
    let v5 = constructor_emit_ret_gpr(ctx, v4);
    // Rule at <OUT_DIR>/assembler.isle line 2664.
    return v5;
}

// Generated as internal constructor for term x64_vpextrd_a_mem.
pub fn constructor_x64_vpextrd_a_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Xmm,
    arg2: u8,
) -> SideEffectNoResult {
    let v3 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v4 = &C::x64_vpextrd_a_raw(ctx, v3, arg1, arg2);
    let v5 = &constructor_defer_side_effect(ctx, v4);
    // Rule at <OUT_DIR>/assembler.isle line 2666.
    return v5.clone();
}

// Generated as internal constructor for term x64_vpextrq_a.
pub fn constructor_x64_vpextrq_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: u8,
) -> Gpr {
    let v2 = C::temp_writable_gpr(ctx);
    let v3 = &constructor_writable_gpr_to_gpr_mem(ctx, v2);
    let v4 = &C::x64_vpextrq_a_raw(ctx, v3, arg0, arg1);
    let v5 = constructor_emit_ret_gpr(ctx, v4);
    // Rule at <OUT_DIR>/assembler.isle line 2671.
    return v5;
}

// Generated as internal constructor for term x64_vpextrq_a_mem.
pub fn constructor_x64_vpextrq_a_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Xmm,
    arg2: u8,
) -> SideEffectNoResult {
    let v3 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v4 = &C::x64_vpextrq_a_raw(ctx, v3, arg1, arg2);
    let v5 = &constructor_defer_side_effect(ctx, v4);
    // Rule at <OUT_DIR>/assembler.isle line 2673.
    return v5.clone();
}

// Generated as internal constructor for term x64_insertps_a.
pub fn constructor_x64_insertps_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
    arg2: u8,
) -> Xmm {
    let v3 = &C::x64_insertps_a_raw(ctx, arg0, arg1, arg2);
    let v4 = constructor_emit_ret_xmm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 2678.
    return v4;
}

// Generated as internal constructor for term x64_insertps_a_or_avx.
pub fn constructor_x64_insertps_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
    arg2: u8,
) -> Xmm {
    let v3 = C::has_avx(ctx);
    if v3 == true {
        let v4 = constructor_x64_vinsertps_b(ctx, arg0, arg1, arg2);
        // Rule at <OUT_DIR>/assembler.isle line 2680.
        return v4;
    }
    let v5 = constructor_x64_insertps_a(ctx, arg0, arg1, arg2);
    // Rule at <OUT_DIR>/assembler.isle line 2683.
    return v5;
}

// Generated as internal constructor for term x64_pinsrb_a.
pub fn constructor_x64_pinsrb_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &GprMem,
    arg2: u8,
) -> Xmm {
    let v3 = &C::x64_pinsrb_a_raw(ctx, arg0, arg1, arg2);
    let v4 = constructor_emit_ret_xmm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 2688.
    return v4;
}

// Generated as internal constructor for term x64_pinsrw_a.
pub fn constructor_x64_pinsrw_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &GprMem,
    arg2: u8,
) -> Xmm {
    let v3 = &C::x64_pinsrw_a_raw(ctx, arg0, arg1, arg2);
    let v4 = constructor_emit_ret_xmm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 2693.
    return v4;
}

// Generated as internal constructor for term x64_pinsrd_a.
pub fn constructor_x64_pinsrd_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &GprMem,
    arg2: u8,
) -> Xmm {
    let v3 = &C::x64_pinsrd_a_raw(ctx, arg0, arg1, arg2);
    let v4 = constructor_emit_ret_xmm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 2698.
    return v4;
}

// Generated as internal constructor for term x64_pinsrq_a.
pub fn constructor_x64_pinsrq_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &GprMem,
    arg2: u8,
) -> Xmm {
    let v3 = &C::x64_pinsrq_a_raw(ctx, arg0, arg1, arg2);
    let v4 = constructor_emit_ret_xmm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 2703.
    return v4;
}

// Generated as internal constructor for term x64_vinsertps_b.
pub fn constructor_x64_vinsertps_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
    arg2: u8,
) -> Xmm {
    let v3 = &C::x64_vinsertps_b_raw(ctx, arg0, arg1, arg2);
    let v4 = constructor_emit_ret_xmm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 2708.
    return v4;
}

// Generated as internal constructor for term x64_vpinsrb_b.
pub fn constructor_x64_vpinsrb_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &GprMem,
    arg2: u8,
) -> Xmm {
    let v3 = &C::x64_vpinsrb_b_raw(ctx, arg0, arg1, arg2);
    let v4 = constructor_emit_ret_xmm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 2713.
    return v4;
}

// Generated as internal constructor for term x64_vpinsrw_b.
pub fn constructor_x64_vpinsrw_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &GprMem,
    arg2: u8,
) -> Xmm {
    let v3 = &C::x64_vpinsrw_b_raw(ctx, arg0, arg1, arg2);
    let v4 = constructor_emit_ret_xmm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 2718.
    return v4;
}

// Generated as internal constructor for term x64_vpinsrd_b.
pub fn constructor_x64_vpinsrd_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &GprMem,
    arg2: u8,
) -> Xmm {
    let v3 = &C::x64_vpinsrd_b_raw(ctx, arg0, arg1, arg2);
    let v4 = constructor_emit_ret_xmm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 2723.
    return v4;
}

// Generated as internal constructor for term x64_vpinsrq_b.
pub fn constructor_x64_vpinsrq_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &GprMem,
    arg2: u8,
) -> Xmm {
    let v3 = &C::x64_vpinsrq_b_raw(ctx, arg0, arg1, arg2);
    let v4 = constructor_emit_ret_xmm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 2728.
    return v4;
}

// Generated as internal constructor for term x64_movmskps_rm.
pub fn constructor_x64_movmskps_rm<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
) -> Gpr {
    let v1 = &C::x64_movmskps_rm_raw(ctx, arg0);
    let v2 = constructor_emit_ret_gpr(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 2733.
    return v2;
}

// Generated as internal constructor for term x64_movmskps_rm_or_avx.
pub fn constructor_x64_movmskps_rm_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
) -> Gpr {
    let v1 = C::has_avx(ctx);
    if v1 == true {
        let v2 = constructor_x64_vmovmskps_rm(ctx, arg0);
        // Rule at <OUT_DIR>/assembler.isle line 2735.
        return v2;
    }
    let v3 = constructor_x64_movmskps_rm(ctx, arg0);
    // Rule at <OUT_DIR>/assembler.isle line 2738.
    return v3;
}

// Generated as internal constructor for term x64_movmskpd_rm.
pub fn constructor_x64_movmskpd_rm<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
) -> Gpr {
    let v1 = &C::x64_movmskpd_rm_raw(ctx, arg0);
    let v2 = constructor_emit_ret_gpr(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 2743.
    return v2;
}

// Generated as internal constructor for term x64_movmskpd_rm_or_avx.
pub fn constructor_x64_movmskpd_rm_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
) -> Gpr {
    let v1 = C::has_avx(ctx);
    if v1 == true {
        let v2 = constructor_x64_vmovmskpd_rm(ctx, arg0);
        // Rule at <OUT_DIR>/assembler.isle line 2745.
        return v2;
    }
    let v3 = constructor_x64_movmskpd_rm(ctx, arg0);
    // Rule at <OUT_DIR>/assembler.isle line 2748.
    return v3;
}

// Generated as internal constructor for term x64_pmovmskb_rm.
pub fn constructor_x64_pmovmskb_rm<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
) -> Gpr {
    let v1 = &C::x64_pmovmskb_rm_raw(ctx, arg0);
    let v2 = constructor_emit_ret_gpr(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 2753.
    return v2;
}

// Generated as internal constructor for term x64_pmovmskb_rm_or_avx.
pub fn constructor_x64_pmovmskb_rm_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
) -> Gpr {
    let v1 = C::has_avx(ctx);
    if v1 == true {
        let v2 = constructor_x64_vpmovmskb_rm(ctx, arg0);
        // Rule at <OUT_DIR>/assembler.isle line 2755.
        return v2;
    }
    let v3 = constructor_x64_pmovmskb_rm(ctx, arg0);
    // Rule at <OUT_DIR>/assembler.isle line 2758.
    return v3;
}

// Generated as internal constructor for term x64_vmovmskps_rm.
pub fn constructor_x64_vmovmskps_rm<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
) -> Gpr {
    let v1 = &C::x64_vmovmskps_rm_raw(ctx, arg0);
    let v2 = constructor_emit_ret_gpr(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 2763.
    return v2;
}

// Generated as internal constructor for term x64_vmovmskpd_rm.
pub fn constructor_x64_vmovmskpd_rm<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
) -> Gpr {
    let v1 = &C::x64_vmovmskpd_rm_raw(ctx, arg0);
    let v2 = constructor_emit_ret_gpr(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 2768.
    return v2;
}

// Generated as internal constructor for term x64_vpmovmskb_rm.
pub fn constructor_x64_vpmovmskb_rm<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
) -> Gpr {
    let v1 = &C::x64_vpmovmskb_rm_raw(ctx, arg0);
    let v2 = constructor_emit_ret_gpr(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 2773.
    return v2;
}

// Generated as internal constructor for term x64_movhps_a.
pub fn constructor_x64_movhps_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &SyntheticAmode,
) -> Xmm {
    let v2 = &C::x64_movhps_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 2778.
    return v3;
}

// Generated as internal constructor for term x64_movhps_a_or_avx.
pub fn constructor_x64_movhps_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &SyntheticAmode,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vmovhps_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 2780.
        return v3;
    }
    let v4 = constructor_x64_movhps_a(ctx, arg0, arg1);
    // Rule at <OUT_DIR>/assembler.isle line 2783.
    return v4;
}

// Generated as internal constructor for term x64_movlhps_rm.
pub fn constructor_x64_movlhps_rm<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: Xmm,
) -> Xmm {
    let v2 = &C::x64_movlhps_rm_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 2788.
    return v3;
}

// Generated as internal constructor for term x64_movlhps_rm_or_avx.
pub fn constructor_x64_movlhps_rm_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: Xmm,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vmovlhps_rvm(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 2790.
        return v3;
    }
    let v4 = constructor_x64_movlhps_rm(ctx, arg0, arg1);
    // Rule at <OUT_DIR>/assembler.isle line 2793.
    return v4;
}

// Generated as internal constructor for term x64_vmovhps_b.
pub fn constructor_x64_vmovhps_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &SyntheticAmode,
) -> Xmm {
    let v2 = &C::x64_vmovhps_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 2798.
    return v3;
}

// Generated as internal constructor for term x64_vmovlhps_rvm.
pub fn constructor_x64_vmovlhps_rvm<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: Xmm,
) -> Xmm {
    let v2 = &C::x64_vmovlhps_rvm_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 2803.
    return v3;
}

// Generated as internal constructor for term x64_movddup_a.
pub fn constructor_x64_movddup_a<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = &C::x64_movddup_a_raw(ctx, arg0);
    let v2 = constructor_emit_ret_xmm(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 2808.
    return v2;
}

// Generated as internal constructor for term x64_movddup_a_or_avx.
pub fn constructor_x64_movddup_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = C::has_avx(ctx);
    if v1 == true {
        let v2 = constructor_x64_vmovddup_a(ctx, arg0);
        // Rule at <OUT_DIR>/assembler.isle line 2810.
        return v2;
    }
    let v3 = constructor_x64_movddup_a(ctx, arg0);
    // Rule at <OUT_DIR>/assembler.isle line 2813.
    return v3;
}

// Generated as internal constructor for term x64_vmovddup_a.
pub fn constructor_x64_vmovddup_a<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = &C::x64_vmovddup_a_raw(ctx, arg0);
    let v2 = constructor_emit_ret_xmm(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 2818.
    return v2;
}

// Generated as internal constructor for term x64_pblendw_rmi.
pub fn constructor_x64_pblendw_rmi<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
    arg2: u8,
) -> Xmm {
    let v3 = &C::x64_pblendw_rmi_raw(ctx, arg0, arg1, arg2);
    let v4 = constructor_emit_ret_xmm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 2823.
    return v4;
}

// Generated as internal constructor for term x64_pblendw_rmi_or_avx.
pub fn constructor_x64_pblendw_rmi_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
    arg2: u8,
) -> Xmm {
    let v3 = C::has_avx(ctx);
    if v3 == true {
        let v4 = constructor_x64_vpblendw_rvmi(ctx, arg0, arg1, arg2);
        // Rule at <OUT_DIR>/assembler.isle line 2825.
        return v4;
    }
    let v5 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v6 = constructor_x64_pblendw_rmi(ctx, arg0, v5, arg2);
    // Rule at <OUT_DIR>/assembler.isle line 2828.
    return v6;
}

// Generated as internal constructor for term x64_pblendvb_rm.
pub fn constructor_x64_pblendvb_rm<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
    arg2: Xmm,
) -> Xmm {
    let v3 = &C::x64_pblendvb_rm_raw(ctx, arg0, arg1, arg2);
    let v4 = constructor_emit_ret_xmm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 2833.
    return v4;
}

// Generated as internal constructor for term x64_blendvps_rm0.
pub fn constructor_x64_blendvps_rm0<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
    arg2: Xmm,
) -> Xmm {
    let v3 = &C::x64_blendvps_rm0_raw(ctx, arg0, arg1, arg2);
    let v4 = constructor_emit_ret_xmm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 2838.
    return v4;
}

// Generated as internal constructor for term x64_blendvpd_rm0.
pub fn constructor_x64_blendvpd_rm0<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
    arg2: Xmm,
) -> Xmm {
    let v3 = &C::x64_blendvpd_rm0_raw(ctx, arg0, arg1, arg2);
    let v4 = constructor_emit_ret_xmm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 2843.
    return v4;
}

// Generated as internal constructor for term x64_vpblendw_rvmi.
pub fn constructor_x64_vpblendw_rvmi<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
    arg2: u8,
) -> Xmm {
    let v3 = &C::x64_vpblendw_rvmi_raw(ctx, arg0, arg1, arg2);
    let v4 = constructor_emit_ret_xmm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 2848.
    return v4;
}

// Generated as internal constructor for term x64_vpblendvb_rvmr.
pub fn constructor_x64_vpblendvb_rvmr<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
    arg2: Xmm,
) -> Xmm {
    let v3 = &C::x64_vpblendvb_rvmr_raw(ctx, arg0, arg1, arg2);
    let v4 = constructor_emit_ret_xmm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 2853.
    return v4;
}

// Generated as internal constructor for term x64_vblendvps_rvmr.
pub fn constructor_x64_vblendvps_rvmr<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
    arg2: Xmm,
) -> Xmm {
    let v3 = &C::x64_vblendvps_rvmr_raw(ctx, arg0, arg1, arg2);
    let v4 = constructor_emit_ret_xmm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 2858.
    return v4;
}

// Generated as internal constructor for term x64_vblendvpd_rvmr.
pub fn constructor_x64_vblendvpd_rvmr<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
    arg2: Xmm,
) -> Xmm {
    let v3 = &C::x64_vblendvpd_rvmr_raw(ctx, arg0, arg1, arg2);
    let v4 = constructor_emit_ret_xmm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 2863.
    return v4;
}

// Generated as internal constructor for term x64_shufpd_a.
pub fn constructor_x64_shufpd_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
    arg2: u8,
) -> Xmm {
    let v3 = &C::x64_shufpd_a_raw(ctx, arg0, arg1, arg2);
    let v4 = constructor_emit_ret_xmm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 2868.
    return v4;
}

// Generated as internal constructor for term x64_shufpd_a_or_avx.
pub fn constructor_x64_shufpd_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
    arg2: u8,
) -> Xmm {
    let v3 = C::has_avx(ctx);
    if v3 == true {
        let v4 = constructor_x64_vshufpd_b(ctx, arg0, arg1, arg2);
        // Rule at <OUT_DIR>/assembler.isle line 2870.
        return v4;
    }
    let v5 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v6 = constructor_x64_shufpd_a(ctx, arg0, v5, arg2);
    // Rule at <OUT_DIR>/assembler.isle line 2873.
    return v6;
}

// Generated as internal constructor for term x64_vshufpd_b.
pub fn constructor_x64_vshufpd_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
    arg2: u8,
) -> Xmm {
    let v3 = &C::x64_vshufpd_b_raw(ctx, arg0, arg1, arg2);
    let v4 = constructor_emit_ret_xmm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 2878.
    return v4;
}

// Generated as internal constructor for term x64_shufps_a.
pub fn constructor_x64_shufps_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
    arg2: u8,
) -> Xmm {
    let v3 = &C::x64_shufps_a_raw(ctx, arg0, arg1, arg2);
    let v4 = constructor_emit_ret_xmm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 2883.
    return v4;
}

// Generated as internal constructor for term x64_shufps_a_or_avx.
pub fn constructor_x64_shufps_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
    arg2: u8,
) -> Xmm {
    let v3 = C::has_avx(ctx);
    if v3 == true {
        let v4 = constructor_x64_vshufps_b(ctx, arg0, arg1, arg2);
        // Rule at <OUT_DIR>/assembler.isle line 2885.
        return v4;
    }
    let v5 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v6 = constructor_x64_shufps_a(ctx, arg0, v5, arg2);
    // Rule at <OUT_DIR>/assembler.isle line 2888.
    return v6;
}

// Generated as internal constructor for term x64_vshufps_b.
pub fn constructor_x64_vshufps_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
    arg2: u8,
) -> Xmm {
    let v3 = &C::x64_vshufps_b_raw(ctx, arg0, arg1, arg2);
    let v4 = constructor_emit_ret_xmm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 2893.
    return v4;
}

// Generated as internal constructor for term x64_pshufb_a.
pub fn constructor_x64_pshufb_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_pshufb_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 2898.
    return v3;
}

// Generated as internal constructor for term x64_pshufb_a_or_avx.
pub fn constructor_x64_pshufb_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vpshufb_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 2900.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_pshufb_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 2903.
    return v5;
}

// Generated as internal constructor for term x64_pshufd_a.
pub fn constructor_x64_pshufd_a<C: Context>(
    ctx: &mut C,
    arg0: &XmmMemAligned,
    arg1: u8,
) -> Xmm {
    let v2 = &C::x64_pshufd_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 2908.
    return v3;
}

// Generated as internal constructor for term x64_pshufd_a_or_avx.
pub fn constructor_x64_pshufd_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
    arg1: u8,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vpshufd_a(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 2910.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg0);
    let v5 = constructor_x64_pshufd_a(ctx, v4, arg1);
    // Rule at <OUT_DIR>/assembler.isle line 2913.
    return v5;
}

// Generated as internal constructor for term x64_pshuflw_a.
pub fn constructor_x64_pshuflw_a<C: Context>(
    ctx: &mut C,
    arg0: &XmmMemAligned,
    arg1: u8,
) -> Xmm {
    let v2 = &C::x64_pshuflw_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 2918.
    return v3;
}

// Generated as internal constructor for term x64_pshuflw_a_or_avx.
pub fn constructor_x64_pshuflw_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
    arg1: u8,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vpshuflw_a(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 2920.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg0);
    let v5 = constructor_x64_pshuflw_a(ctx, v4, arg1);
    // Rule at <OUT_DIR>/assembler.isle line 2923.
    return v5;
}

// Generated as internal constructor for term x64_pshufhw_a.
pub fn constructor_x64_pshufhw_a<C: Context>(
    ctx: &mut C,
    arg0: &XmmMemAligned,
    arg1: u8,
) -> Xmm {
    let v2 = &C::x64_pshufhw_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 2928.
    return v3;
}

// Generated as internal constructor for term x64_pshufhw_a_or_avx.
pub fn constructor_x64_pshufhw_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
    arg1: u8,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vpshufhw_a(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 2930.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg0);
    let v5 = constructor_x64_pshufhw_a(ctx, v4, arg1);
    // Rule at <OUT_DIR>/assembler.isle line 2933.
    return v5;
}

// Generated as internal constructor for term x64_vpshufb_b.
pub fn constructor_x64_vpshufb_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vpshufb_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 2938.
    return v3;
}

// Generated as internal constructor for term x64_vpshufd_a.
pub fn constructor_x64_vpshufd_a<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
    arg1: u8,
) -> Xmm {
    let v2 = &C::x64_vpshufd_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 2943.
    return v3;
}

// Generated as internal constructor for term x64_vpshuflw_a.
pub fn constructor_x64_vpshuflw_a<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
    arg1: u8,
) -> Xmm {
    let v2 = &C::x64_vpshuflw_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 2948.
    return v3;
}

// Generated as internal constructor for term x64_vpshufhw_a.
pub fn constructor_x64_vpshufhw_a<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
    arg1: u8,
) -> Xmm {
    let v2 = &C::x64_vpshufhw_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 2953.
    return v3;
}

// Generated as internal constructor for term x64_vbroadcastss_a_m.
pub fn constructor_x64_vbroadcastss_a_m<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
) -> Xmm {
    let v1 = &C::x64_vbroadcastss_a_m_raw(ctx, arg0);
    let v2 = constructor_emit_ret_xmm(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 2958.
    return v2;
}

// Generated as internal constructor for term x64_vbroadcastss_a_r.
pub fn constructor_x64_vbroadcastss_a_r<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
) -> Xmm {
    let v1 = &C::x64_vbroadcastss_a_r_raw(ctx, arg0);
    let v2 = constructor_emit_ret_xmm(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 2963.
    return v2;
}

// Generated as internal constructor for term x64_vpbroadcastb_a.
pub fn constructor_x64_vpbroadcastb_a<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = &C::x64_vpbroadcastb_a_raw(ctx, arg0);
    let v2 = constructor_emit_ret_xmm(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 2968.
    return v2;
}

// Generated as internal constructor for term x64_vpbroadcastw_a.
pub fn constructor_x64_vpbroadcastw_a<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = &C::x64_vpbroadcastw_a_raw(ctx, arg0);
    let v2 = constructor_emit_ret_xmm(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 2973.
    return v2;
}

// Generated as internal constructor for term x64_vpbroadcastd_a.
pub fn constructor_x64_vpbroadcastd_a<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = &C::x64_vpbroadcastd_a_raw(ctx, arg0);
    let v2 = constructor_emit_ret_xmm(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 2978.
    return v2;
}

// Generated as internal constructor for term x64_vpbroadcastq_a.
pub fn constructor_x64_vpbroadcastq_a<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = &C::x64_vpbroadcastq_a_raw(ctx, arg0);
    let v2 = constructor_emit_ret_xmm(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 2983.
    return v2;
}

// Generated as internal constructor for term x64_vpermi2b_a.
pub fn constructor_x64_vpermi2b_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: Xmm,
    arg2: &XmmMem,
) -> Xmm {
    let v3 = &C::x64_vpermi2b_a_raw(ctx, arg0, arg1, arg2);
    let v4 = constructor_emit_ret_xmm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 2988.
    return v4;
}

// Generated as internal constructor for term x64_maxss_a.
pub fn constructor_x64_maxss_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_maxss_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 2993.
    return v3;
}

// Generated as internal constructor for term x64_maxss_a_or_avx.
pub fn constructor_x64_maxss_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vmaxss_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 2995.
        return v3;
    }
    let v4 = constructor_x64_maxss_a(ctx, arg0, arg1);
    // Rule at <OUT_DIR>/assembler.isle line 2998.
    return v4;
}

// Generated as internal constructor for term x64_maxsd_a.
pub fn constructor_x64_maxsd_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_maxsd_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 3003.
    return v3;
}

// Generated as internal constructor for term x64_maxsd_a_or_avx.
pub fn constructor_x64_maxsd_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vmaxsd_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 3005.
        return v3;
    }
    let v4 = constructor_x64_maxsd_a(ctx, arg0, arg1);
    // Rule at <OUT_DIR>/assembler.isle line 3008.
    return v4;
}

// Generated as internal constructor for term x64_maxps_a.
pub fn constructor_x64_maxps_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_maxps_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 3013.
    return v3;
}

// Generated as internal constructor for term x64_maxps_a_or_avx.
pub fn constructor_x64_maxps_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vmaxps_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 3015.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_maxps_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 3018.
    return v5;
}

// Generated as internal constructor for term x64_maxpd_a.
pub fn constructor_x64_maxpd_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_maxpd_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 3023.
    return v3;
}

// Generated as internal constructor for term x64_maxpd_a_or_avx.
pub fn constructor_x64_maxpd_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vmaxpd_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 3025.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_maxpd_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 3028.
    return v5;
}

// Generated as internal constructor for term x64_vmaxss_b.
pub fn constructor_x64_vmaxss_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vmaxss_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 3033.
    return v3;
}

// Generated as internal constructor for term x64_vmaxsd_b.
pub fn constructor_x64_vmaxsd_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vmaxsd_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 3038.
    return v3;
}

// Generated as internal constructor for term x64_vmaxps_b.
pub fn constructor_x64_vmaxps_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vmaxps_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 3043.
    return v3;
}

// Generated as internal constructor for term x64_vmaxpd_b.
pub fn constructor_x64_vmaxpd_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vmaxpd_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 3048.
    return v3;
}

// Generated as internal constructor for term x64_pmaxsb_a.
pub fn constructor_x64_pmaxsb_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_pmaxsb_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 3053.
    return v3;
}

// Generated as internal constructor for term x64_pmaxsb_a_or_avx.
pub fn constructor_x64_pmaxsb_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vpmaxsb_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 3055.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_pmaxsb_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 3058.
    return v5;
}

// Generated as internal constructor for term x64_pmaxsw_a.
pub fn constructor_x64_pmaxsw_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_pmaxsw_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 3063.
    return v3;
}

// Generated as internal constructor for term x64_pmaxsw_a_or_avx.
pub fn constructor_x64_pmaxsw_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vpmaxsw_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 3065.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_pmaxsw_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 3068.
    return v5;
}

// Generated as internal constructor for term x64_pmaxsd_a.
pub fn constructor_x64_pmaxsd_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_pmaxsd_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 3073.
    return v3;
}

// Generated as internal constructor for term x64_pmaxsd_a_or_avx.
pub fn constructor_x64_pmaxsd_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vpmaxsd_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 3075.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_pmaxsd_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 3078.
    return v5;
}

// Generated as internal constructor for term x64_pmaxub_a.
pub fn constructor_x64_pmaxub_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_pmaxub_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 3083.
    return v3;
}

// Generated as internal constructor for term x64_pmaxub_a_or_avx.
pub fn constructor_x64_pmaxub_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vpmaxub_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 3085.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_pmaxub_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 3088.
    return v5;
}

// Generated as internal constructor for term x64_pmaxuw_a.
pub fn constructor_x64_pmaxuw_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_pmaxuw_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 3093.
    return v3;
}

// Generated as internal constructor for term x64_pmaxuw_a_or_avx.
pub fn constructor_x64_pmaxuw_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vpmaxuw_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 3095.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_pmaxuw_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 3098.
    return v5;
}

// Generated as internal constructor for term x64_pmaxud_a.
pub fn constructor_x64_pmaxud_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_pmaxud_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 3103.
    return v3;
}

// Generated as internal constructor for term x64_pmaxud_a_or_avx.
pub fn constructor_x64_pmaxud_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vpmaxud_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 3105.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_pmaxud_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 3108.
    return v5;
}

// Generated as internal constructor for term x64_vpmaxsb_b.
pub fn constructor_x64_vpmaxsb_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vpmaxsb_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 3113.
    return v3;
}

// Generated as internal constructor for term x64_vpmaxsw_b.
pub fn constructor_x64_vpmaxsw_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vpmaxsw_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 3118.
    return v3;
}

// Generated as internal constructor for term x64_vpmaxsd_b.
pub fn constructor_x64_vpmaxsd_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vpmaxsd_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 3123.
    return v3;
}

// Generated as internal constructor for term x64_vpmaxub_b.
pub fn constructor_x64_vpmaxub_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vpmaxub_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 3128.
    return v3;
}

// Generated as internal constructor for term x64_vpmaxuw_b.
pub fn constructor_x64_vpmaxuw_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vpmaxuw_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 3133.
    return v3;
}

// Generated as internal constructor for term x64_vpmaxud_b.
pub fn constructor_x64_vpmaxud_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vpmaxud_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 3138.
    return v3;
}

// Generated as internal constructor for term x64_minss_a.
pub fn constructor_x64_minss_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_minss_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 3143.
    return v3;
}

// Generated as internal constructor for term x64_minss_a_or_avx.
pub fn constructor_x64_minss_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vminss_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 3145.
        return v3;
    }
    let v4 = constructor_x64_minss_a(ctx, arg0, arg1);
    // Rule at <OUT_DIR>/assembler.isle line 3148.
    return v4;
}

// Generated as internal constructor for term x64_minsd_a.
pub fn constructor_x64_minsd_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_minsd_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 3153.
    return v3;
}

// Generated as internal constructor for term x64_minsd_a_or_avx.
pub fn constructor_x64_minsd_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vminsd_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 3155.
        return v3;
    }
    let v4 = constructor_x64_minsd_a(ctx, arg0, arg1);
    // Rule at <OUT_DIR>/assembler.isle line 3158.
    return v4;
}

// Generated as internal constructor for term x64_minps_a.
pub fn constructor_x64_minps_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_minps_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 3163.
    return v3;
}

// Generated as internal constructor for term x64_minps_a_or_avx.
pub fn constructor_x64_minps_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vminps_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 3165.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_minps_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 3168.
    return v5;
}

// Generated as internal constructor for term x64_minpd_a.
pub fn constructor_x64_minpd_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_minpd_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 3173.
    return v3;
}

// Generated as internal constructor for term x64_minpd_a_or_avx.
pub fn constructor_x64_minpd_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vminpd_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 3175.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_minpd_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 3178.
    return v5;
}

// Generated as internal constructor for term x64_vminss_b.
pub fn constructor_x64_vminss_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vminss_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 3183.
    return v3;
}

// Generated as internal constructor for term x64_vminsd_b.
pub fn constructor_x64_vminsd_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vminsd_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 3188.
    return v3;
}

// Generated as internal constructor for term x64_vminps_b.
pub fn constructor_x64_vminps_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vminps_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 3193.
    return v3;
}

// Generated as internal constructor for term x64_vminpd_b.
pub fn constructor_x64_vminpd_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vminpd_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 3198.
    return v3;
}

// Generated as internal constructor for term x64_pminsb_a.
pub fn constructor_x64_pminsb_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_pminsb_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 3203.
    return v3;
}

// Generated as internal constructor for term x64_pminsb_a_or_avx.
pub fn constructor_x64_pminsb_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vpminsb_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 3205.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_pminsb_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 3208.
    return v5;
}

// Generated as internal constructor for term x64_pminsw_a.
pub fn constructor_x64_pminsw_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_pminsw_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 3213.
    return v3;
}

// Generated as internal constructor for term x64_pminsw_a_or_avx.
pub fn constructor_x64_pminsw_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vpminsw_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 3215.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_pminsw_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 3218.
    return v5;
}

// Generated as internal constructor for term x64_pminsd_a.
pub fn constructor_x64_pminsd_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_pminsd_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 3223.
    return v3;
}

// Generated as internal constructor for term x64_pminsd_a_or_avx.
pub fn constructor_x64_pminsd_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vpminsd_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 3225.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_pminsd_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 3228.
    return v5;
}

// Generated as internal constructor for term x64_pminub_a.
pub fn constructor_x64_pminub_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_pminub_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 3233.
    return v3;
}

// Generated as internal constructor for term x64_pminub_a_or_avx.
pub fn constructor_x64_pminub_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vpminub_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 3235.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_pminub_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 3238.
    return v5;
}

// Generated as internal constructor for term x64_pminuw_a.
pub fn constructor_x64_pminuw_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_pminuw_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 3243.
    return v3;
}

// Generated as internal constructor for term x64_pminuw_a_or_avx.
pub fn constructor_x64_pminuw_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vpminuw_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 3245.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_pminuw_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 3248.
    return v5;
}

// Generated as internal constructor for term x64_pminud_a.
pub fn constructor_x64_pminud_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_pminud_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 3253.
    return v3;
}

// Generated as internal constructor for term x64_pminud_a_or_avx.
pub fn constructor_x64_pminud_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vpminud_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 3255.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_pminud_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 3258.
    return v5;
}

// Generated as internal constructor for term x64_vpminsb_b.
pub fn constructor_x64_vpminsb_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vpminsb_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 3263.
    return v3;
}

// Generated as internal constructor for term x64_vpminsw_b.
pub fn constructor_x64_vpminsw_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vpminsw_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 3268.
    return v3;
}

// Generated as internal constructor for term x64_vpminsd_b.
pub fn constructor_x64_vpminsd_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vpminsd_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 3273.
    return v3;
}

// Generated as internal constructor for term x64_vpminub_b.
pub fn constructor_x64_vpminub_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vpminub_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 3278.
    return v3;
}

// Generated as internal constructor for term x64_vpminuw_b.
pub fn constructor_x64_vpminuw_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vpminuw_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 3283.
    return v3;
}

// Generated as internal constructor for term x64_vpminud_b.
pub fn constructor_x64_vpminud_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vpminud_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 3288.
    return v3;
}

// Generated as internal constructor for term x64_mfence_zo.
pub fn constructor_x64_mfence_zo<C: Context>(
    ctx: &mut C,
) -> SideEffectNoResult {
    let v0 = &C::x64_mfence_zo_raw(ctx);
    let v1 = &constructor_defer_side_effect(ctx, v0);
    // Rule at <OUT_DIR>/assembler.isle line 3293.
    return v1.clone();
}

// Generated as internal constructor for term x64_sfence_zo.
pub fn constructor_x64_sfence_zo<C: Context>(
    ctx: &mut C,
) -> SideEffectNoResult {
    let v0 = &C::x64_sfence_zo_raw(ctx);
    let v1 = &constructor_defer_side_effect(ctx, v0);
    // Rule at <OUT_DIR>/assembler.isle line 3298.
    return v1.clone();
}

// Generated as internal constructor for term x64_lfence_zo.
pub fn constructor_x64_lfence_zo<C: Context>(
    ctx: &mut C,
) -> SideEffectNoResult {
    let v0 = &C::x64_lfence_zo_raw(ctx);
    let v1 = &constructor_defer_side_effect(ctx, v0);
    // Rule at <OUT_DIR>/assembler.isle line 3303.
    return v1.clone();
}

// Generated as internal constructor for term x64_hlt_zo.
pub fn constructor_x64_hlt_zo<C: Context>(
    ctx: &mut C,
) -> SideEffectNoResult {
    let v0 = &C::x64_hlt_zo_raw(ctx);
    let v1 = &constructor_defer_side_effect(ctx, v0);
    // Rule at <OUT_DIR>/assembler.isle line 3308.
    return v1.clone();
}

// Generated as internal constructor for term x64_ud2_zo.
pub fn constructor_x64_ud2_zo<C: Context>(
    ctx: &mut C,
    arg0: &TrapCode,
) -> SideEffectNoResult {
    let v1 = &C::x64_ud2_zo_raw(ctx, arg0);
    let v2 = &constructor_defer_side_effect(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 3313.
    return v2.clone();
}

// Generated as internal constructor for term x64_int3_zo.
pub fn constructor_x64_int3_zo<C: Context>(
    ctx: &mut C,
) -> SideEffectNoResult {
    let v0 = &C::x64_int3_zo_raw(ctx);
    let v1 = &constructor_defer_side_effect(ctx, v0);
    // Rule at <OUT_DIR>/assembler.isle line 3318.
    return v1.clone();
}

// Generated as internal constructor for term x64_retq_zo.
pub fn constructor_x64_retq_zo<C: Context>(
    ctx: &mut C,
) -> SideEffectNoResult {
    let v0 = &C::x64_retq_zo_raw(ctx);
    let v1 = &constructor_defer_side_effect(ctx, v0);
    // Rule at <OUT_DIR>/assembler.isle line 3323.
    return v1.clone();
}

// Generated as internal constructor for term x64_retq_i.
pub fn constructor_x64_retq_i<C: Context>(
    ctx: &mut C,
    arg0: u16,
) -> SideEffectNoResult {
    let v1 = &C::x64_retq_i_raw(ctx, arg0);
    let v2 = &constructor_defer_side_effect(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 3328.
    return v2.clone();
}

// Generated as internal constructor for term x64_leaw_rm.
pub fn constructor_x64_leaw_rm<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
) -> Gpr {
    let v1 = &C::x64_leaw_rm_raw(ctx, arg0);
    let v2 = constructor_emit_ret_gpr(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 3333.
    return v2;
}

// Generated as internal constructor for term x64_leal_rm.
pub fn constructor_x64_leal_rm<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
) -> Gpr {
    let v1 = &C::x64_leal_rm_raw(ctx, arg0);
    let v2 = constructor_emit_ret_gpr(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 3338.
    return v2;
}

// Generated as internal constructor for term x64_leaq_rm.
pub fn constructor_x64_leaq_rm<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
) -> Gpr {
    let v1 = &C::x64_leaq_rm_raw(ctx, arg0);
    let v2 = constructor_emit_ret_gpr(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 3343.
    return v2;
}

// Generated as internal constructor for term x64_callq_d.
pub fn constructor_x64_callq_d<C: Context>(
    ctx: &mut C,
    arg0: i32,
) -> SideEffectNoResult {
    let v1 = &C::x64_callq_d_raw(ctx, arg0);
    let v2 = &constructor_defer_side_effect(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 3348.
    return v2.clone();
}

// Generated as internal constructor for term x64_callq_m.
pub fn constructor_x64_callq_m<C: Context>(
    ctx: &mut C,
    arg0: &GprMem,
) -> SideEffectNoResult {
    let v1 = &C::x64_callq_m_raw(ctx, arg0);
    let v2 = &constructor_defer_side_effect(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 3353.
    return v2.clone();
}

// Generated as internal constructor for term x64_movb_mr.
pub fn constructor_x64_movb_mr<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
) -> Gpr {
    let v1 = C::temp_writable_gpr(ctx);
    let v2 = &constructor_writable_gpr_to_gpr_mem(ctx, v1);
    let v3 = &C::x64_movb_mr_raw(ctx, v2, arg0);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 3358.
    return v4;
}

// Generated as internal constructor for term x64_movb_mr_mem.
pub fn constructor_x64_movb_mr_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Gpr,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_movb_mr_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 3360.
    return v4.clone();
}

// Generated as internal constructor for term x64_movw_mr.
pub fn constructor_x64_movw_mr<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
) -> Gpr {
    let v1 = C::temp_writable_gpr(ctx);
    let v2 = &constructor_writable_gpr_to_gpr_mem(ctx, v1);
    let v3 = &C::x64_movw_mr_raw(ctx, v2, arg0);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 3365.
    return v4;
}

// Generated as internal constructor for term x64_movw_mr_mem.
pub fn constructor_x64_movw_mr_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Gpr,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_movw_mr_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 3367.
    return v4.clone();
}

// Generated as internal constructor for term x64_movl_mr.
pub fn constructor_x64_movl_mr<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
) -> Gpr {
    let v1 = C::temp_writable_gpr(ctx);
    let v2 = &constructor_writable_gpr_to_gpr_mem(ctx, v1);
    let v3 = &C::x64_movl_mr_raw(ctx, v2, arg0);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 3372.
    return v4;
}

// Generated as internal constructor for term x64_movl_mr_mem.
pub fn constructor_x64_movl_mr_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Gpr,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_movl_mr_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 3374.
    return v4.clone();
}

// Generated as internal constructor for term x64_movq_mr.
pub fn constructor_x64_movq_mr<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
) -> Gpr {
    let v1 = C::temp_writable_gpr(ctx);
    let v2 = &constructor_writable_gpr_to_gpr_mem(ctx, v1);
    let v3 = &C::x64_movq_mr_raw(ctx, v2, arg0);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 3379.
    return v4;
}

// Generated as internal constructor for term x64_movq_mr_mem.
pub fn constructor_x64_movq_mr_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Gpr,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_movq_mr_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 3381.
    return v4.clone();
}

// Generated as internal constructor for term x64_movb_rm.
pub fn constructor_x64_movb_rm<C: Context>(
    ctx: &mut C,
    arg0: &GprMem,
) -> Gpr {
    let v1 = &C::x64_movb_rm_raw(ctx, arg0);
    let v2 = constructor_emit_ret_gpr(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 3386.
    return v2;
}

// Generated as internal constructor for term x64_movw_rm.
pub fn constructor_x64_movw_rm<C: Context>(
    ctx: &mut C,
    arg0: &GprMem,
) -> Gpr {
    let v1 = &C::x64_movw_rm_raw(ctx, arg0);
    let v2 = constructor_emit_ret_gpr(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 3391.
    return v2;
}

// Generated as internal constructor for term x64_movl_rm.
pub fn constructor_x64_movl_rm<C: Context>(
    ctx: &mut C,
    arg0: &GprMem,
) -> Gpr {
    let v1 = &C::x64_movl_rm_raw(ctx, arg0);
    let v2 = constructor_emit_ret_gpr(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 3396.
    return v2;
}

// Generated as internal constructor for term x64_movq_rm.
pub fn constructor_x64_movq_rm<C: Context>(
    ctx: &mut C,
    arg0: &GprMem,
) -> Gpr {
    let v1 = &C::x64_movq_rm_raw(ctx, arg0);
    let v2 = constructor_emit_ret_gpr(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 3401.
    return v2;
}

// Generated as internal constructor for term x64_movb_oi.
pub fn constructor_x64_movb_oi<C: Context>(
    ctx: &mut C,
    arg0: u8,
) -> Gpr {
    let v1 = &C::x64_movb_oi_raw(ctx, arg0);
    let v2 = constructor_emit_ret_gpr(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 3406.
    return v2;
}

// Generated as internal constructor for term x64_movw_oi.
pub fn constructor_x64_movw_oi<C: Context>(
    ctx: &mut C,
    arg0: u16,
) -> Gpr {
    let v1 = &C::x64_movw_oi_raw(ctx, arg0);
    let v2 = constructor_emit_ret_gpr(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 3411.
    return v2;
}

// Generated as internal constructor for term x64_movl_oi.
pub fn constructor_x64_movl_oi<C: Context>(
    ctx: &mut C,
    arg0: u32,
) -> Gpr {
    let v1 = &C::x64_movl_oi_raw(ctx, arg0);
    let v2 = constructor_emit_ret_gpr(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 3416.
    return v2;
}

// Generated as internal constructor for term x64_movabsq_oi.
pub fn constructor_x64_movabsq_oi<C: Context>(
    ctx: &mut C,
    arg0: u64,
) -> Gpr {
    let v1 = &C::x64_movabsq_oi_raw(ctx, arg0);
    let v2 = constructor_emit_ret_gpr(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 3421.
    return v2;
}

// Generated as internal constructor for term x64_movb_mi.
pub fn constructor_x64_movb_mi<C: Context>(
    ctx: &mut C,
    arg0: u8,
) -> Gpr {
    let v1 = C::temp_writable_gpr(ctx);
    let v2 = &constructor_writable_gpr_to_gpr_mem(ctx, v1);
    let v3 = &C::x64_movb_mi_raw(ctx, v2, arg0);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 3426.
    return v4;
}

// Generated as internal constructor for term x64_movb_mi_mem.
pub fn constructor_x64_movb_mi_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: u8,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_movb_mi_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 3428.
    return v4.clone();
}

// Generated as internal constructor for term x64_movw_mi.
pub fn constructor_x64_movw_mi<C: Context>(
    ctx: &mut C,
    arg0: u16,
) -> Gpr {
    let v1 = C::temp_writable_gpr(ctx);
    let v2 = &constructor_writable_gpr_to_gpr_mem(ctx, v1);
    let v3 = &C::x64_movw_mi_raw(ctx, v2, arg0);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 3433.
    return v4;
}

// Generated as internal constructor for term x64_movw_mi_mem.
pub fn constructor_x64_movw_mi_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: u16,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_movw_mi_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 3435.
    return v4.clone();
}

// Generated as internal constructor for term x64_movl_mi.
pub fn constructor_x64_movl_mi<C: Context>(
    ctx: &mut C,
    arg0: u32,
) -> Gpr {
    let v1 = C::temp_writable_gpr(ctx);
    let v2 = &constructor_writable_gpr_to_gpr_mem(ctx, v1);
    let v3 = &C::x64_movl_mi_raw(ctx, v2, arg0);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 3440.
    return v4;
}

// Generated as internal constructor for term x64_movl_mi_mem.
pub fn constructor_x64_movl_mi_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: u32,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_movl_mi_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 3442.
    return v4.clone();
}

// Generated as internal constructor for term x64_movq_mi_sxl.
pub fn constructor_x64_movq_mi_sxl<C: Context>(
    ctx: &mut C,
    arg0: i32,
) -> Gpr {
    let v1 = C::temp_writable_gpr(ctx);
    let v2 = &constructor_writable_gpr_to_gpr_mem(ctx, v1);
    let v3 = &C::x64_movq_mi_sxl_raw(ctx, v2, arg0);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 3447.
    return v4;
}

// Generated as internal constructor for term x64_movq_mi_sxl_mem.
pub fn constructor_x64_movq_mi_sxl_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: i32,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_movq_mi_sxl_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 3449.
    return v4.clone();
}

// Generated as internal constructor for term x64_movsbw_rm.
pub fn constructor_x64_movsbw_rm<C: Context>(
    ctx: &mut C,
    arg0: &GprMem,
) -> Gpr {
    let v1 = &C::x64_movsbw_rm_raw(ctx, arg0);
    let v2 = constructor_emit_ret_gpr(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 3454.
    return v2;
}

// Generated as internal constructor for term x64_movsbl_rm.
pub fn constructor_x64_movsbl_rm<C: Context>(
    ctx: &mut C,
    arg0: &GprMem,
) -> Gpr {
    let v1 = &C::x64_movsbl_rm_raw(ctx, arg0);
    let v2 = constructor_emit_ret_gpr(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 3459.
    return v2;
}

// Generated as internal constructor for term x64_movsbq_rm.
pub fn constructor_x64_movsbq_rm<C: Context>(
    ctx: &mut C,
    arg0: &GprMem,
) -> Gpr {
    let v1 = &C::x64_movsbq_rm_raw(ctx, arg0);
    let v2 = constructor_emit_ret_gpr(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 3464.
    return v2;
}

// Generated as internal constructor for term x64_movsww_rm.
pub fn constructor_x64_movsww_rm<C: Context>(
    ctx: &mut C,
    arg0: &GprMem,
) -> Gpr {
    let v1 = &C::x64_movsww_rm_raw(ctx, arg0);
    let v2 = constructor_emit_ret_gpr(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 3469.
    return v2;
}

// Generated as internal constructor for term x64_movswl_rm.
pub fn constructor_x64_movswl_rm<C: Context>(
    ctx: &mut C,
    arg0: &GprMem,
) -> Gpr {
    let v1 = &C::x64_movswl_rm_raw(ctx, arg0);
    let v2 = constructor_emit_ret_gpr(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 3474.
    return v2;
}

// Generated as internal constructor for term x64_movswq_rm.
pub fn constructor_x64_movswq_rm<C: Context>(
    ctx: &mut C,
    arg0: &GprMem,
) -> Gpr {
    let v1 = &C::x64_movswq_rm_raw(ctx, arg0);
    let v2 = constructor_emit_ret_gpr(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 3479.
    return v2;
}

// Generated as internal constructor for term x64_movslq_rm.
pub fn constructor_x64_movslq_rm<C: Context>(
    ctx: &mut C,
    arg0: &GprMem,
) -> Gpr {
    let v1 = &C::x64_movslq_rm_raw(ctx, arg0);
    let v2 = constructor_emit_ret_gpr(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 3484.
    return v2;
}

// Generated as internal constructor for term x64_movzbw_rm.
pub fn constructor_x64_movzbw_rm<C: Context>(
    ctx: &mut C,
    arg0: &GprMem,
) -> Gpr {
    let v1 = &C::x64_movzbw_rm_raw(ctx, arg0);
    let v2 = constructor_emit_ret_gpr(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 3489.
    return v2;
}

// Generated as internal constructor for term x64_movzbl_rm.
pub fn constructor_x64_movzbl_rm<C: Context>(
    ctx: &mut C,
    arg0: &GprMem,
) -> Gpr {
    let v1 = &C::x64_movzbl_rm_raw(ctx, arg0);
    let v2 = constructor_emit_ret_gpr(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 3494.
    return v2;
}

// Generated as internal constructor for term x64_movzbq_rm.
pub fn constructor_x64_movzbq_rm<C: Context>(
    ctx: &mut C,
    arg0: &GprMem,
) -> Gpr {
    let v1 = &C::x64_movzbq_rm_raw(ctx, arg0);
    let v2 = constructor_emit_ret_gpr(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 3499.
    return v2;
}

// Generated as internal constructor for term x64_movzww_rm.
pub fn constructor_x64_movzww_rm<C: Context>(
    ctx: &mut C,
    arg0: &GprMem,
) -> Gpr {
    let v1 = &C::x64_movzww_rm_raw(ctx, arg0);
    let v2 = constructor_emit_ret_gpr(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 3504.
    return v2;
}

// Generated as internal constructor for term x64_movzwl_rm.
pub fn constructor_x64_movzwl_rm<C: Context>(
    ctx: &mut C,
    arg0: &GprMem,
) -> Gpr {
    let v1 = &C::x64_movzwl_rm_raw(ctx, arg0);
    let v2 = constructor_emit_ret_gpr(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 3509.
    return v2;
}

// Generated as internal constructor for term x64_movzwq_rm.
pub fn constructor_x64_movzwq_rm<C: Context>(
    ctx: &mut C,
    arg0: &GprMem,
) -> Gpr {
    let v1 = &C::x64_movzwq_rm_raw(ctx, arg0);
    let v2 = constructor_emit_ret_gpr(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 3514.
    return v2;
}

// Generated as internal constructor for term x64_movd_a.
pub fn constructor_x64_movd_a<C: Context>(
    ctx: &mut C,
    arg0: &GprMem,
) -> Xmm {
    let v1 = &C::x64_movd_a_raw(ctx, arg0);
    let v2 = constructor_emit_ret_xmm(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 3519.
    return v2;
}

// Generated as internal constructor for term x64_movq_a.
pub fn constructor_x64_movq_a<C: Context>(
    ctx: &mut C,
    arg0: &GprMem,
) -> Xmm {
    let v1 = &C::x64_movq_a_raw(ctx, arg0);
    let v2 = constructor_emit_ret_xmm(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 3524.
    return v2;
}

// Generated as internal constructor for term x64_movd_b.
pub fn constructor_x64_movd_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
) -> Gpr {
    let v1 = C::temp_writable_gpr(ctx);
    let v2 = &constructor_writable_gpr_to_gpr_mem(ctx, v1);
    let v3 = &C::x64_movd_b_raw(ctx, v2, arg0);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 3529.
    return v4;
}

// Generated as internal constructor for term x64_movd_b_mem.
pub fn constructor_x64_movd_b_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Xmm,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_movd_b_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 3531.
    return v4.clone();
}

// Generated as internal constructor for term x64_movq_b.
pub fn constructor_x64_movq_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
) -> Gpr {
    let v1 = C::temp_writable_gpr(ctx);
    let v2 = &constructor_writable_gpr_to_gpr_mem(ctx, v1);
    let v3 = &C::x64_movq_b_raw(ctx, v2, arg0);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 3536.
    return v4;
}

// Generated as internal constructor for term x64_movq_b_mem.
pub fn constructor_x64_movq_b_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Xmm,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_movq_b_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 3538.
    return v4.clone();
}

// Generated as internal constructor for term x64_vmovd_a.
pub fn constructor_x64_vmovd_a<C: Context>(
    ctx: &mut C,
    arg0: &GprMem,
) -> Xmm {
    let v1 = &C::x64_vmovd_a_raw(ctx, arg0);
    let v2 = constructor_emit_ret_xmm(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 3543.
    return v2;
}

// Generated as internal constructor for term x64_vmovq_a.
pub fn constructor_x64_vmovq_a<C: Context>(
    ctx: &mut C,
    arg0: &GprMem,
) -> Xmm {
    let v1 = &C::x64_vmovq_a_raw(ctx, arg0);
    let v2 = constructor_emit_ret_xmm(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 3548.
    return v2;
}

// Generated as internal constructor for term x64_vmovd_b.
pub fn constructor_x64_vmovd_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
) -> Gpr {
    let v1 = C::temp_writable_gpr(ctx);
    let v2 = &constructor_writable_gpr_to_gpr_mem(ctx, v1);
    let v3 = &C::x64_vmovd_b_raw(ctx, v2, arg0);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 3553.
    return v4;
}

// Generated as internal constructor for term x64_vmovd_b_mem.
pub fn constructor_x64_vmovd_b_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Xmm,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_vmovd_b_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 3555.
    return v4.clone();
}

// Generated as internal constructor for term x64_vmovq_b.
pub fn constructor_x64_vmovq_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
) -> Gpr {
    let v1 = C::temp_writable_gpr(ctx);
    let v2 = &constructor_writable_gpr_to_gpr_mem(ctx, v1);
    let v3 = &C::x64_vmovq_b_raw(ctx, v2, arg0);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 3560.
    return v4;
}

// Generated as internal constructor for term x64_vmovq_b_mem.
pub fn constructor_x64_vmovq_b_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Xmm,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_vmovq_b_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 3562.
    return v4.clone();
}

// Generated as internal constructor for term x64_movss_a_m.
pub fn constructor_x64_movss_a_m<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
) -> Xmm {
    let v1 = &C::x64_movss_a_m_raw(ctx, arg0);
    let v2 = constructor_emit_ret_xmm(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 3567.
    return v2;
}

// Generated as internal constructor for term x64_movss_a_m_or_avx.
pub fn constructor_x64_movss_a_m_or_avx<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
) -> Xmm {
    let v1 = C::has_avx(ctx);
    if v1 == true {
        let v2 = constructor_x64_vmovss_d(ctx, arg0);
        // Rule at <OUT_DIR>/assembler.isle line 3569.
        return v2;
    }
    let v3 = constructor_x64_movss_a_m(ctx, arg0);
    // Rule at <OUT_DIR>/assembler.isle line 3572.
    return v3;
}

// Generated as internal constructor for term x64_movss_a_r.
pub fn constructor_x64_movss_a_r<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: Xmm,
) -> Xmm {
    let v2 = &C::x64_movss_a_r_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 3577.
    return v3;
}

// Generated as internal constructor for term x64_movss_a_r_or_avx.
pub fn constructor_x64_movss_a_r_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: Xmm,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vmovss_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 3579.
        return v3;
    }
    let v4 = constructor_x64_movss_a_r(ctx, arg0, arg1);
    // Rule at <OUT_DIR>/assembler.isle line 3582.
    return v4;
}

// Generated as internal constructor for term x64_movss_c_m_mem.
pub fn constructor_x64_movss_c_m_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Xmm,
) -> SideEffectNoResult {
    let v2 = &C::x64_movss_c_m_raw(ctx, arg0, arg1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 3587.
    return v3.clone();
}

// Generated as internal constructor for term x64_movss_c_m_mem_or_avx.
pub fn constructor_x64_movss_c_m_mem_or_avx<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Xmm,
) -> SideEffectNoResult {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = &constructor_x64_vmovss_c_m_mem(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 3589.
        return v3.clone();
    }
    let v4 = &constructor_x64_movss_c_m_mem(ctx, arg0, arg1);
    // Rule at <OUT_DIR>/assembler.isle line 3592.
    return v4.clone();
}

// Generated as internal constructor for term x64_movsd_a_m.
pub fn constructor_x64_movsd_a_m<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
) -> Xmm {
    let v1 = &C::x64_movsd_a_m_raw(ctx, arg0);
    let v2 = constructor_emit_ret_xmm(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 3597.
    return v2;
}

// Generated as internal constructor for term x64_movsd_a_m_or_avx.
pub fn constructor_x64_movsd_a_m_or_avx<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
) -> Xmm {
    let v1 = C::has_avx(ctx);
    if v1 == true {
        let v2 = constructor_x64_vmovsd_d(ctx, arg0);
        // Rule at <OUT_DIR>/assembler.isle line 3599.
        return v2;
    }
    let v3 = constructor_x64_movsd_a_m(ctx, arg0);
    // Rule at <OUT_DIR>/assembler.isle line 3602.
    return v3;
}

// Generated as internal constructor for term x64_movsd_a_r.
pub fn constructor_x64_movsd_a_r<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: Xmm,
) -> Xmm {
    let v2 = &C::x64_movsd_a_r_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 3607.
    return v3;
}

// Generated as internal constructor for term x64_movsd_a_r_or_avx.
pub fn constructor_x64_movsd_a_r_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: Xmm,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vmovsd_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 3609.
        return v3;
    }
    let v4 = constructor_x64_movsd_a_r(ctx, arg0, arg1);
    // Rule at <OUT_DIR>/assembler.isle line 3612.
    return v4;
}

// Generated as internal constructor for term x64_movsd_c_m_mem.
pub fn constructor_x64_movsd_c_m_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Xmm,
) -> SideEffectNoResult {
    let v2 = &C::x64_movsd_c_m_raw(ctx, arg0, arg1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 3617.
    return v3.clone();
}

// Generated as internal constructor for term x64_movsd_c_m_mem_or_avx.
pub fn constructor_x64_movsd_c_m_mem_or_avx<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Xmm,
) -> SideEffectNoResult {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = &constructor_x64_vmovsd_c_m_mem(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 3619.
        return v3.clone();
    }
    let v4 = &constructor_x64_movsd_c_m_mem(ctx, arg0, arg1);
    // Rule at <OUT_DIR>/assembler.isle line 3622.
    return v4.clone();
}

// Generated as internal constructor for term x64_vmovss_d.
pub fn constructor_x64_vmovss_d<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
) -> Xmm {
    let v1 = &C::x64_vmovss_d_raw(ctx, arg0);
    let v2 = constructor_emit_ret_xmm(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 3627.
    return v2;
}

// Generated as internal constructor for term x64_vmovss_b.
pub fn constructor_x64_vmovss_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: Xmm,
) -> Xmm {
    let v2 = &C::x64_vmovss_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 3632.
    return v3;
}

// Generated as internal constructor for term x64_vmovss_c_m_mem.
pub fn constructor_x64_vmovss_c_m_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Xmm,
) -> SideEffectNoResult {
    let v2 = &C::x64_vmovss_c_m_raw(ctx, arg0, arg1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 3637.
    return v3.clone();
}

// Generated as internal constructor for term x64_vmovsd_d.
pub fn constructor_x64_vmovsd_d<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
) -> Xmm {
    let v1 = &C::x64_vmovsd_d_raw(ctx, arg0);
    let v2 = constructor_emit_ret_xmm(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 3642.
    return v2;
}

// Generated as internal constructor for term x64_vmovsd_b.
pub fn constructor_x64_vmovsd_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: Xmm,
) -> Xmm {
    let v2 = &C::x64_vmovsd_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 3647.
    return v3;
}

// Generated as internal constructor for term x64_vmovsd_c_m_mem.
pub fn constructor_x64_vmovsd_c_m_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Xmm,
) -> SideEffectNoResult {
    let v2 = &C::x64_vmovsd_c_m_raw(ctx, arg0, arg1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 3652.
    return v3.clone();
}

// Generated as internal constructor for term x64_movapd_a.
pub fn constructor_x64_movapd_a<C: Context>(
    ctx: &mut C,
    arg0: &XmmMemAligned,
) -> Xmm {
    let v1 = &C::x64_movapd_a_raw(ctx, arg0);
    let v2 = constructor_emit_ret_xmm(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 3657.
    return v2;
}

// Generated as internal constructor for term x64_movapd_a_or_avx.
pub fn constructor_x64_movapd_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = C::has_avx(ctx);
    if v1 == true {
        let v2 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg0);
        let v3 = constructor_x64_vmovapd_a(ctx, v2);
        // Rule at <OUT_DIR>/assembler.isle line 3659.
        return v3;
    }
    let v2 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg0);
    let v4 = constructor_x64_movapd_a(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 3662.
    return v4;
}

// Generated as internal constructor for term x64_movapd_b.
pub fn constructor_x64_movapd_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
) -> Xmm {
    let v1 = C::temp_writable_xmm(ctx);
    let v2 = &constructor_writable_xmm_to_xmm_mem_aligned(ctx, v1);
    let v3 = &C::x64_movapd_b_raw(ctx, v2, arg0);
    let v4 = constructor_emit_ret_xmm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 3667.
    return v4;
}

// Generated as internal constructor for term x64_movapd_b_or_avx.
pub fn constructor_x64_movapd_b_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
) -> Xmm {
    let v1 = C::has_avx(ctx);
    if v1 == true {
        let v2 = constructor_x64_vmovapd_b(ctx, arg0);
        // Rule at <OUT_DIR>/assembler.isle line 3669.
        return v2;
    }
    let v3 = constructor_x64_movapd_b(ctx, arg0);
    // Rule at <OUT_DIR>/assembler.isle line 3672.
    return v3;
}

// Generated as internal constructor for term x64_movapd_b_mem.
pub fn constructor_x64_movapd_b_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Xmm,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_xmm_mem_aligned(ctx, arg0);
    let v3 = &C::x64_movapd_b_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 3674.
    return v4.clone();
}

// Generated as internal constructor for term x64_movapd_b_mem_or_avx.
pub fn constructor_x64_movapd_b_mem_or_avx<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Xmm,
) -> SideEffectNoResult {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = &constructor_x64_vmovapd_b_mem(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 3676.
        return v3.clone();
    }
    let v4 = &constructor_x64_movapd_b_mem(ctx, arg0, arg1);
    // Rule at <OUT_DIR>/assembler.isle line 3679.
    return v4.clone();
}

// Generated as internal constructor for term x64_movaps_a.
pub fn constructor_x64_movaps_a<C: Context>(
    ctx: &mut C,
    arg0: &XmmMemAligned,
) -> Xmm {
    let v1 = &C::x64_movaps_a_raw(ctx, arg0);
    let v2 = constructor_emit_ret_xmm(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 3684.
    return v2;
}

// Generated as internal constructor for term x64_movaps_a_or_avx.
pub fn constructor_x64_movaps_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = C::has_avx(ctx);
    if v1 == true {
        let v2 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg0);
        let v3 = constructor_x64_vmovaps_a(ctx, v2);
        // Rule at <OUT_DIR>/assembler.isle line 3686.
        return v3;
    }
    let v2 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg0);
    let v4 = constructor_x64_movaps_a(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 3689.
    return v4;
}

// Generated as internal constructor for term x64_movaps_b.
pub fn constructor_x64_movaps_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
) -> Xmm {
    let v1 = C::temp_writable_xmm(ctx);
    let v2 = &constructor_writable_xmm_to_xmm_mem_aligned(ctx, v1);
    let v3 = &C::x64_movaps_b_raw(ctx, v2, arg0);
    let v4 = constructor_emit_ret_xmm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 3694.
    return v4;
}

// Generated as internal constructor for term x64_movaps_b_or_avx.
pub fn constructor_x64_movaps_b_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
) -> Xmm {
    let v1 = C::has_avx(ctx);
    if v1 == true {
        let v2 = constructor_x64_vmovaps_b(ctx, arg0);
        // Rule at <OUT_DIR>/assembler.isle line 3696.
        return v2;
    }
    let v3 = constructor_x64_movaps_b(ctx, arg0);
    // Rule at <OUT_DIR>/assembler.isle line 3699.
    return v3;
}

// Generated as internal constructor for term x64_movaps_b_mem.
pub fn constructor_x64_movaps_b_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Xmm,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_xmm_mem_aligned(ctx, arg0);
    let v3 = &C::x64_movaps_b_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 3701.
    return v4.clone();
}

// Generated as internal constructor for term x64_movaps_b_mem_or_avx.
pub fn constructor_x64_movaps_b_mem_or_avx<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Xmm,
) -> SideEffectNoResult {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = &constructor_x64_vmovaps_b_mem(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 3703.
        return v3.clone();
    }
    let v4 = &constructor_x64_movaps_b_mem(ctx, arg0, arg1);
    // Rule at <OUT_DIR>/assembler.isle line 3706.
    return v4.clone();
}

// Generated as internal constructor for term x64_movdqa_a.
pub fn constructor_x64_movdqa_a<C: Context>(
    ctx: &mut C,
    arg0: &XmmMemAligned,
) -> Xmm {
    let v1 = &C::x64_movdqa_a_raw(ctx, arg0);
    let v2 = constructor_emit_ret_xmm(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 3711.
    return v2;
}

// Generated as internal constructor for term x64_movdqa_a_or_avx.
pub fn constructor_x64_movdqa_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = C::has_avx(ctx);
    if v1 == true {
        let v2 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg0);
        let v3 = constructor_x64_vmovdqa_a(ctx, v2);
        // Rule at <OUT_DIR>/assembler.isle line 3713.
        return v3;
    }
    let v2 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg0);
    let v4 = constructor_x64_movdqa_a(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 3716.
    return v4;
}

// Generated as internal constructor for term x64_movdqa_b.
pub fn constructor_x64_movdqa_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
) -> Xmm {
    let v1 = C::temp_writable_xmm(ctx);
    let v2 = &constructor_writable_xmm_to_xmm_mem_aligned(ctx, v1);
    let v3 = &C::x64_movdqa_b_raw(ctx, v2, arg0);
    let v4 = constructor_emit_ret_xmm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 3721.
    return v4;
}

// Generated as internal constructor for term x64_movdqa_b_or_avx.
pub fn constructor_x64_movdqa_b_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
) -> Xmm {
    let v1 = C::has_avx(ctx);
    if v1 == true {
        let v2 = constructor_x64_vmovdqa_b(ctx, arg0);
        // Rule at <OUT_DIR>/assembler.isle line 3723.
        return v2;
    }
    let v3 = constructor_x64_movdqa_b(ctx, arg0);
    // Rule at <OUT_DIR>/assembler.isle line 3726.
    return v3;
}

// Generated as internal constructor for term x64_movdqa_b_mem.
pub fn constructor_x64_movdqa_b_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Xmm,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_xmm_mem_aligned(ctx, arg0);
    let v3 = &C::x64_movdqa_b_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 3728.
    return v4.clone();
}

// Generated as internal constructor for term x64_movdqa_b_mem_or_avx.
pub fn constructor_x64_movdqa_b_mem_or_avx<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Xmm,
) -> SideEffectNoResult {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = &constructor_x64_vmovdqa_b_mem(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 3730.
        return v3.clone();
    }
    let v4 = &constructor_x64_movdqa_b_mem(ctx, arg0, arg1);
    // Rule at <OUT_DIR>/assembler.isle line 3733.
    return v4.clone();
}

// Generated as internal constructor for term x64_vmovapd_a.
pub fn constructor_x64_vmovapd_a<C: Context>(
    ctx: &mut C,
    arg0: &XmmMemAligned,
) -> Xmm {
    let v1 = &C::x64_vmovapd_a_raw(ctx, arg0);
    let v2 = constructor_emit_ret_xmm(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 3738.
    return v2;
}

// Generated as internal constructor for term x64_vmovapd_b.
pub fn constructor_x64_vmovapd_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
) -> Xmm {
    let v1 = C::temp_writable_xmm(ctx);
    let v2 = &constructor_writable_xmm_to_xmm_mem_aligned(ctx, v1);
    let v3 = &C::x64_vmovapd_b_raw(ctx, v2, arg0);
    let v4 = constructor_emit_ret_xmm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 3743.
    return v4;
}

// Generated as internal constructor for term x64_vmovapd_b_mem.
pub fn constructor_x64_vmovapd_b_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Xmm,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_xmm_mem_aligned(ctx, arg0);
    let v3 = &C::x64_vmovapd_b_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 3745.
    return v4.clone();
}

// Generated as internal constructor for term x64_vmovaps_a.
pub fn constructor_x64_vmovaps_a<C: Context>(
    ctx: &mut C,
    arg0: &XmmMemAligned,
) -> Xmm {
    let v1 = &C::x64_vmovaps_a_raw(ctx, arg0);
    let v2 = constructor_emit_ret_xmm(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 3750.
    return v2;
}

// Generated as internal constructor for term x64_vmovaps_b.
pub fn constructor_x64_vmovaps_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
) -> Xmm {
    let v1 = C::temp_writable_xmm(ctx);
    let v2 = &constructor_writable_xmm_to_xmm_mem_aligned(ctx, v1);
    let v3 = &C::x64_vmovaps_b_raw(ctx, v2, arg0);
    let v4 = constructor_emit_ret_xmm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 3755.
    return v4;
}

// Generated as internal constructor for term x64_vmovaps_b_mem.
pub fn constructor_x64_vmovaps_b_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Xmm,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_xmm_mem_aligned(ctx, arg0);
    let v3 = &C::x64_vmovaps_b_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 3757.
    return v4.clone();
}

// Generated as internal constructor for term x64_vmovdqa_a.
pub fn constructor_x64_vmovdqa_a<C: Context>(
    ctx: &mut C,
    arg0: &XmmMemAligned,
) -> Xmm {
    let v1 = &C::x64_vmovdqa_a_raw(ctx, arg0);
    let v2 = constructor_emit_ret_xmm(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 3762.
    return v2;
}

// Generated as internal constructor for term x64_vmovdqa_b.
pub fn constructor_x64_vmovdqa_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
) -> Xmm {
    let v1 = C::temp_writable_xmm(ctx);
    let v2 = &constructor_writable_xmm_to_xmm_mem_aligned(ctx, v1);
    let v3 = &C::x64_vmovdqa_b_raw(ctx, v2, arg0);
    let v4 = constructor_emit_ret_xmm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 3767.
    return v4;
}

// Generated as internal constructor for term x64_vmovdqa_b_mem.
pub fn constructor_x64_vmovdqa_b_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Xmm,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_xmm_mem_aligned(ctx, arg0);
    let v3 = &C::x64_vmovdqa_b_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 3769.
    return v4.clone();
}

// Generated as internal constructor for term x64_movupd_a.
pub fn constructor_x64_movupd_a<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = &C::x64_movupd_a_raw(ctx, arg0);
    let v2 = constructor_emit_ret_xmm(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 3774.
    return v2;
}

// Generated as internal constructor for term x64_movupd_a_or_avx.
pub fn constructor_x64_movupd_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = C::has_avx(ctx);
    if v1 == true {
        let v2 = constructor_x64_vmovupd_a(ctx, arg0);
        // Rule at <OUT_DIR>/assembler.isle line 3776.
        return v2;
    }
    let v3 = constructor_x64_movupd_a(ctx, arg0);
    // Rule at <OUT_DIR>/assembler.isle line 3779.
    return v3;
}

// Generated as internal constructor for term x64_movupd_b.
pub fn constructor_x64_movupd_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
) -> Xmm {
    let v1 = C::temp_writable_xmm(ctx);
    let v2 = &constructor_writable_xmm_to_xmm_mem(ctx, v1);
    let v3 = &C::x64_movupd_b_raw(ctx, v2, arg0);
    let v4 = constructor_emit_ret_xmm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 3784.
    return v4;
}

// Generated as internal constructor for term x64_movupd_b_or_avx.
pub fn constructor_x64_movupd_b_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
) -> Xmm {
    let v1 = C::has_avx(ctx);
    if v1 == true {
        let v2 = constructor_x64_vmovupd_b(ctx, arg0);
        // Rule at <OUT_DIR>/assembler.isle line 3786.
        return v2;
    }
    let v3 = constructor_x64_movupd_b(ctx, arg0);
    // Rule at <OUT_DIR>/assembler.isle line 3789.
    return v3;
}

// Generated as internal constructor for term x64_movupd_b_mem.
pub fn constructor_x64_movupd_b_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Xmm,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_xmm_mem(ctx, arg0);
    let v3 = &C::x64_movupd_b_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 3791.
    return v4.clone();
}

// Generated as internal constructor for term x64_movupd_b_mem_or_avx.
pub fn constructor_x64_movupd_b_mem_or_avx<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Xmm,
) -> SideEffectNoResult {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = &constructor_x64_vmovupd_b_mem(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 3793.
        return v3.clone();
    }
    let v4 = &constructor_x64_movupd_b_mem(ctx, arg0, arg1);
    // Rule at <OUT_DIR>/assembler.isle line 3796.
    return v4.clone();
}

// Generated as internal constructor for term x64_movups_a.
pub fn constructor_x64_movups_a<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = &C::x64_movups_a_raw(ctx, arg0);
    let v2 = constructor_emit_ret_xmm(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 3801.
    return v2;
}

// Generated as internal constructor for term x64_movups_a_or_avx.
pub fn constructor_x64_movups_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = C::has_avx(ctx);
    if v1 == true {
        let v2 = constructor_x64_vmovups_a(ctx, arg0);
        // Rule at <OUT_DIR>/assembler.isle line 3803.
        return v2;
    }
    let v3 = constructor_x64_movups_a(ctx, arg0);
    // Rule at <OUT_DIR>/assembler.isle line 3806.
    return v3;
}

// Generated as internal constructor for term x64_movups_b.
pub fn constructor_x64_movups_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
) -> Xmm {
    let v1 = C::temp_writable_xmm(ctx);
    let v2 = &constructor_writable_xmm_to_xmm_mem(ctx, v1);
    let v3 = &C::x64_movups_b_raw(ctx, v2, arg0);
    let v4 = constructor_emit_ret_xmm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 3811.
    return v4;
}

// Generated as internal constructor for term x64_movups_b_or_avx.
pub fn constructor_x64_movups_b_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
) -> Xmm {
    let v1 = C::has_avx(ctx);
    if v1 == true {
        let v2 = constructor_x64_vmovups_b(ctx, arg0);
        // Rule at <OUT_DIR>/assembler.isle line 3813.
        return v2;
    }
    let v3 = constructor_x64_movups_b(ctx, arg0);
    // Rule at <OUT_DIR>/assembler.isle line 3816.
    return v3;
}

// Generated as internal constructor for term x64_movups_b_mem.
pub fn constructor_x64_movups_b_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Xmm,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_xmm_mem(ctx, arg0);
    let v3 = &C::x64_movups_b_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 3818.
    return v4.clone();
}

// Generated as internal constructor for term x64_movups_b_mem_or_avx.
pub fn constructor_x64_movups_b_mem_or_avx<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Xmm,
) -> SideEffectNoResult {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = &constructor_x64_vmovups_b_mem(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 3820.
        return v3.clone();
    }
    let v4 = &constructor_x64_movups_b_mem(ctx, arg0, arg1);
    // Rule at <OUT_DIR>/assembler.isle line 3823.
    return v4.clone();
}

// Generated as internal constructor for term x64_movdqu_a.
pub fn constructor_x64_movdqu_a<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = &C::x64_movdqu_a_raw(ctx, arg0);
    let v2 = constructor_emit_ret_xmm(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 3828.
    return v2;
}

// Generated as internal constructor for term x64_movdqu_a_or_avx.
pub fn constructor_x64_movdqu_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = C::has_avx(ctx);
    if v1 == true {
        let v2 = constructor_x64_vmovdqu_a(ctx, arg0);
        // Rule at <OUT_DIR>/assembler.isle line 3830.
        return v2;
    }
    let v3 = constructor_x64_movdqu_a(ctx, arg0);
    // Rule at <OUT_DIR>/assembler.isle line 3833.
    return v3;
}

// Generated as internal constructor for term x64_movdqu_b.
pub fn constructor_x64_movdqu_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
) -> Xmm {
    let v1 = C::temp_writable_xmm(ctx);
    let v2 = &constructor_writable_xmm_to_xmm_mem(ctx, v1);
    let v3 = &C::x64_movdqu_b_raw(ctx, v2, arg0);
    let v4 = constructor_emit_ret_xmm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 3838.
    return v4;
}

// Generated as internal constructor for term x64_movdqu_b_or_avx.
pub fn constructor_x64_movdqu_b_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
) -> Xmm {
    let v1 = C::has_avx(ctx);
    if v1 == true {
        let v2 = constructor_x64_vmovdqu_b(ctx, arg0);
        // Rule at <OUT_DIR>/assembler.isle line 3840.
        return v2;
    }
    let v3 = constructor_x64_movdqu_b(ctx, arg0);
    // Rule at <OUT_DIR>/assembler.isle line 3843.
    return v3;
}

// Generated as internal constructor for term x64_movdqu_b_mem.
pub fn constructor_x64_movdqu_b_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Xmm,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_xmm_mem(ctx, arg0);
    let v3 = &C::x64_movdqu_b_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 3845.
    return v4.clone();
}

// Generated as internal constructor for term x64_movdqu_b_mem_or_avx.
pub fn constructor_x64_movdqu_b_mem_or_avx<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Xmm,
) -> SideEffectNoResult {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = &constructor_x64_vmovdqu_b_mem(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 3847.
        return v3.clone();
    }
    let v4 = &constructor_x64_movdqu_b_mem(ctx, arg0, arg1);
    // Rule at <OUT_DIR>/assembler.isle line 3850.
    return v4.clone();
}

// Generated as internal constructor for term x64_vmovupd_a.
pub fn constructor_x64_vmovupd_a<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = &C::x64_vmovupd_a_raw(ctx, arg0);
    let v2 = constructor_emit_ret_xmm(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 3855.
    return v2;
}

// Generated as internal constructor for term x64_vmovupd_b.
pub fn constructor_x64_vmovupd_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
) -> Xmm {
    let v1 = C::temp_writable_xmm(ctx);
    let v2 = &constructor_writable_xmm_to_xmm_mem(ctx, v1);
    let v3 = &C::x64_vmovupd_b_raw(ctx, v2, arg0);
    let v4 = constructor_emit_ret_xmm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 3860.
    return v4;
}

// Generated as internal constructor for term x64_vmovupd_b_mem.
pub fn constructor_x64_vmovupd_b_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Xmm,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_xmm_mem(ctx, arg0);
    let v3 = &C::x64_vmovupd_b_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 3862.
    return v4.clone();
}

// Generated as internal constructor for term x64_vmovups_a.
pub fn constructor_x64_vmovups_a<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = &C::x64_vmovups_a_raw(ctx, arg0);
    let v2 = constructor_emit_ret_xmm(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 3867.
    return v2;
}

// Generated as internal constructor for term x64_vmovups_b.
pub fn constructor_x64_vmovups_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
) -> Xmm {
    let v1 = C::temp_writable_xmm(ctx);
    let v2 = &constructor_writable_xmm_to_xmm_mem(ctx, v1);
    let v3 = &C::x64_vmovups_b_raw(ctx, v2, arg0);
    let v4 = constructor_emit_ret_xmm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 3872.
    return v4;
}

// Generated as internal constructor for term x64_vmovups_b_mem.
pub fn constructor_x64_vmovups_b_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Xmm,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_xmm_mem(ctx, arg0);
    let v3 = &C::x64_vmovups_b_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 3874.
    return v4.clone();
}

// Generated as internal constructor for term x64_vmovdqu_a.
pub fn constructor_x64_vmovdqu_a<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = &C::x64_vmovdqu_a_raw(ctx, arg0);
    let v2 = constructor_emit_ret_xmm(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 3879.
    return v2;
}

// Generated as internal constructor for term x64_vmovdqu_b.
pub fn constructor_x64_vmovdqu_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
) -> Xmm {
    let v1 = C::temp_writable_xmm(ctx);
    let v2 = &constructor_writable_xmm_to_xmm_mem(ctx, v1);
    let v3 = &C::x64_vmovdqu_b_raw(ctx, v2, arg0);
    let v4 = constructor_emit_ret_xmm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 3884.
    return v4;
}

// Generated as internal constructor for term x64_vmovdqu_b_mem.
pub fn constructor_x64_vmovdqu_b_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Xmm,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_xmm_mem(ctx, arg0);
    let v3 = &C::x64_vmovdqu_b_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 3886.
    return v4.clone();
}

// Generated as internal constructor for term x64_pmovsxbw_a.
pub fn constructor_x64_pmovsxbw_a<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = &C::x64_pmovsxbw_a_raw(ctx, arg0);
    let v2 = constructor_emit_ret_xmm(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 3891.
    return v2;
}

// Generated as internal constructor for term x64_pmovsxbw_a_or_avx.
pub fn constructor_x64_pmovsxbw_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = C::has_avx(ctx);
    if v1 == true {
        let v2 = constructor_x64_vpmovsxbw_a(ctx, arg0);
        // Rule at <OUT_DIR>/assembler.isle line 3893.
        return v2;
    }
    let v3 = constructor_x64_pmovsxbw_a(ctx, arg0);
    // Rule at <OUT_DIR>/assembler.isle line 3896.
    return v3;
}

// Generated as internal constructor for term x64_pmovsxbd_a.
pub fn constructor_x64_pmovsxbd_a<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = &C::x64_pmovsxbd_a_raw(ctx, arg0);
    let v2 = constructor_emit_ret_xmm(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 3901.
    return v2;
}

// Generated as internal constructor for term x64_pmovsxbd_a_or_avx.
pub fn constructor_x64_pmovsxbd_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = C::has_avx(ctx);
    if v1 == true {
        let v2 = constructor_x64_vpmovsxbd_a(ctx, arg0);
        // Rule at <OUT_DIR>/assembler.isle line 3903.
        return v2;
    }
    let v3 = constructor_x64_pmovsxbd_a(ctx, arg0);
    // Rule at <OUT_DIR>/assembler.isle line 3906.
    return v3;
}

// Generated as internal constructor for term x64_pmovsxbq_a.
pub fn constructor_x64_pmovsxbq_a<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = &C::x64_pmovsxbq_a_raw(ctx, arg0);
    let v2 = constructor_emit_ret_xmm(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 3911.
    return v2;
}

// Generated as internal constructor for term x64_pmovsxbq_a_or_avx.
pub fn constructor_x64_pmovsxbq_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = C::has_avx(ctx);
    if v1 == true {
        let v2 = constructor_x64_vpmovsxbq_a(ctx, arg0);
        // Rule at <OUT_DIR>/assembler.isle line 3913.
        return v2;
    }
    let v3 = constructor_x64_pmovsxbq_a(ctx, arg0);
    // Rule at <OUT_DIR>/assembler.isle line 3916.
    return v3;
}

// Generated as internal constructor for term x64_pmovsxwd_a.
pub fn constructor_x64_pmovsxwd_a<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = &C::x64_pmovsxwd_a_raw(ctx, arg0);
    let v2 = constructor_emit_ret_xmm(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 3921.
    return v2;
}

// Generated as internal constructor for term x64_pmovsxwd_a_or_avx.
pub fn constructor_x64_pmovsxwd_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = C::has_avx(ctx);
    if v1 == true {
        let v2 = constructor_x64_vpmovsxwd_a(ctx, arg0);
        // Rule at <OUT_DIR>/assembler.isle line 3923.
        return v2;
    }
    let v3 = constructor_x64_pmovsxwd_a(ctx, arg0);
    // Rule at <OUT_DIR>/assembler.isle line 3926.
    return v3;
}

// Generated as internal constructor for term x64_pmovsxwq_a.
pub fn constructor_x64_pmovsxwq_a<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = &C::x64_pmovsxwq_a_raw(ctx, arg0);
    let v2 = constructor_emit_ret_xmm(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 3931.
    return v2;
}

// Generated as internal constructor for term x64_pmovsxwq_a_or_avx.
pub fn constructor_x64_pmovsxwq_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = C::has_avx(ctx);
    if v1 == true {
        let v2 = constructor_x64_vpmovsxwq_a(ctx, arg0);
        // Rule at <OUT_DIR>/assembler.isle line 3933.
        return v2;
    }
    let v3 = constructor_x64_pmovsxwq_a(ctx, arg0);
    // Rule at <OUT_DIR>/assembler.isle line 3936.
    return v3;
}

// Generated as internal constructor for term x64_pmovsxdq_a.
pub fn constructor_x64_pmovsxdq_a<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = &C::x64_pmovsxdq_a_raw(ctx, arg0);
    let v2 = constructor_emit_ret_xmm(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 3941.
    return v2;
}

// Generated as internal constructor for term x64_pmovsxdq_a_or_avx.
pub fn constructor_x64_pmovsxdq_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = C::has_avx(ctx);
    if v1 == true {
        let v2 = constructor_x64_vpmovsxdq_a(ctx, arg0);
        // Rule at <OUT_DIR>/assembler.isle line 3943.
        return v2;
    }
    let v3 = constructor_x64_pmovsxdq_a(ctx, arg0);
    // Rule at <OUT_DIR>/assembler.isle line 3946.
    return v3;
}

// Generated as internal constructor for term x64_vpmovsxbw_a.
pub fn constructor_x64_vpmovsxbw_a<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = &C::x64_vpmovsxbw_a_raw(ctx, arg0);
    let v2 = constructor_emit_ret_xmm(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 3951.
    return v2;
}

// Generated as internal constructor for term x64_vpmovsxbd_a.
pub fn constructor_x64_vpmovsxbd_a<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = &C::x64_vpmovsxbd_a_raw(ctx, arg0);
    let v2 = constructor_emit_ret_xmm(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 3956.
    return v2;
}

// Generated as internal constructor for term x64_vpmovsxbq_a.
pub fn constructor_x64_vpmovsxbq_a<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = &C::x64_vpmovsxbq_a_raw(ctx, arg0);
    let v2 = constructor_emit_ret_xmm(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 3961.
    return v2;
}

// Generated as internal constructor for term x64_vpmovsxwd_a.
pub fn constructor_x64_vpmovsxwd_a<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = &C::x64_vpmovsxwd_a_raw(ctx, arg0);
    let v2 = constructor_emit_ret_xmm(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 3966.
    return v2;
}

// Generated as internal constructor for term x64_vpmovsxwq_a.
pub fn constructor_x64_vpmovsxwq_a<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = &C::x64_vpmovsxwq_a_raw(ctx, arg0);
    let v2 = constructor_emit_ret_xmm(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 3971.
    return v2;
}

// Generated as internal constructor for term x64_vpmovsxdq_a.
pub fn constructor_x64_vpmovsxdq_a<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = &C::x64_vpmovsxdq_a_raw(ctx, arg0);
    let v2 = constructor_emit_ret_xmm(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 3976.
    return v2;
}

// Generated as internal constructor for term x64_pmovzxbw_a.
pub fn constructor_x64_pmovzxbw_a<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = &C::x64_pmovzxbw_a_raw(ctx, arg0);
    let v2 = constructor_emit_ret_xmm(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 3981.
    return v2;
}

// Generated as internal constructor for term x64_pmovzxbw_a_or_avx.
pub fn constructor_x64_pmovzxbw_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = C::has_avx(ctx);
    if v1 == true {
        let v2 = constructor_x64_vpmovzxbw_a(ctx, arg0);
        // Rule at <OUT_DIR>/assembler.isle line 3983.
        return v2;
    }
    let v3 = constructor_x64_pmovzxbw_a(ctx, arg0);
    // Rule at <OUT_DIR>/assembler.isle line 3986.
    return v3;
}

// Generated as internal constructor for term x64_pmovzxbd_a.
pub fn constructor_x64_pmovzxbd_a<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = &C::x64_pmovzxbd_a_raw(ctx, arg0);
    let v2 = constructor_emit_ret_xmm(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 3991.
    return v2;
}

// Generated as internal constructor for term x64_pmovzxbd_a_or_avx.
pub fn constructor_x64_pmovzxbd_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = C::has_avx(ctx);
    if v1 == true {
        let v2 = constructor_x64_vpmovzxbd_a(ctx, arg0);
        // Rule at <OUT_DIR>/assembler.isle line 3993.
        return v2;
    }
    let v3 = constructor_x64_pmovzxbd_a(ctx, arg0);
    // Rule at <OUT_DIR>/assembler.isle line 3996.
    return v3;
}

// Generated as internal constructor for term x64_pmovzxbq_a.
pub fn constructor_x64_pmovzxbq_a<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = &C::x64_pmovzxbq_a_raw(ctx, arg0);
    let v2 = constructor_emit_ret_xmm(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 4001.
    return v2;
}

// Generated as internal constructor for term x64_pmovzxbq_a_or_avx.
pub fn constructor_x64_pmovzxbq_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = C::has_avx(ctx);
    if v1 == true {
        let v2 = constructor_x64_vpmovzxbq_a(ctx, arg0);
        // Rule at <OUT_DIR>/assembler.isle line 4003.
        return v2;
    }
    let v3 = constructor_x64_pmovzxbq_a(ctx, arg0);
    // Rule at <OUT_DIR>/assembler.isle line 4006.
    return v3;
}

// Generated as internal constructor for term x64_pmovzxwd_a.
pub fn constructor_x64_pmovzxwd_a<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = &C::x64_pmovzxwd_a_raw(ctx, arg0);
    let v2 = constructor_emit_ret_xmm(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 4011.
    return v2;
}

// Generated as internal constructor for term x64_pmovzxwd_a_or_avx.
pub fn constructor_x64_pmovzxwd_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = C::has_avx(ctx);
    if v1 == true {
        let v2 = constructor_x64_vpmovzxwd_a(ctx, arg0);
        // Rule at <OUT_DIR>/assembler.isle line 4013.
        return v2;
    }
    let v3 = constructor_x64_pmovzxwd_a(ctx, arg0);
    // Rule at <OUT_DIR>/assembler.isle line 4016.
    return v3;
}

// Generated as internal constructor for term x64_pmovzxwq_a.
pub fn constructor_x64_pmovzxwq_a<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = &C::x64_pmovzxwq_a_raw(ctx, arg0);
    let v2 = constructor_emit_ret_xmm(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 4021.
    return v2;
}

// Generated as internal constructor for term x64_pmovzxwq_a_or_avx.
pub fn constructor_x64_pmovzxwq_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = C::has_avx(ctx);
    if v1 == true {
        let v2 = constructor_x64_vpmovzxwq_a(ctx, arg0);
        // Rule at <OUT_DIR>/assembler.isle line 4023.
        return v2;
    }
    let v3 = constructor_x64_pmovzxwq_a(ctx, arg0);
    // Rule at <OUT_DIR>/assembler.isle line 4026.
    return v3;
}

// Generated as internal constructor for term x64_pmovzxdq_a.
pub fn constructor_x64_pmovzxdq_a<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = &C::x64_pmovzxdq_a_raw(ctx, arg0);
    let v2 = constructor_emit_ret_xmm(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 4031.
    return v2;
}

// Generated as internal constructor for term x64_pmovzxdq_a_or_avx.
pub fn constructor_x64_pmovzxdq_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = C::has_avx(ctx);
    if v1 == true {
        let v2 = constructor_x64_vpmovzxdq_a(ctx, arg0);
        // Rule at <OUT_DIR>/assembler.isle line 4033.
        return v2;
    }
    let v3 = constructor_x64_pmovzxdq_a(ctx, arg0);
    // Rule at <OUT_DIR>/assembler.isle line 4036.
    return v3;
}

// Generated as internal constructor for term x64_vpmovzxbw_a.
pub fn constructor_x64_vpmovzxbw_a<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = &C::x64_vpmovzxbw_a_raw(ctx, arg0);
    let v2 = constructor_emit_ret_xmm(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 4041.
    return v2;
}

// Generated as internal constructor for term x64_vpmovzxbd_a.
pub fn constructor_x64_vpmovzxbd_a<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = &C::x64_vpmovzxbd_a_raw(ctx, arg0);
    let v2 = constructor_emit_ret_xmm(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 4046.
    return v2;
}

// Generated as internal constructor for term x64_vpmovzxbq_a.
pub fn constructor_x64_vpmovzxbq_a<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = &C::x64_vpmovzxbq_a_raw(ctx, arg0);
    let v2 = constructor_emit_ret_xmm(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 4051.
    return v2;
}

// Generated as internal constructor for term x64_vpmovzxwd_a.
pub fn constructor_x64_vpmovzxwd_a<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = &C::x64_vpmovzxwd_a_raw(ctx, arg0);
    let v2 = constructor_emit_ret_xmm(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 4056.
    return v2;
}

// Generated as internal constructor for term x64_vpmovzxwq_a.
pub fn constructor_x64_vpmovzxwq_a<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = &C::x64_vpmovzxwq_a_raw(ctx, arg0);
    let v2 = constructor_emit_ret_xmm(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 4061.
    return v2;
}

// Generated as internal constructor for term x64_vpmovzxdq_a.
pub fn constructor_x64_vpmovzxdq_a<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = &C::x64_vpmovzxdq_a_raw(ctx, arg0);
    let v2 = constructor_emit_ret_xmm(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 4066.
    return v2;
}

// Generated as internal constructor for term x64_mulb_m.
pub fn constructor_x64_mulb_m<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
) -> Gpr {
    let v2 = &C::x64_mulb_m_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4071.
    return v3;
}

// Generated as internal constructor for term x64_mulw_m.
pub fn constructor_x64_mulw_m<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
) -> ValueRegs {
    let v2 = &C::x64_mulw_m_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_value_regs(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4076.
    return v3;
}

// Generated as internal constructor for term x64_mull_m.
pub fn constructor_x64_mull_m<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
) -> ValueRegs {
    let v2 = &C::x64_mull_m_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_value_regs(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4081.
    return v3;
}

// Generated as internal constructor for term x64_mulq_m.
pub fn constructor_x64_mulq_m<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
) -> ValueRegs {
    let v2 = &C::x64_mulq_m_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_value_regs(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4086.
    return v3;
}

// Generated as internal constructor for term x64_imulb_m.
pub fn constructor_x64_imulb_m<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
) -> Gpr {
    let v2 = &C::x64_imulb_m_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4091.
    return v3;
}

// Generated as internal constructor for term x64_imulw_m.
pub fn constructor_x64_imulw_m<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
) -> ValueRegs {
    let v2 = &C::x64_imulw_m_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_value_regs(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4096.
    return v3;
}

// Generated as internal constructor for term x64_imull_m.
pub fn constructor_x64_imull_m<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
) -> ValueRegs {
    let v2 = &C::x64_imull_m_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_value_regs(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4101.
    return v3;
}

// Generated as internal constructor for term x64_imulq_m.
pub fn constructor_x64_imulq_m<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
) -> ValueRegs {
    let v2 = &C::x64_imulq_m_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_value_regs(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4106.
    return v3;
}

// Generated as internal constructor for term x64_imulw_rm.
pub fn constructor_x64_imulw_rm<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
) -> Gpr {
    let v2 = &C::x64_imulw_rm_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4111.
    return v3;
}

// Generated as internal constructor for term x64_imull_rm.
pub fn constructor_x64_imull_rm<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
) -> Gpr {
    let v2 = &C::x64_imull_rm_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4116.
    return v3;
}

// Generated as internal constructor for term x64_imulq_rm.
pub fn constructor_x64_imulq_rm<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
) -> Gpr {
    let v2 = &C::x64_imulq_rm_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4121.
    return v3;
}

// Generated as internal constructor for term x64_imulw_rmi_sxb.
pub fn constructor_x64_imulw_rmi_sxb<C: Context>(
    ctx: &mut C,
    arg0: &GprMem,
    arg1: i8,
) -> Gpr {
    let v2 = &C::x64_imulw_rmi_sxb_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4126.
    return v3;
}

// Generated as internal constructor for term x64_imull_rmi_sxb.
pub fn constructor_x64_imull_rmi_sxb<C: Context>(
    ctx: &mut C,
    arg0: &GprMem,
    arg1: i8,
) -> Gpr {
    let v2 = &C::x64_imull_rmi_sxb_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4131.
    return v3;
}

// Generated as internal constructor for term x64_imulq_rmi_sxb.
pub fn constructor_x64_imulq_rmi_sxb<C: Context>(
    ctx: &mut C,
    arg0: &GprMem,
    arg1: i8,
) -> Gpr {
    let v2 = &C::x64_imulq_rmi_sxb_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4136.
    return v3;
}

// Generated as internal constructor for term x64_imulw_rmi.
pub fn constructor_x64_imulw_rmi<C: Context>(
    ctx: &mut C,
    arg0: &GprMem,
    arg1: u16,
) -> Gpr {
    let v2 = &C::x64_imulw_rmi_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4141.
    return v3;
}

// Generated as internal constructor for term x64_imull_rmi.
pub fn constructor_x64_imull_rmi<C: Context>(
    ctx: &mut C,
    arg0: &GprMem,
    arg1: u32,
) -> Gpr {
    let v2 = &C::x64_imull_rmi_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4146.
    return v3;
}

// Generated as internal constructor for term x64_imulq_rmi_sxl.
pub fn constructor_x64_imulq_rmi_sxl<C: Context>(
    ctx: &mut C,
    arg0: &GprMem,
    arg1: i32,
) -> Gpr {
    let v2 = &C::x64_imulq_rmi_sxl_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4151.
    return v3;
}

// Generated as internal constructor for term x64_mulxl_rvm.
pub fn constructor_x64_mulxl_rvm<C: Context>(
    ctx: &mut C,
    arg0: &GprMem,
    arg1: Gpr,
) -> ValueRegs {
    let v2 = &C::x64_mulxl_rvm_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_value_regs(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4156.
    return v3;
}

// Generated as internal constructor for term x64_mulxq_rvm.
pub fn constructor_x64_mulxq_rvm<C: Context>(
    ctx: &mut C,
    arg0: &GprMem,
    arg1: Gpr,
) -> ValueRegs {
    let v2 = &C::x64_mulxq_rvm_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_value_regs(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4161.
    return v3;
}

// Generated as internal constructor for term x64_mulss_a.
pub fn constructor_x64_mulss_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_mulss_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4166.
    return v3;
}

// Generated as internal constructor for term x64_mulss_a_or_avx.
pub fn constructor_x64_mulss_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vmulss_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 4168.
        return v3;
    }
    let v4 = constructor_x64_mulss_a(ctx, arg0, arg1);
    // Rule at <OUT_DIR>/assembler.isle line 4171.
    return v4;
}

// Generated as internal constructor for term x64_mulsd_a.
pub fn constructor_x64_mulsd_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_mulsd_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4176.
    return v3;
}

// Generated as internal constructor for term x64_mulsd_a_or_avx.
pub fn constructor_x64_mulsd_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vmulsd_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 4178.
        return v3;
    }
    let v4 = constructor_x64_mulsd_a(ctx, arg0, arg1);
    // Rule at <OUT_DIR>/assembler.isle line 4181.
    return v4;
}

// Generated as internal constructor for term x64_mulps_a.
pub fn constructor_x64_mulps_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_mulps_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4186.
    return v3;
}

// Generated as internal constructor for term x64_mulps_a_or_avx.
pub fn constructor_x64_mulps_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vmulps_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 4188.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_mulps_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 4191.
    return v5;
}

// Generated as internal constructor for term x64_mulpd_a.
pub fn constructor_x64_mulpd_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_mulpd_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4196.
    return v3;
}

// Generated as internal constructor for term x64_mulpd_a_or_avx.
pub fn constructor_x64_mulpd_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vmulpd_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 4198.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_mulpd_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 4201.
    return v5;
}

// Generated as internal constructor for term x64_pmuldq_a.
pub fn constructor_x64_pmuldq_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_pmuldq_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4206.
    return v3;
}

// Generated as internal constructor for term x64_pmuldq_a_or_avx.
pub fn constructor_x64_pmuldq_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vpmuldq_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 4208.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_pmuldq_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 4211.
    return v5;
}

// Generated as internal constructor for term x64_pmulhrsw_a.
pub fn constructor_x64_pmulhrsw_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_pmulhrsw_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4216.
    return v3;
}

// Generated as internal constructor for term x64_pmulhrsw_a_or_avx.
pub fn constructor_x64_pmulhrsw_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vpmulhrsw_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 4218.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_pmulhrsw_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 4221.
    return v5;
}

// Generated as internal constructor for term x64_pmulhuw_a.
pub fn constructor_x64_pmulhuw_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_pmulhuw_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4226.
    return v3;
}

// Generated as internal constructor for term x64_pmulhuw_a_or_avx.
pub fn constructor_x64_pmulhuw_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vpmulhuw_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 4228.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_pmulhuw_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 4231.
    return v5;
}

// Generated as internal constructor for term x64_pmulhw_a.
pub fn constructor_x64_pmulhw_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_pmulhw_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4236.
    return v3;
}

// Generated as internal constructor for term x64_pmulhw_a_or_avx.
pub fn constructor_x64_pmulhw_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vpmulhw_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 4238.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_pmulhw_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 4241.
    return v5;
}

// Generated as internal constructor for term x64_pmulld_a.
pub fn constructor_x64_pmulld_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_pmulld_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4246.
    return v3;
}

// Generated as internal constructor for term x64_pmulld_a_or_avx.
pub fn constructor_x64_pmulld_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vpmulld_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 4248.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_pmulld_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 4251.
    return v5;
}

// Generated as internal constructor for term x64_pmullw_a.
pub fn constructor_x64_pmullw_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_pmullw_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4256.
    return v3;
}

// Generated as internal constructor for term x64_pmullw_a_or_avx.
pub fn constructor_x64_pmullw_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vpmullw_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 4258.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_pmullw_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 4261.
    return v5;
}

// Generated as internal constructor for term x64_pmuludq_a.
pub fn constructor_x64_pmuludq_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_pmuludq_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4266.
    return v3;
}

// Generated as internal constructor for term x64_pmuludq_a_or_avx.
pub fn constructor_x64_pmuludq_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vpmuludq_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 4268.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_pmuludq_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 4271.
    return v5;
}

// Generated as internal constructor for term x64_vmulss_b.
pub fn constructor_x64_vmulss_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vmulss_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4276.
    return v3;
}

// Generated as internal constructor for term x64_vmulsd_b.
pub fn constructor_x64_vmulsd_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vmulsd_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4281.
    return v3;
}

// Generated as internal constructor for term x64_vmulps_b.
pub fn constructor_x64_vmulps_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vmulps_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4286.
    return v3;
}

// Generated as internal constructor for term x64_vmulpd_b.
pub fn constructor_x64_vmulpd_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vmulpd_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4291.
    return v3;
}

// Generated as internal constructor for term x64_vpmuldq_b.
pub fn constructor_x64_vpmuldq_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vpmuldq_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4296.
    return v3;
}

// Generated as internal constructor for term x64_vpmulhrsw_b.
pub fn constructor_x64_vpmulhrsw_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vpmulhrsw_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4301.
    return v3;
}

// Generated as internal constructor for term x64_vpmulhuw_b.
pub fn constructor_x64_vpmulhuw_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vpmulhuw_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4306.
    return v3;
}

// Generated as internal constructor for term x64_vpmulhw_b.
pub fn constructor_x64_vpmulhw_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vpmulhw_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4311.
    return v3;
}

// Generated as internal constructor for term x64_vpmulld_b.
pub fn constructor_x64_vpmulld_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vpmulld_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4316.
    return v3;
}

// Generated as internal constructor for term x64_vpmullw_b.
pub fn constructor_x64_vpmullw_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vpmullw_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4321.
    return v3;
}

// Generated as internal constructor for term x64_vpmuludq_b.
pub fn constructor_x64_vpmuludq_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vpmuludq_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4326.
    return v3;
}

// Generated as internal constructor for term x64_vpmulld_c.
pub fn constructor_x64_vpmulld_c<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vpmulld_c_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4331.
    return v3;
}

// Generated as internal constructor for term x64_vpmullq_c.
pub fn constructor_x64_vpmullq_c<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vpmullq_c_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4336.
    return v3;
}

// Generated as internal constructor for term x64_negb_m.
pub fn constructor_x64_negb_m<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
) -> Gpr {
    let v1 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v2 = &C::x64_negb_m_raw(ctx, v1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4341.
    return v3;
}

// Generated as internal constructor for term x64_negb_m_mem.
pub fn constructor_x64_negb_m_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
) -> SideEffectNoResult {
    let v1 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v2 = &C::x64_negb_m_raw(ctx, v1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4343.
    return v3.clone();
}

// Generated as internal constructor for term x64_negw_m.
pub fn constructor_x64_negw_m<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
) -> Gpr {
    let v1 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v2 = &C::x64_negw_m_raw(ctx, v1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4348.
    return v3;
}

// Generated as internal constructor for term x64_negw_m_mem.
pub fn constructor_x64_negw_m_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
) -> SideEffectNoResult {
    let v1 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v2 = &C::x64_negw_m_raw(ctx, v1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4350.
    return v3.clone();
}

// Generated as internal constructor for term x64_negl_m.
pub fn constructor_x64_negl_m<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
) -> Gpr {
    let v1 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v2 = &C::x64_negl_m_raw(ctx, v1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4355.
    return v3;
}

// Generated as internal constructor for term x64_negl_m_mem.
pub fn constructor_x64_negl_m_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
) -> SideEffectNoResult {
    let v1 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v2 = &C::x64_negl_m_raw(ctx, v1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4357.
    return v3.clone();
}

// Generated as internal constructor for term x64_negq_m.
pub fn constructor_x64_negq_m<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
) -> Gpr {
    let v1 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v2 = &C::x64_negq_m_raw(ctx, v1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4362.
    return v3;
}

// Generated as internal constructor for term x64_negq_m_mem.
pub fn constructor_x64_negq_m_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
) -> SideEffectNoResult {
    let v1 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v2 = &C::x64_negq_m_raw(ctx, v1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4364.
    return v3.clone();
}

// Generated as internal constructor for term x64_notb_m.
pub fn constructor_x64_notb_m<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
) -> Gpr {
    let v1 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v2 = &C::x64_notb_m_raw(ctx, v1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4369.
    return v3;
}

// Generated as internal constructor for term x64_notb_m_mem.
pub fn constructor_x64_notb_m_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
) -> SideEffectNoResult {
    let v1 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v2 = &C::x64_notb_m_raw(ctx, v1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4371.
    return v3.clone();
}

// Generated as internal constructor for term x64_notw_m.
pub fn constructor_x64_notw_m<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
) -> Gpr {
    let v1 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v2 = &C::x64_notw_m_raw(ctx, v1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4376.
    return v3;
}

// Generated as internal constructor for term x64_notw_m_mem.
pub fn constructor_x64_notw_m_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
) -> SideEffectNoResult {
    let v1 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v2 = &C::x64_notw_m_raw(ctx, v1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4378.
    return v3.clone();
}

// Generated as internal constructor for term x64_notl_m.
pub fn constructor_x64_notl_m<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
) -> Gpr {
    let v1 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v2 = &C::x64_notl_m_raw(ctx, v1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4383.
    return v3;
}

// Generated as internal constructor for term x64_notl_m_mem.
pub fn constructor_x64_notl_m_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
) -> SideEffectNoResult {
    let v1 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v2 = &C::x64_notl_m_raw(ctx, v1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4385.
    return v3.clone();
}

// Generated as internal constructor for term x64_notq_m.
pub fn constructor_x64_notq_m<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
) -> Gpr {
    let v1 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v2 = &C::x64_notq_m_raw(ctx, v1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4390.
    return v3;
}

// Generated as internal constructor for term x64_notq_m_mem.
pub fn constructor_x64_notq_m_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
) -> SideEffectNoResult {
    let v1 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v2 = &C::x64_notq_m_raw(ctx, v1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4392.
    return v3.clone();
}

// Generated as internal constructor for term x64_nop_zo.
pub fn constructor_x64_nop_zo<C: Context>(
    ctx: &mut C,
) -> SideEffectNoResult {
    let v0 = &C::x64_nop_zo_raw(ctx);
    let v1 = &constructor_defer_side_effect(ctx, v0);
    // Rule at <OUT_DIR>/assembler.isle line 4397.
    return v1.clone();
}

// Generated as internal constructor for term x64_nopl_m.
pub fn constructor_x64_nopl_m<C: Context>(
    ctx: &mut C,
    arg0: &GprMem,
) -> SideEffectNoResult {
    let v1 = &C::x64_nopl_m_raw(ctx, arg0);
    let v2 = &constructor_defer_side_effect(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 4402.
    return v2.clone();
}

// Generated as internal constructor for term x64_nop_1b.
pub fn constructor_x64_nop_1b<C: Context>(
    ctx: &mut C,
) -> SideEffectNoResult {
    let v0 = &C::x64_nop_1b_raw(ctx);
    let v1 = &constructor_defer_side_effect(ctx, v0);
    // Rule at <OUT_DIR>/assembler.isle line 4407.
    return v1.clone();
}

// Generated as internal constructor for term x64_nop_2b.
pub fn constructor_x64_nop_2b<C: Context>(
    ctx: &mut C,
) -> SideEffectNoResult {
    let v0 = &C::x64_nop_2b_raw(ctx);
    let v1 = &constructor_defer_side_effect(ctx, v0);
    // Rule at <OUT_DIR>/assembler.isle line 4412.
    return v1.clone();
}

// Generated as internal constructor for term x64_nop_3b.
pub fn constructor_x64_nop_3b<C: Context>(
    ctx: &mut C,
) -> SideEffectNoResult {
    let v0 = &C::x64_nop_3b_raw(ctx);
    let v1 = &constructor_defer_side_effect(ctx, v0);
    // Rule at <OUT_DIR>/assembler.isle line 4417.
    return v1.clone();
}

// Generated as internal constructor for term x64_nop_4b.
pub fn constructor_x64_nop_4b<C: Context>(
    ctx: &mut C,
) -> SideEffectNoResult {
    let v0 = &C::x64_nop_4b_raw(ctx);
    let v1 = &constructor_defer_side_effect(ctx, v0);
    // Rule at <OUT_DIR>/assembler.isle line 4422.
    return v1.clone();
}

// Generated as internal constructor for term x64_nop_5b.
pub fn constructor_x64_nop_5b<C: Context>(
    ctx: &mut C,
) -> SideEffectNoResult {
    let v0 = &C::x64_nop_5b_raw(ctx);
    let v1 = &constructor_defer_side_effect(ctx, v0);
    // Rule at <OUT_DIR>/assembler.isle line 4427.
    return v1.clone();
}

// Generated as internal constructor for term x64_nop_6b.
pub fn constructor_x64_nop_6b<C: Context>(
    ctx: &mut C,
) -> SideEffectNoResult {
    let v0 = &C::x64_nop_6b_raw(ctx);
    let v1 = &constructor_defer_side_effect(ctx, v0);
    // Rule at <OUT_DIR>/assembler.isle line 4432.
    return v1.clone();
}

// Generated as internal constructor for term x64_nop_7b.
pub fn constructor_x64_nop_7b<C: Context>(
    ctx: &mut C,
) -> SideEffectNoResult {
    let v0 = &C::x64_nop_7b_raw(ctx);
    let v1 = &constructor_defer_side_effect(ctx, v0);
    // Rule at <OUT_DIR>/assembler.isle line 4437.
    return v1.clone();
}

// Generated as internal constructor for term x64_nop_8b.
pub fn constructor_x64_nop_8b<C: Context>(
    ctx: &mut C,
) -> SideEffectNoResult {
    let v0 = &C::x64_nop_8b_raw(ctx);
    let v1 = &constructor_defer_side_effect(ctx, v0);
    // Rule at <OUT_DIR>/assembler.isle line 4442.
    return v1.clone();
}

// Generated as internal constructor for term x64_nop_9b.
pub fn constructor_x64_nop_9b<C: Context>(
    ctx: &mut C,
) -> SideEffectNoResult {
    let v0 = &C::x64_nop_9b_raw(ctx);
    let v1 = &constructor_defer_side_effect(ctx, v0);
    // Rule at <OUT_DIR>/assembler.isle line 4447.
    return v1.clone();
}

// Generated as internal constructor for term x64_orb_i.
pub fn constructor_x64_orb_i<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: u8,
) -> Gpr {
    let v2 = &C::x64_orb_i_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4452.
    return v3;
}

// Generated as internal constructor for term x64_orw_i.
pub fn constructor_x64_orw_i<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: u16,
) -> Gpr {
    let v2 = &C::x64_orw_i_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4457.
    return v3;
}

// Generated as internal constructor for term x64_orl_i.
pub fn constructor_x64_orl_i<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: u32,
) -> Gpr {
    let v2 = &C::x64_orl_i_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4462.
    return v3;
}

// Generated as internal constructor for term x64_orq_i_sxl.
pub fn constructor_x64_orq_i_sxl<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: i32,
) -> Gpr {
    let v2 = &C::x64_orq_i_sxl_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4467.
    return v3;
}

// Generated as internal constructor for term x64_orb_mi.
pub fn constructor_x64_orb_mi<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: u8,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_orb_mi_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 4472.
    return v4;
}

// Generated as internal constructor for term x64_orb_mi_mem.
pub fn constructor_x64_orb_mi_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: u8,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_orb_mi_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 4474.
    return v4.clone();
}

// Generated as internal constructor for term x64_orw_mi.
pub fn constructor_x64_orw_mi<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: u16,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_orw_mi_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 4479.
    return v4;
}

// Generated as internal constructor for term x64_orw_mi_mem.
pub fn constructor_x64_orw_mi_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: u16,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_orw_mi_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 4481.
    return v4.clone();
}

// Generated as internal constructor for term x64_orl_mi.
pub fn constructor_x64_orl_mi<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: u32,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_orl_mi_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 4486.
    return v4;
}

// Generated as internal constructor for term x64_orl_mi_mem.
pub fn constructor_x64_orl_mi_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: u32,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_orl_mi_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 4488.
    return v4.clone();
}

// Generated as internal constructor for term x64_orq_mi_sxl.
pub fn constructor_x64_orq_mi_sxl<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: i32,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_orq_mi_sxl_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 4493.
    return v4;
}

// Generated as internal constructor for term x64_orq_mi_sxl_mem.
pub fn constructor_x64_orq_mi_sxl_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: i32,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_orq_mi_sxl_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 4495.
    return v4.clone();
}

// Generated as internal constructor for term x64_orl_mi_sxb.
pub fn constructor_x64_orl_mi_sxb<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: i8,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_orl_mi_sxb_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 4500.
    return v4;
}

// Generated as internal constructor for term x64_orl_mi_sxb_mem.
pub fn constructor_x64_orl_mi_sxb_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: i8,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_orl_mi_sxb_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 4502.
    return v4.clone();
}

// Generated as internal constructor for term x64_orq_mi_sxb.
pub fn constructor_x64_orq_mi_sxb<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: i8,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_orq_mi_sxb_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 4507.
    return v4;
}

// Generated as internal constructor for term x64_orq_mi_sxb_mem.
pub fn constructor_x64_orq_mi_sxb_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: i8,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_orq_mi_sxb_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 4509.
    return v4.clone();
}

// Generated as internal constructor for term x64_orb_mr.
pub fn constructor_x64_orb_mr<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: Gpr,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_orb_mr_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 4514.
    return v4;
}

// Generated as internal constructor for term x64_orb_mr_mem.
pub fn constructor_x64_orb_mr_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Gpr,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_orb_mr_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 4516.
    return v4.clone();
}

// Generated as internal constructor for term x64_orw_mr.
pub fn constructor_x64_orw_mr<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: Gpr,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_orw_mr_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 4521.
    return v4;
}

// Generated as internal constructor for term x64_orw_mr_mem.
pub fn constructor_x64_orw_mr_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Gpr,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_orw_mr_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 4523.
    return v4.clone();
}

// Generated as internal constructor for term x64_orl_mr.
pub fn constructor_x64_orl_mr<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: Gpr,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_orl_mr_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 4528.
    return v4;
}

// Generated as internal constructor for term x64_orl_mr_mem.
pub fn constructor_x64_orl_mr_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Gpr,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_orl_mr_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 4530.
    return v4.clone();
}

// Generated as internal constructor for term x64_orq_mr.
pub fn constructor_x64_orq_mr<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: Gpr,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_orq_mr_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 4535.
    return v4;
}

// Generated as internal constructor for term x64_orq_mr_mem.
pub fn constructor_x64_orq_mr_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Gpr,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_orq_mr_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 4537.
    return v4.clone();
}

// Generated as internal constructor for term x64_orb_rm.
pub fn constructor_x64_orb_rm<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
) -> Gpr {
    let v2 = &C::x64_orb_rm_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4542.
    return v3;
}

// Generated as internal constructor for term x64_orw_rm.
pub fn constructor_x64_orw_rm<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
) -> Gpr {
    let v2 = &C::x64_orw_rm_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4547.
    return v3;
}

// Generated as internal constructor for term x64_orl_rm.
pub fn constructor_x64_orl_rm<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
) -> Gpr {
    let v2 = &C::x64_orl_rm_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4552.
    return v3;
}

// Generated as internal constructor for term x64_orq_rm.
pub fn constructor_x64_orq_rm<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
) -> Gpr {
    let v2 = &C::x64_orq_rm_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4557.
    return v3;
}

// Generated as internal constructor for term x64_lock_orb_mi_mem.
pub fn constructor_x64_lock_orb_mi_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: u8,
) -> SideEffectNoResult {
    let v2 = &C::x64_lock_orb_mi_raw(ctx, arg0, arg1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4562.
    return v3.clone();
}

// Generated as internal constructor for term x64_lock_orw_mi_mem.
pub fn constructor_x64_lock_orw_mi_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: u16,
) -> SideEffectNoResult {
    let v2 = &C::x64_lock_orw_mi_raw(ctx, arg0, arg1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4567.
    return v3.clone();
}

// Generated as internal constructor for term x64_lock_orl_mi_mem.
pub fn constructor_x64_lock_orl_mi_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: u32,
) -> SideEffectNoResult {
    let v2 = &C::x64_lock_orl_mi_raw(ctx, arg0, arg1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4572.
    return v3.clone();
}

// Generated as internal constructor for term x64_lock_orq_mi_sxl_mem.
pub fn constructor_x64_lock_orq_mi_sxl_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: i32,
) -> SideEffectNoResult {
    let v2 = &C::x64_lock_orq_mi_sxl_raw(ctx, arg0, arg1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4577.
    return v3.clone();
}

// Generated as internal constructor for term x64_lock_orl_mi_sxb_mem.
pub fn constructor_x64_lock_orl_mi_sxb_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: i8,
) -> SideEffectNoResult {
    let v2 = &C::x64_lock_orl_mi_sxb_raw(ctx, arg0, arg1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4582.
    return v3.clone();
}

// Generated as internal constructor for term x64_lock_orq_mi_sxb_mem.
pub fn constructor_x64_lock_orq_mi_sxb_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: i8,
) -> SideEffectNoResult {
    let v2 = &C::x64_lock_orq_mi_sxb_raw(ctx, arg0, arg1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4587.
    return v3.clone();
}

// Generated as internal constructor for term x64_lock_orb_mr_mem.
pub fn constructor_x64_lock_orb_mr_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Gpr,
) -> SideEffectNoResult {
    let v2 = &C::x64_lock_orb_mr_raw(ctx, arg0, arg1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4592.
    return v3.clone();
}

// Generated as internal constructor for term x64_lock_orw_mr_mem.
pub fn constructor_x64_lock_orw_mr_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Gpr,
) -> SideEffectNoResult {
    let v2 = &C::x64_lock_orw_mr_raw(ctx, arg0, arg1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4597.
    return v3.clone();
}

// Generated as internal constructor for term x64_lock_orl_mr_mem.
pub fn constructor_x64_lock_orl_mr_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Gpr,
) -> SideEffectNoResult {
    let v2 = &C::x64_lock_orl_mr_raw(ctx, arg0, arg1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4602.
    return v3.clone();
}

// Generated as internal constructor for term x64_lock_orq_mr_mem.
pub fn constructor_x64_lock_orq_mr_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Gpr,
) -> SideEffectNoResult {
    let v2 = &C::x64_lock_orq_mr_raw(ctx, arg0, arg1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4607.
    return v3.clone();
}

// Generated as internal constructor for term x64_orps_a.
pub fn constructor_x64_orps_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_orps_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4612.
    return v3;
}

// Generated as internal constructor for term x64_orps_a_or_avx.
pub fn constructor_x64_orps_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vorps_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 4614.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_orps_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 4617.
    return v5;
}

// Generated as internal constructor for term x64_orpd_a.
pub fn constructor_x64_orpd_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_orpd_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4622.
    return v3;
}

// Generated as internal constructor for term x64_orpd_a_or_avx.
pub fn constructor_x64_orpd_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vorpd_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 4624.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_orpd_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 4627.
    return v5;
}

// Generated as internal constructor for term x64_por_a.
pub fn constructor_x64_por_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_por_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4632.
    return v3;
}

// Generated as internal constructor for term x64_por_a_or_avx.
pub fn constructor_x64_por_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vpor_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 4634.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_por_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 4637.
    return v5;
}

// Generated as internal constructor for term x64_vorps_b.
pub fn constructor_x64_vorps_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vorps_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4642.
    return v3;
}

// Generated as internal constructor for term x64_vorpd_b.
pub fn constructor_x64_vorpd_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vorpd_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4647.
    return v3;
}

// Generated as internal constructor for term x64_vpor_b.
pub fn constructor_x64_vpor_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vpor_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4652.
    return v3;
}

// Generated as internal constructor for term x64_packsswb_a.
pub fn constructor_x64_packsswb_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_packsswb_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4657.
    return v3;
}

// Generated as internal constructor for term x64_packsswb_a_or_avx.
pub fn constructor_x64_packsswb_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vpacksswb_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 4659.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_packsswb_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 4662.
    return v5;
}

// Generated as internal constructor for term x64_packssdw_a.
pub fn constructor_x64_packssdw_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_packssdw_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4667.
    return v3;
}

// Generated as internal constructor for term x64_packssdw_a_or_avx.
pub fn constructor_x64_packssdw_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vpackssdw_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 4669.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_packssdw_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 4672.
    return v5;
}

// Generated as internal constructor for term x64_vpacksswb_b.
pub fn constructor_x64_vpacksswb_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vpacksswb_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4677.
    return v3;
}

// Generated as internal constructor for term x64_vpackssdw_b.
pub fn constructor_x64_vpackssdw_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vpackssdw_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4682.
    return v3;
}

// Generated as internal constructor for term x64_packuswb_a.
pub fn constructor_x64_packuswb_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_packuswb_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4687.
    return v3;
}

// Generated as internal constructor for term x64_packuswb_a_or_avx.
pub fn constructor_x64_packuswb_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vpackuswb_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 4689.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_packuswb_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 4692.
    return v5;
}

// Generated as internal constructor for term x64_packusdw_a.
pub fn constructor_x64_packusdw_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_packusdw_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4697.
    return v3;
}

// Generated as internal constructor for term x64_packusdw_a_or_avx.
pub fn constructor_x64_packusdw_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vpackusdw_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 4699.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_packusdw_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 4702.
    return v5;
}

// Generated as internal constructor for term x64_vpackuswb_b.
pub fn constructor_x64_vpackuswb_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vpackuswb_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4707.
    return v3;
}

// Generated as internal constructor for term x64_vpackusdw_b.
pub fn constructor_x64_vpackusdw_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vpackusdw_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4712.
    return v3;
}

// Generated as internal constructor for term x64_pmaddwd_a.
pub fn constructor_x64_pmaddwd_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_pmaddwd_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4717.
    return v3;
}

// Generated as internal constructor for term x64_pmaddwd_a_or_avx.
pub fn constructor_x64_pmaddwd_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vpmaddwd_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 4719.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_pmaddwd_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 4722.
    return v5;
}

// Generated as internal constructor for term x64_vpmaddwd_b.
pub fn constructor_x64_vpmaddwd_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vpmaddwd_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4727.
    return v3;
}

// Generated as internal constructor for term x64_pmaddubsw_a.
pub fn constructor_x64_pmaddubsw_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_pmaddubsw_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4732.
    return v3;
}

// Generated as internal constructor for term x64_pmaddubsw_a_or_avx.
pub fn constructor_x64_pmaddubsw_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vpmaddubsw_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 4734.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_pmaddubsw_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 4737.
    return v5;
}

// Generated as internal constructor for term x64_vpmaddubsw_b.
pub fn constructor_x64_vpmaddubsw_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vpmaddubsw_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4742.
    return v3;
}

// Generated as internal constructor for term x64_rcpps_rm.
pub fn constructor_x64_rcpps_rm<C: Context>(
    ctx: &mut C,
    arg0: &XmmMemAligned,
) -> Xmm {
    let v1 = &C::x64_rcpps_rm_raw(ctx, arg0);
    let v2 = constructor_emit_ret_xmm(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 4747.
    return v2;
}

// Generated as internal constructor for term x64_rcpps_rm_or_avx.
pub fn constructor_x64_rcpps_rm_or_avx<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = C::has_avx(ctx);
    if v1 == true {
        let v2 = constructor_x64_vrcpps_rm(ctx, arg0);
        // Rule at <OUT_DIR>/assembler.isle line 4749.
        return v2;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg0);
    let v4 = constructor_x64_rcpps_rm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 4752.
    return v4;
}

// Generated as internal constructor for term x64_rcpss_rm.
pub fn constructor_x64_rcpss_rm<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = &C::x64_rcpss_rm_raw(ctx, arg0);
    let v2 = constructor_emit_ret_xmm(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 4757.
    return v2;
}

// Generated as internal constructor for term x64_rsqrtps_rm.
pub fn constructor_x64_rsqrtps_rm<C: Context>(
    ctx: &mut C,
    arg0: &XmmMemAligned,
) -> Xmm {
    let v1 = &C::x64_rsqrtps_rm_raw(ctx, arg0);
    let v2 = constructor_emit_ret_xmm(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 4762.
    return v2;
}

// Generated as internal constructor for term x64_rsqrtps_rm_or_avx.
pub fn constructor_x64_rsqrtps_rm_or_avx<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = C::has_avx(ctx);
    if v1 == true {
        let v2 = constructor_x64_vrsqrtps_rm(ctx, arg0);
        // Rule at <OUT_DIR>/assembler.isle line 4764.
        return v2;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg0);
    let v4 = constructor_x64_rsqrtps_rm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 4767.
    return v4;
}

// Generated as internal constructor for term x64_rsqrtss_rm.
pub fn constructor_x64_rsqrtss_rm<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = &C::x64_rsqrtss_rm_raw(ctx, arg0);
    let v2 = constructor_emit_ret_xmm(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 4772.
    return v2;
}

// Generated as internal constructor for term x64_vrcpps_rm.
pub fn constructor_x64_vrcpps_rm<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = &C::x64_vrcpps_rm_raw(ctx, arg0);
    let v2 = constructor_emit_ret_xmm(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 4777.
    return v2;
}

// Generated as internal constructor for term x64_vrcpss_rvm.
pub fn constructor_x64_vrcpss_rvm<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vrcpss_rvm_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4782.
    return v3;
}

// Generated as internal constructor for term x64_vrsqrtps_rm.
pub fn constructor_x64_vrsqrtps_rm<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = &C::x64_vrsqrtps_rm_raw(ctx, arg0);
    let v2 = constructor_emit_ret_xmm(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 4787.
    return v2;
}

// Generated as internal constructor for term x64_vrsqrtss_rvm.
pub fn constructor_x64_vrsqrtss_rvm<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vrsqrtss_rvm_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4792.
    return v3;
}

// Generated as internal constructor for term x64_roundpd_rmi.
pub fn constructor_x64_roundpd_rmi<C: Context>(
    ctx: &mut C,
    arg0: &XmmMemAligned,
    arg1: u8,
) -> Xmm {
    let v2 = &C::x64_roundpd_rmi_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4797.
    return v3;
}

// Generated as internal constructor for term x64_roundps_rmi.
pub fn constructor_x64_roundps_rmi<C: Context>(
    ctx: &mut C,
    arg0: &XmmMemAligned,
    arg1: u8,
) -> Xmm {
    let v2 = &C::x64_roundps_rmi_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4802.
    return v3;
}

// Generated as internal constructor for term x64_roundsd_rmi.
pub fn constructor_x64_roundsd_rmi<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
    arg1: u8,
) -> Xmm {
    let v2 = &C::x64_roundsd_rmi_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4807.
    return v3;
}

// Generated as internal constructor for term x64_roundss_rmi.
pub fn constructor_x64_roundss_rmi<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
    arg1: u8,
) -> Xmm {
    let v2 = &C::x64_roundss_rmi_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4812.
    return v3;
}

// Generated as internal constructor for term x64_vroundpd_rmi.
pub fn constructor_x64_vroundpd_rmi<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
    arg1: u8,
) -> Xmm {
    let v2 = &C::x64_vroundpd_rmi_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4817.
    return v3;
}

// Generated as internal constructor for term x64_vroundps_rmi.
pub fn constructor_x64_vroundps_rmi<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
    arg1: u8,
) -> Xmm {
    let v2 = &C::x64_vroundps_rmi_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4822.
    return v3;
}

// Generated as internal constructor for term x64_vroundsd_rvmi.
pub fn constructor_x64_vroundsd_rvmi<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
    arg2: u8,
) -> Xmm {
    let v3 = &C::x64_vroundsd_rvmi_raw(ctx, arg0, arg1, arg2);
    let v4 = constructor_emit_ret_xmm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 4827.
    return v4;
}

// Generated as internal constructor for term x64_vroundss_rvmi.
pub fn constructor_x64_vroundss_rvmi<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
    arg2: u8,
) -> Xmm {
    let v3 = &C::x64_vroundss_rvmi_raw(ctx, arg0, arg1, arg2);
    let v4 = constructor_emit_ret_xmm(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 4832.
    return v4;
}

// Generated as internal constructor for term x64_seta_m.
pub fn constructor_x64_seta_m<C: Context>(
    ctx: &mut C,
) -> ConsumesFlags {
    let v0 = C::temp_writable_gpr(ctx);
    let v1 = &constructor_writable_gpr_to_gpr_mem(ctx, v0);
    let v2 = &C::x64_seta_m_raw(ctx, v1);
    let v3 = &constructor_asm_consumes_flags_returns_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4837.
    return v3.clone();
}

// Generated as internal constructor for term x64_setae_m.
pub fn constructor_x64_setae_m<C: Context>(
    ctx: &mut C,
) -> ConsumesFlags {
    let v0 = C::temp_writable_gpr(ctx);
    let v1 = &constructor_writable_gpr_to_gpr_mem(ctx, v0);
    let v2 = &C::x64_setae_m_raw(ctx, v1);
    let v3 = &constructor_asm_consumes_flags_returns_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4842.
    return v3.clone();
}

// Generated as internal constructor for term x64_setb_m.
pub fn constructor_x64_setb_m<C: Context>(
    ctx: &mut C,
) -> ConsumesFlags {
    let v0 = C::temp_writable_gpr(ctx);
    let v1 = &constructor_writable_gpr_to_gpr_mem(ctx, v0);
    let v2 = &C::x64_setb_m_raw(ctx, v1);
    let v3 = &constructor_asm_consumes_flags_returns_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4847.
    return v3.clone();
}

// Generated as internal constructor for term x64_setbe_m.
pub fn constructor_x64_setbe_m<C: Context>(
    ctx: &mut C,
) -> ConsumesFlags {
    let v0 = C::temp_writable_gpr(ctx);
    let v1 = &constructor_writable_gpr_to_gpr_mem(ctx, v0);
    let v2 = &C::x64_setbe_m_raw(ctx, v1);
    let v3 = &constructor_asm_consumes_flags_returns_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4852.
    return v3.clone();
}

// Generated as internal constructor for term x64_sete_m.
pub fn constructor_x64_sete_m<C: Context>(
    ctx: &mut C,
) -> ConsumesFlags {
    let v0 = C::temp_writable_gpr(ctx);
    let v1 = &constructor_writable_gpr_to_gpr_mem(ctx, v0);
    let v2 = &C::x64_sete_m_raw(ctx, v1);
    let v3 = &constructor_asm_consumes_flags_returns_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4857.
    return v3.clone();
}

// Generated as internal constructor for term x64_setg_m.
pub fn constructor_x64_setg_m<C: Context>(
    ctx: &mut C,
) -> ConsumesFlags {
    let v0 = C::temp_writable_gpr(ctx);
    let v1 = &constructor_writable_gpr_to_gpr_mem(ctx, v0);
    let v2 = &C::x64_setg_m_raw(ctx, v1);
    let v3 = &constructor_asm_consumes_flags_returns_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4862.
    return v3.clone();
}

// Generated as internal constructor for term x64_setge_m.
pub fn constructor_x64_setge_m<C: Context>(
    ctx: &mut C,
) -> ConsumesFlags {
    let v0 = C::temp_writable_gpr(ctx);
    let v1 = &constructor_writable_gpr_to_gpr_mem(ctx, v0);
    let v2 = &C::x64_setge_m_raw(ctx, v1);
    let v3 = &constructor_asm_consumes_flags_returns_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4867.
    return v3.clone();
}

// Generated as internal constructor for term x64_setl_m.
pub fn constructor_x64_setl_m<C: Context>(
    ctx: &mut C,
) -> ConsumesFlags {
    let v0 = C::temp_writable_gpr(ctx);
    let v1 = &constructor_writable_gpr_to_gpr_mem(ctx, v0);
    let v2 = &C::x64_setl_m_raw(ctx, v1);
    let v3 = &constructor_asm_consumes_flags_returns_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4872.
    return v3.clone();
}

// Generated as internal constructor for term x64_setle_m.
pub fn constructor_x64_setle_m<C: Context>(
    ctx: &mut C,
) -> ConsumesFlags {
    let v0 = C::temp_writable_gpr(ctx);
    let v1 = &constructor_writable_gpr_to_gpr_mem(ctx, v0);
    let v2 = &C::x64_setle_m_raw(ctx, v1);
    let v3 = &constructor_asm_consumes_flags_returns_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4877.
    return v3.clone();
}

// Generated as internal constructor for term x64_setne_m.
pub fn constructor_x64_setne_m<C: Context>(
    ctx: &mut C,
) -> ConsumesFlags {
    let v0 = C::temp_writable_gpr(ctx);
    let v1 = &constructor_writable_gpr_to_gpr_mem(ctx, v0);
    let v2 = &C::x64_setne_m_raw(ctx, v1);
    let v3 = &constructor_asm_consumes_flags_returns_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4882.
    return v3.clone();
}

// Generated as internal constructor for term x64_setno_m.
pub fn constructor_x64_setno_m<C: Context>(
    ctx: &mut C,
) -> ConsumesFlags {
    let v0 = C::temp_writable_gpr(ctx);
    let v1 = &constructor_writable_gpr_to_gpr_mem(ctx, v0);
    let v2 = &C::x64_setno_m_raw(ctx, v1);
    let v3 = &constructor_asm_consumes_flags_returns_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4887.
    return v3.clone();
}

// Generated as internal constructor for term x64_setnp_m.
pub fn constructor_x64_setnp_m<C: Context>(
    ctx: &mut C,
) -> ConsumesFlags {
    let v0 = C::temp_writable_gpr(ctx);
    let v1 = &constructor_writable_gpr_to_gpr_mem(ctx, v0);
    let v2 = &C::x64_setnp_m_raw(ctx, v1);
    let v3 = &constructor_asm_consumes_flags_returns_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4892.
    return v3.clone();
}

// Generated as internal constructor for term x64_setns_m.
pub fn constructor_x64_setns_m<C: Context>(
    ctx: &mut C,
) -> ConsumesFlags {
    let v0 = C::temp_writable_gpr(ctx);
    let v1 = &constructor_writable_gpr_to_gpr_mem(ctx, v0);
    let v2 = &C::x64_setns_m_raw(ctx, v1);
    let v3 = &constructor_asm_consumes_flags_returns_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4897.
    return v3.clone();
}

// Generated as internal constructor for term x64_seto_m.
pub fn constructor_x64_seto_m<C: Context>(
    ctx: &mut C,
) -> ConsumesFlags {
    let v0 = C::temp_writable_gpr(ctx);
    let v1 = &constructor_writable_gpr_to_gpr_mem(ctx, v0);
    let v2 = &C::x64_seto_m_raw(ctx, v1);
    let v3 = &constructor_asm_consumes_flags_returns_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4902.
    return v3.clone();
}

// Generated as internal constructor for term x64_setp_m.
pub fn constructor_x64_setp_m<C: Context>(
    ctx: &mut C,
) -> ConsumesFlags {
    let v0 = C::temp_writable_gpr(ctx);
    let v1 = &constructor_writable_gpr_to_gpr_mem(ctx, v0);
    let v2 = &C::x64_setp_m_raw(ctx, v1);
    let v3 = &constructor_asm_consumes_flags_returns_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4907.
    return v3.clone();
}

// Generated as internal constructor for term x64_sets_m.
pub fn constructor_x64_sets_m<C: Context>(
    ctx: &mut C,
) -> ConsumesFlags {
    let v0 = C::temp_writable_gpr(ctx);
    let v1 = &constructor_writable_gpr_to_gpr_mem(ctx, v0);
    let v2 = &C::x64_sets_m_raw(ctx, v1);
    let v3 = &constructor_asm_consumes_flags_returns_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4912.
    return v3.clone();
}

// Generated as internal constructor for term x64_sarb_mc.
pub fn constructor_x64_sarb_mc<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: Gpr,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_sarb_mc_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 4917.
    return v4;
}

// Generated as internal constructor for term x64_sarb_mc_mem.
pub fn constructor_x64_sarb_mc_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Gpr,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_sarb_mc_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 4919.
    return v4.clone();
}

// Generated as internal constructor for term x64_sarb_mi.
pub fn constructor_x64_sarb_mi<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: u8,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_sarb_mi_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 4924.
    return v4;
}

// Generated as internal constructor for term x64_sarb_mi_mem.
pub fn constructor_x64_sarb_mi_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: u8,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_sarb_mi_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 4926.
    return v4.clone();
}

// Generated as internal constructor for term x64_sarb_m1.
pub fn constructor_x64_sarb_m1<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
) -> Gpr {
    let v1 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v2 = &C::x64_sarb_m1_raw(ctx, v1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4931.
    return v3;
}

// Generated as internal constructor for term x64_sarb_m1_mem.
pub fn constructor_x64_sarb_m1_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
) -> SideEffectNoResult {
    let v1 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v2 = &C::x64_sarb_m1_raw(ctx, v1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4933.
    return v3.clone();
}

// Generated as internal constructor for term x64_sarw_mc.
pub fn constructor_x64_sarw_mc<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: Gpr,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_sarw_mc_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 4938.
    return v4;
}

// Generated as internal constructor for term x64_sarw_mc_mem.
pub fn constructor_x64_sarw_mc_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Gpr,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_sarw_mc_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 4940.
    return v4.clone();
}

// Generated as internal constructor for term x64_sarw_mi.
pub fn constructor_x64_sarw_mi<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: u8,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_sarw_mi_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 4945.
    return v4;
}

// Generated as internal constructor for term x64_sarw_mi_mem.
pub fn constructor_x64_sarw_mi_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: u8,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_sarw_mi_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 4947.
    return v4.clone();
}

// Generated as internal constructor for term x64_sarw_m1.
pub fn constructor_x64_sarw_m1<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
) -> Gpr {
    let v1 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v2 = &C::x64_sarw_m1_raw(ctx, v1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4952.
    return v3;
}

// Generated as internal constructor for term x64_sarw_m1_mem.
pub fn constructor_x64_sarw_m1_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
) -> SideEffectNoResult {
    let v1 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v2 = &C::x64_sarw_m1_raw(ctx, v1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4954.
    return v3.clone();
}

// Generated as internal constructor for term x64_sarl_mc.
pub fn constructor_x64_sarl_mc<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: Gpr,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_sarl_mc_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 4959.
    return v4;
}

// Generated as internal constructor for term x64_sarl_mc_mem.
pub fn constructor_x64_sarl_mc_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Gpr,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_sarl_mc_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 4961.
    return v4.clone();
}

// Generated as internal constructor for term x64_sarl_mi.
pub fn constructor_x64_sarl_mi<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: u8,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_sarl_mi_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 4966.
    return v4;
}

// Generated as internal constructor for term x64_sarl_mi_mem.
pub fn constructor_x64_sarl_mi_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: u8,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_sarl_mi_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 4968.
    return v4.clone();
}

// Generated as internal constructor for term x64_sarl_m1.
pub fn constructor_x64_sarl_m1<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
) -> Gpr {
    let v1 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v2 = &C::x64_sarl_m1_raw(ctx, v1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4973.
    return v3;
}

// Generated as internal constructor for term x64_sarl_m1_mem.
pub fn constructor_x64_sarl_m1_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
) -> SideEffectNoResult {
    let v1 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v2 = &C::x64_sarl_m1_raw(ctx, v1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4975.
    return v3.clone();
}

// Generated as internal constructor for term x64_sarq_mc.
pub fn constructor_x64_sarq_mc<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: Gpr,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_sarq_mc_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 4980.
    return v4;
}

// Generated as internal constructor for term x64_sarq_mc_mem.
pub fn constructor_x64_sarq_mc_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Gpr,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_sarq_mc_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 4982.
    return v4.clone();
}

// Generated as internal constructor for term x64_sarq_mi.
pub fn constructor_x64_sarq_mi<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: u8,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_sarq_mi_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 4987.
    return v4;
}

// Generated as internal constructor for term x64_sarq_mi_mem.
pub fn constructor_x64_sarq_mi_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: u8,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_sarq_mi_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 4989.
    return v4.clone();
}

// Generated as internal constructor for term x64_sarq_m1.
pub fn constructor_x64_sarq_m1<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
) -> Gpr {
    let v1 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v2 = &C::x64_sarq_m1_raw(ctx, v1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4994.
    return v3;
}

// Generated as internal constructor for term x64_sarq_m1_mem.
pub fn constructor_x64_sarq_m1_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
) -> SideEffectNoResult {
    let v1 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v2 = &C::x64_sarq_m1_raw(ctx, v1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 4996.
    return v3.clone();
}

// Generated as internal constructor for term x64_shlb_mc.
pub fn constructor_x64_shlb_mc<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: Gpr,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_shlb_mc_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5001.
    return v4;
}

// Generated as internal constructor for term x64_shlb_mc_mem.
pub fn constructor_x64_shlb_mc_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Gpr,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_shlb_mc_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5003.
    return v4.clone();
}

// Generated as internal constructor for term x64_shlb_mi.
pub fn constructor_x64_shlb_mi<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: u8,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_shlb_mi_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5008.
    return v4;
}

// Generated as internal constructor for term x64_shlb_mi_mem.
pub fn constructor_x64_shlb_mi_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: u8,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_shlb_mi_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5010.
    return v4.clone();
}

// Generated as internal constructor for term x64_shlb_m1.
pub fn constructor_x64_shlb_m1<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
) -> Gpr {
    let v1 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v2 = &C::x64_shlb_m1_raw(ctx, v1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5015.
    return v3;
}

// Generated as internal constructor for term x64_shlb_m1_mem.
pub fn constructor_x64_shlb_m1_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
) -> SideEffectNoResult {
    let v1 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v2 = &C::x64_shlb_m1_raw(ctx, v1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5017.
    return v3.clone();
}

// Generated as internal constructor for term x64_shlw_mc.
pub fn constructor_x64_shlw_mc<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: Gpr,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_shlw_mc_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5022.
    return v4;
}

// Generated as internal constructor for term x64_shlw_mc_mem.
pub fn constructor_x64_shlw_mc_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Gpr,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_shlw_mc_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5024.
    return v4.clone();
}

// Generated as internal constructor for term x64_shlw_mi.
pub fn constructor_x64_shlw_mi<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: u8,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_shlw_mi_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5029.
    return v4;
}

// Generated as internal constructor for term x64_shlw_mi_mem.
pub fn constructor_x64_shlw_mi_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: u8,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_shlw_mi_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5031.
    return v4.clone();
}

// Generated as internal constructor for term x64_shlw_m1.
pub fn constructor_x64_shlw_m1<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
) -> Gpr {
    let v1 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v2 = &C::x64_shlw_m1_raw(ctx, v1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5036.
    return v3;
}

// Generated as internal constructor for term x64_shlw_m1_mem.
pub fn constructor_x64_shlw_m1_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
) -> SideEffectNoResult {
    let v1 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v2 = &C::x64_shlw_m1_raw(ctx, v1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5038.
    return v3.clone();
}

// Generated as internal constructor for term x64_shll_mc.
pub fn constructor_x64_shll_mc<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: Gpr,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_shll_mc_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5043.
    return v4;
}

// Generated as internal constructor for term x64_shll_mc_mem.
pub fn constructor_x64_shll_mc_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Gpr,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_shll_mc_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5045.
    return v4.clone();
}

// Generated as internal constructor for term x64_shll_mi.
pub fn constructor_x64_shll_mi<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: u8,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_shll_mi_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5050.
    return v4;
}

// Generated as internal constructor for term x64_shll_mi_mem.
pub fn constructor_x64_shll_mi_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: u8,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_shll_mi_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5052.
    return v4.clone();
}

// Generated as internal constructor for term x64_shll_m1.
pub fn constructor_x64_shll_m1<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
) -> Gpr {
    let v1 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v2 = &C::x64_shll_m1_raw(ctx, v1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5057.
    return v3;
}

// Generated as internal constructor for term x64_shll_m1_mem.
pub fn constructor_x64_shll_m1_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
) -> SideEffectNoResult {
    let v1 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v2 = &C::x64_shll_m1_raw(ctx, v1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5059.
    return v3.clone();
}

// Generated as internal constructor for term x64_shlq_mc.
pub fn constructor_x64_shlq_mc<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: Gpr,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_shlq_mc_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5064.
    return v4;
}

// Generated as internal constructor for term x64_shlq_mc_mem.
pub fn constructor_x64_shlq_mc_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Gpr,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_shlq_mc_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5066.
    return v4.clone();
}

// Generated as internal constructor for term x64_shlq_mi.
pub fn constructor_x64_shlq_mi<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: u8,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_shlq_mi_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5071.
    return v4;
}

// Generated as internal constructor for term x64_shlq_mi_mem.
pub fn constructor_x64_shlq_mi_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: u8,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_shlq_mi_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5073.
    return v4.clone();
}

// Generated as internal constructor for term x64_shlq_m1.
pub fn constructor_x64_shlq_m1<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
) -> Gpr {
    let v1 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v2 = &C::x64_shlq_m1_raw(ctx, v1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5078.
    return v3;
}

// Generated as internal constructor for term x64_shlq_m1_mem.
pub fn constructor_x64_shlq_m1_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
) -> SideEffectNoResult {
    let v1 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v2 = &C::x64_shlq_m1_raw(ctx, v1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5080.
    return v3.clone();
}

// Generated as internal constructor for term x64_shrb_mc.
pub fn constructor_x64_shrb_mc<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: Gpr,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_shrb_mc_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5085.
    return v4;
}

// Generated as internal constructor for term x64_shrb_mc_mem.
pub fn constructor_x64_shrb_mc_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Gpr,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_shrb_mc_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5087.
    return v4.clone();
}

// Generated as internal constructor for term x64_shrb_mi.
pub fn constructor_x64_shrb_mi<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: u8,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_shrb_mi_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5092.
    return v4;
}

// Generated as internal constructor for term x64_shrb_mi_mem.
pub fn constructor_x64_shrb_mi_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: u8,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_shrb_mi_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5094.
    return v4.clone();
}

// Generated as internal constructor for term x64_shrb_m1.
pub fn constructor_x64_shrb_m1<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
) -> Gpr {
    let v1 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v2 = &C::x64_shrb_m1_raw(ctx, v1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5099.
    return v3;
}

// Generated as internal constructor for term x64_shrb_m1_mem.
pub fn constructor_x64_shrb_m1_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
) -> SideEffectNoResult {
    let v1 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v2 = &C::x64_shrb_m1_raw(ctx, v1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5101.
    return v3.clone();
}

// Generated as internal constructor for term x64_shrw_mc.
pub fn constructor_x64_shrw_mc<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: Gpr,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_shrw_mc_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5106.
    return v4;
}

// Generated as internal constructor for term x64_shrw_mc_mem.
pub fn constructor_x64_shrw_mc_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Gpr,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_shrw_mc_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5108.
    return v4.clone();
}

// Generated as internal constructor for term x64_shrw_mi.
pub fn constructor_x64_shrw_mi<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: u8,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_shrw_mi_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5113.
    return v4;
}

// Generated as internal constructor for term x64_shrw_mi_mem.
pub fn constructor_x64_shrw_mi_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: u8,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_shrw_mi_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5115.
    return v4.clone();
}

// Generated as internal constructor for term x64_shrw_m1.
pub fn constructor_x64_shrw_m1<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
) -> Gpr {
    let v1 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v2 = &C::x64_shrw_m1_raw(ctx, v1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5120.
    return v3;
}

// Generated as internal constructor for term x64_shrw_m1_mem.
pub fn constructor_x64_shrw_m1_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
) -> SideEffectNoResult {
    let v1 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v2 = &C::x64_shrw_m1_raw(ctx, v1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5122.
    return v3.clone();
}

// Generated as internal constructor for term x64_shrl_mc.
pub fn constructor_x64_shrl_mc<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: Gpr,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_shrl_mc_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5127.
    return v4;
}

// Generated as internal constructor for term x64_shrl_mc_mem.
pub fn constructor_x64_shrl_mc_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Gpr,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_shrl_mc_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5129.
    return v4.clone();
}

// Generated as internal constructor for term x64_shrl_mi.
pub fn constructor_x64_shrl_mi<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: u8,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_shrl_mi_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5134.
    return v4;
}

// Generated as internal constructor for term x64_shrl_mi_mem.
pub fn constructor_x64_shrl_mi_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: u8,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_shrl_mi_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5136.
    return v4.clone();
}

// Generated as internal constructor for term x64_shrl_m1.
pub fn constructor_x64_shrl_m1<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
) -> Gpr {
    let v1 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v2 = &C::x64_shrl_m1_raw(ctx, v1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5141.
    return v3;
}

// Generated as internal constructor for term x64_shrl_m1_mem.
pub fn constructor_x64_shrl_m1_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
) -> SideEffectNoResult {
    let v1 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v2 = &C::x64_shrl_m1_raw(ctx, v1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5143.
    return v3.clone();
}

// Generated as internal constructor for term x64_shrq_mc.
pub fn constructor_x64_shrq_mc<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: Gpr,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_shrq_mc_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5148.
    return v4;
}

// Generated as internal constructor for term x64_shrq_mc_mem.
pub fn constructor_x64_shrq_mc_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Gpr,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_shrq_mc_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5150.
    return v4.clone();
}

// Generated as internal constructor for term x64_shrq_mi.
pub fn constructor_x64_shrq_mi<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: u8,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_shrq_mi_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5155.
    return v4;
}

// Generated as internal constructor for term x64_shrq_mi_mem.
pub fn constructor_x64_shrq_mi_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: u8,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_shrq_mi_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5157.
    return v4.clone();
}

// Generated as internal constructor for term x64_shrq_m1.
pub fn constructor_x64_shrq_m1<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
) -> Gpr {
    let v1 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v2 = &C::x64_shrq_m1_raw(ctx, v1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5162.
    return v3;
}

// Generated as internal constructor for term x64_shrq_m1_mem.
pub fn constructor_x64_shrq_m1_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
) -> SideEffectNoResult {
    let v1 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v2 = &C::x64_shrq_m1_raw(ctx, v1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5164.
    return v3.clone();
}

// Generated as internal constructor for term x64_rolb_mc.
pub fn constructor_x64_rolb_mc<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: Gpr,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_rolb_mc_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5169.
    return v4;
}

// Generated as internal constructor for term x64_rolb_mc_mem.
pub fn constructor_x64_rolb_mc_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Gpr,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_rolb_mc_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5171.
    return v4.clone();
}

// Generated as internal constructor for term x64_rolb_mi.
pub fn constructor_x64_rolb_mi<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: u8,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_rolb_mi_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5176.
    return v4;
}

// Generated as internal constructor for term x64_rolb_mi_mem.
pub fn constructor_x64_rolb_mi_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: u8,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_rolb_mi_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5178.
    return v4.clone();
}

// Generated as internal constructor for term x64_rolb_m1.
pub fn constructor_x64_rolb_m1<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
) -> Gpr {
    let v1 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v2 = &C::x64_rolb_m1_raw(ctx, v1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5183.
    return v3;
}

// Generated as internal constructor for term x64_rolb_m1_mem.
pub fn constructor_x64_rolb_m1_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
) -> SideEffectNoResult {
    let v1 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v2 = &C::x64_rolb_m1_raw(ctx, v1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5185.
    return v3.clone();
}

// Generated as internal constructor for term x64_rolw_mc.
pub fn constructor_x64_rolw_mc<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: Gpr,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_rolw_mc_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5190.
    return v4;
}

// Generated as internal constructor for term x64_rolw_mc_mem.
pub fn constructor_x64_rolw_mc_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Gpr,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_rolw_mc_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5192.
    return v4.clone();
}

// Generated as internal constructor for term x64_rolw_mi.
pub fn constructor_x64_rolw_mi<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: u8,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_rolw_mi_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5197.
    return v4;
}

// Generated as internal constructor for term x64_rolw_mi_mem.
pub fn constructor_x64_rolw_mi_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: u8,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_rolw_mi_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5199.
    return v4.clone();
}

// Generated as internal constructor for term x64_rolw_m1.
pub fn constructor_x64_rolw_m1<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
) -> Gpr {
    let v1 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v2 = &C::x64_rolw_m1_raw(ctx, v1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5204.
    return v3;
}

// Generated as internal constructor for term x64_rolw_m1_mem.
pub fn constructor_x64_rolw_m1_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
) -> SideEffectNoResult {
    let v1 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v2 = &C::x64_rolw_m1_raw(ctx, v1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5206.
    return v3.clone();
}

// Generated as internal constructor for term x64_roll_mc.
pub fn constructor_x64_roll_mc<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: Gpr,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_roll_mc_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5211.
    return v4;
}

// Generated as internal constructor for term x64_roll_mc_mem.
pub fn constructor_x64_roll_mc_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Gpr,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_roll_mc_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5213.
    return v4.clone();
}

// Generated as internal constructor for term x64_roll_mi.
pub fn constructor_x64_roll_mi<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: u8,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_roll_mi_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5218.
    return v4;
}

// Generated as internal constructor for term x64_roll_mi_mem.
pub fn constructor_x64_roll_mi_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: u8,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_roll_mi_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5220.
    return v4.clone();
}

// Generated as internal constructor for term x64_roll_m1.
pub fn constructor_x64_roll_m1<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
) -> Gpr {
    let v1 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v2 = &C::x64_roll_m1_raw(ctx, v1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5225.
    return v3;
}

// Generated as internal constructor for term x64_roll_m1_mem.
pub fn constructor_x64_roll_m1_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
) -> SideEffectNoResult {
    let v1 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v2 = &C::x64_roll_m1_raw(ctx, v1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5227.
    return v3.clone();
}

// Generated as internal constructor for term x64_rolq_mc.
pub fn constructor_x64_rolq_mc<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: Gpr,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_rolq_mc_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5232.
    return v4;
}

// Generated as internal constructor for term x64_rolq_mc_mem.
pub fn constructor_x64_rolq_mc_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Gpr,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_rolq_mc_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5234.
    return v4.clone();
}

// Generated as internal constructor for term x64_rolq_mi.
pub fn constructor_x64_rolq_mi<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: u8,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_rolq_mi_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5239.
    return v4;
}

// Generated as internal constructor for term x64_rolq_mi_mem.
pub fn constructor_x64_rolq_mi_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: u8,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_rolq_mi_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5241.
    return v4.clone();
}

// Generated as internal constructor for term x64_rolq_m1.
pub fn constructor_x64_rolq_m1<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
) -> Gpr {
    let v1 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v2 = &C::x64_rolq_m1_raw(ctx, v1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5246.
    return v3;
}

// Generated as internal constructor for term x64_rolq_m1_mem.
pub fn constructor_x64_rolq_m1_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
) -> SideEffectNoResult {
    let v1 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v2 = &C::x64_rolq_m1_raw(ctx, v1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5248.
    return v3.clone();
}

// Generated as internal constructor for term x64_rorb_mc.
pub fn constructor_x64_rorb_mc<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: Gpr,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_rorb_mc_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5253.
    return v4;
}

// Generated as internal constructor for term x64_rorb_mc_mem.
pub fn constructor_x64_rorb_mc_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Gpr,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_rorb_mc_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5255.
    return v4.clone();
}

// Generated as internal constructor for term x64_rorb_mi.
pub fn constructor_x64_rorb_mi<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: u8,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_rorb_mi_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5260.
    return v4;
}

// Generated as internal constructor for term x64_rorb_mi_mem.
pub fn constructor_x64_rorb_mi_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: u8,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_rorb_mi_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5262.
    return v4.clone();
}

// Generated as internal constructor for term x64_rorb_m1.
pub fn constructor_x64_rorb_m1<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
) -> Gpr {
    let v1 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v2 = &C::x64_rorb_m1_raw(ctx, v1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5267.
    return v3;
}

// Generated as internal constructor for term x64_rorb_m1_mem.
pub fn constructor_x64_rorb_m1_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
) -> SideEffectNoResult {
    let v1 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v2 = &C::x64_rorb_m1_raw(ctx, v1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5269.
    return v3.clone();
}

// Generated as internal constructor for term x64_rorw_mc.
pub fn constructor_x64_rorw_mc<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: Gpr,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_rorw_mc_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5274.
    return v4;
}

// Generated as internal constructor for term x64_rorw_mc_mem.
pub fn constructor_x64_rorw_mc_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Gpr,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_rorw_mc_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5276.
    return v4.clone();
}

// Generated as internal constructor for term x64_rorw_mi.
pub fn constructor_x64_rorw_mi<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: u8,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_rorw_mi_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5281.
    return v4;
}

// Generated as internal constructor for term x64_rorw_mi_mem.
pub fn constructor_x64_rorw_mi_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: u8,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_rorw_mi_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5283.
    return v4.clone();
}

// Generated as internal constructor for term x64_rorw_m1.
pub fn constructor_x64_rorw_m1<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
) -> Gpr {
    let v1 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v2 = &C::x64_rorw_m1_raw(ctx, v1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5288.
    return v3;
}

// Generated as internal constructor for term x64_rorw_m1_mem.
pub fn constructor_x64_rorw_m1_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
) -> SideEffectNoResult {
    let v1 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v2 = &C::x64_rorw_m1_raw(ctx, v1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5290.
    return v3.clone();
}

// Generated as internal constructor for term x64_rorl_mc.
pub fn constructor_x64_rorl_mc<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: Gpr,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_rorl_mc_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5295.
    return v4;
}

// Generated as internal constructor for term x64_rorl_mc_mem.
pub fn constructor_x64_rorl_mc_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Gpr,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_rorl_mc_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5297.
    return v4.clone();
}

// Generated as internal constructor for term x64_rorl_mi.
pub fn constructor_x64_rorl_mi<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: u8,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_rorl_mi_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5302.
    return v4;
}

// Generated as internal constructor for term x64_rorl_mi_mem.
pub fn constructor_x64_rorl_mi_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: u8,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_rorl_mi_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5304.
    return v4.clone();
}

// Generated as internal constructor for term x64_rorl_m1.
pub fn constructor_x64_rorl_m1<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
) -> Gpr {
    let v1 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v2 = &C::x64_rorl_m1_raw(ctx, v1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5309.
    return v3;
}

// Generated as internal constructor for term x64_rorl_m1_mem.
pub fn constructor_x64_rorl_m1_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
) -> SideEffectNoResult {
    let v1 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v2 = &C::x64_rorl_m1_raw(ctx, v1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5311.
    return v3.clone();
}

// Generated as internal constructor for term x64_rorq_mc.
pub fn constructor_x64_rorq_mc<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: Gpr,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_rorq_mc_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5316.
    return v4;
}

// Generated as internal constructor for term x64_rorq_mc_mem.
pub fn constructor_x64_rorq_mc_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Gpr,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_rorq_mc_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5318.
    return v4.clone();
}

// Generated as internal constructor for term x64_rorq_mi.
pub fn constructor_x64_rorq_mi<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: u8,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_rorq_mi_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5323.
    return v4;
}

// Generated as internal constructor for term x64_rorq_mi_mem.
pub fn constructor_x64_rorq_mi_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: u8,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_rorq_mi_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5325.
    return v4.clone();
}

// Generated as internal constructor for term x64_rorq_m1.
pub fn constructor_x64_rorq_m1<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
) -> Gpr {
    let v1 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v2 = &C::x64_rorq_m1_raw(ctx, v1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5330.
    return v3;
}

// Generated as internal constructor for term x64_rorq_m1_mem.
pub fn constructor_x64_rorq_m1_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
) -> SideEffectNoResult {
    let v1 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v2 = &C::x64_rorq_m1_raw(ctx, v1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5332.
    return v3.clone();
}

// Generated as internal constructor for term x64_shldw_mri.
pub fn constructor_x64_shldw_mri<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: Gpr,
    arg2: u8,
) -> Gpr {
    let v3 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v4 = &C::x64_shldw_mri_raw(ctx, v3, arg1, arg2);
    let v5 = constructor_emit_ret_gpr(ctx, v4);
    // Rule at <OUT_DIR>/assembler.isle line 5337.
    return v5;
}

// Generated as internal constructor for term x64_shldw_mri_mem.
pub fn constructor_x64_shldw_mri_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Gpr,
    arg2: u8,
) -> SideEffectNoResult {
    let v3 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v4 = &C::x64_shldw_mri_raw(ctx, v3, arg1, arg2);
    let v5 = &constructor_defer_side_effect(ctx, v4);
    // Rule at <OUT_DIR>/assembler.isle line 5339.
    return v5.clone();
}

// Generated as internal constructor for term x64_shldw_mrc.
pub fn constructor_x64_shldw_mrc<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: Gpr,
    arg2: Gpr,
) -> Gpr {
    let v3 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v4 = &C::x64_shldw_mrc_raw(ctx, v3, arg1, arg2);
    let v5 = constructor_emit_ret_gpr(ctx, v4);
    // Rule at <OUT_DIR>/assembler.isle line 5344.
    return v5;
}

// Generated as internal constructor for term x64_shldw_mrc_mem.
pub fn constructor_x64_shldw_mrc_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Gpr,
    arg2: Gpr,
) -> SideEffectNoResult {
    let v3 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v4 = &C::x64_shldw_mrc_raw(ctx, v3, arg1, arg2);
    let v5 = &constructor_defer_side_effect(ctx, v4);
    // Rule at <OUT_DIR>/assembler.isle line 5346.
    return v5.clone();
}

// Generated as internal constructor for term x64_shldl_mri.
pub fn constructor_x64_shldl_mri<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: Gpr,
    arg2: u8,
) -> Gpr {
    let v3 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v4 = &C::x64_shldl_mri_raw(ctx, v3, arg1, arg2);
    let v5 = constructor_emit_ret_gpr(ctx, v4);
    // Rule at <OUT_DIR>/assembler.isle line 5351.
    return v5;
}

// Generated as internal constructor for term x64_shldl_mri_mem.
pub fn constructor_x64_shldl_mri_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Gpr,
    arg2: u8,
) -> SideEffectNoResult {
    let v3 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v4 = &C::x64_shldl_mri_raw(ctx, v3, arg1, arg2);
    let v5 = &constructor_defer_side_effect(ctx, v4);
    // Rule at <OUT_DIR>/assembler.isle line 5353.
    return v5.clone();
}

// Generated as internal constructor for term x64_shldq_mri.
pub fn constructor_x64_shldq_mri<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: Gpr,
    arg2: u8,
) -> Gpr {
    let v3 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v4 = &C::x64_shldq_mri_raw(ctx, v3, arg1, arg2);
    let v5 = constructor_emit_ret_gpr(ctx, v4);
    // Rule at <OUT_DIR>/assembler.isle line 5358.
    return v5;
}

// Generated as internal constructor for term x64_shldq_mri_mem.
pub fn constructor_x64_shldq_mri_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Gpr,
    arg2: u8,
) -> SideEffectNoResult {
    let v3 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v4 = &C::x64_shldq_mri_raw(ctx, v3, arg1, arg2);
    let v5 = &constructor_defer_side_effect(ctx, v4);
    // Rule at <OUT_DIR>/assembler.isle line 5360.
    return v5.clone();
}

// Generated as internal constructor for term x64_shldl_mrc.
pub fn constructor_x64_shldl_mrc<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: Gpr,
    arg2: Gpr,
) -> Gpr {
    let v3 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v4 = &C::x64_shldl_mrc_raw(ctx, v3, arg1, arg2);
    let v5 = constructor_emit_ret_gpr(ctx, v4);
    // Rule at <OUT_DIR>/assembler.isle line 5365.
    return v5;
}

// Generated as internal constructor for term x64_shldl_mrc_mem.
pub fn constructor_x64_shldl_mrc_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Gpr,
    arg2: Gpr,
) -> SideEffectNoResult {
    let v3 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v4 = &C::x64_shldl_mrc_raw(ctx, v3, arg1, arg2);
    let v5 = &constructor_defer_side_effect(ctx, v4);
    // Rule at <OUT_DIR>/assembler.isle line 5367.
    return v5.clone();
}

// Generated as internal constructor for term x64_shldq_mrc.
pub fn constructor_x64_shldq_mrc<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: Gpr,
    arg2: Gpr,
) -> Gpr {
    let v3 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v4 = &C::x64_shldq_mrc_raw(ctx, v3, arg1, arg2);
    let v5 = constructor_emit_ret_gpr(ctx, v4);
    // Rule at <OUT_DIR>/assembler.isle line 5372.
    return v5;
}

// Generated as internal constructor for term x64_shldq_mrc_mem.
pub fn constructor_x64_shldq_mrc_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Gpr,
    arg2: Gpr,
) -> SideEffectNoResult {
    let v3 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v4 = &C::x64_shldq_mrc_raw(ctx, v3, arg1, arg2);
    let v5 = &constructor_defer_side_effect(ctx, v4);
    // Rule at <OUT_DIR>/assembler.isle line 5374.
    return v5.clone();
}

// Generated as internal constructor for term x64_sarxl_rmv.
pub fn constructor_x64_sarxl_rmv<C: Context>(
    ctx: &mut C,
    arg0: &GprMem,
    arg1: Gpr,
) -> Gpr {
    let v2 = &C::x64_sarxl_rmv_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5379.
    return v3;
}

// Generated as internal constructor for term x64_shlxl_rmv.
pub fn constructor_x64_shlxl_rmv<C: Context>(
    ctx: &mut C,
    arg0: &GprMem,
    arg1: Gpr,
) -> Gpr {
    let v2 = &C::x64_shlxl_rmv_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5384.
    return v3;
}

// Generated as internal constructor for term x64_shrxl_rmv.
pub fn constructor_x64_shrxl_rmv<C: Context>(
    ctx: &mut C,
    arg0: &GprMem,
    arg1: Gpr,
) -> Gpr {
    let v2 = &C::x64_shrxl_rmv_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5389.
    return v3;
}

// Generated as internal constructor for term x64_sarxq_rmv.
pub fn constructor_x64_sarxq_rmv<C: Context>(
    ctx: &mut C,
    arg0: &GprMem,
    arg1: Gpr,
) -> Gpr {
    let v2 = &C::x64_sarxq_rmv_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5394.
    return v3;
}

// Generated as internal constructor for term x64_shlxq_rmv.
pub fn constructor_x64_shlxq_rmv<C: Context>(
    ctx: &mut C,
    arg0: &GprMem,
    arg1: Gpr,
) -> Gpr {
    let v2 = &C::x64_shlxq_rmv_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5399.
    return v3;
}

// Generated as internal constructor for term x64_shrxq_rmv.
pub fn constructor_x64_shrxq_rmv<C: Context>(
    ctx: &mut C,
    arg0: &GprMem,
    arg1: Gpr,
) -> Gpr {
    let v2 = &C::x64_shrxq_rmv_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5404.
    return v3;
}

// Generated as internal constructor for term x64_rorxl_rmi.
pub fn constructor_x64_rorxl_rmi<C: Context>(
    ctx: &mut C,
    arg0: &GprMem,
    arg1: u8,
) -> Gpr {
    let v2 = &C::x64_rorxl_rmi_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5409.
    return v3;
}

// Generated as internal constructor for term x64_rorxq_rmi.
pub fn constructor_x64_rorxq_rmi<C: Context>(
    ctx: &mut C,
    arg0: &GprMem,
    arg1: u8,
) -> Gpr {
    let v2 = &C::x64_rorxq_rmi_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5414.
    return v3;
}

// Generated as internal constructor for term x64_psllw_a.
pub fn constructor_x64_psllw_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_psllw_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5419.
    return v3;
}

// Generated as internal constructor for term x64_psllw_a_or_avx.
pub fn constructor_x64_psllw_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vpsllw_c(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 5421.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_psllw_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 5424.
    return v5;
}

// Generated as internal constructor for term x64_psllw_b.
pub fn constructor_x64_psllw_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: u8,
) -> Xmm {
    let v2 = &C::x64_psllw_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5429.
    return v3;
}

// Generated as internal constructor for term x64_psllw_b_or_avx.
pub fn constructor_x64_psllw_b_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: u8,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vpsllw_d(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 5431.
        return v3;
    }
    let v4 = constructor_x64_psllw_b(ctx, arg0, arg1);
    // Rule at <OUT_DIR>/assembler.isle line 5434.
    return v4;
}

// Generated as internal constructor for term x64_pslld_a.
pub fn constructor_x64_pslld_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_pslld_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5439.
    return v3;
}

// Generated as internal constructor for term x64_pslld_a_or_avx.
pub fn constructor_x64_pslld_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vpslld_c(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 5441.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_pslld_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 5444.
    return v5;
}

// Generated as internal constructor for term x64_pslld_b.
pub fn constructor_x64_pslld_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: u8,
) -> Xmm {
    let v2 = &C::x64_pslld_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5449.
    return v3;
}

// Generated as internal constructor for term x64_pslld_b_or_avx.
pub fn constructor_x64_pslld_b_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: u8,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vpslld_d(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 5451.
        return v3;
    }
    let v4 = constructor_x64_pslld_b(ctx, arg0, arg1);
    // Rule at <OUT_DIR>/assembler.isle line 5454.
    return v4;
}

// Generated as internal constructor for term x64_psllq_a.
pub fn constructor_x64_psllq_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_psllq_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5459.
    return v3;
}

// Generated as internal constructor for term x64_psllq_a_or_avx.
pub fn constructor_x64_psllq_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vpsllq_c(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 5461.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_psllq_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 5464.
    return v5;
}

// Generated as internal constructor for term x64_psllq_b.
pub fn constructor_x64_psllq_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: u8,
) -> Xmm {
    let v2 = &C::x64_psllq_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5469.
    return v3;
}

// Generated as internal constructor for term x64_psllq_b_or_avx.
pub fn constructor_x64_psllq_b_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: u8,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vpsllq_d(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 5471.
        return v3;
    }
    let v4 = constructor_x64_psllq_b(ctx, arg0, arg1);
    // Rule at <OUT_DIR>/assembler.isle line 5474.
    return v4;
}

// Generated as internal constructor for term x64_vpsllw_c.
pub fn constructor_x64_vpsllw_c<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vpsllw_c_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5479.
    return v3;
}

// Generated as internal constructor for term x64_vpsllw_d.
pub fn constructor_x64_vpsllw_d<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: u8,
) -> Xmm {
    let v2 = &C::x64_vpsllw_d_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5484.
    return v3;
}

// Generated as internal constructor for term x64_vpslld_c.
pub fn constructor_x64_vpslld_c<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vpslld_c_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5489.
    return v3;
}

// Generated as internal constructor for term x64_vpslld_d.
pub fn constructor_x64_vpslld_d<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: u8,
) -> Xmm {
    let v2 = &C::x64_vpslld_d_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5494.
    return v3;
}

// Generated as internal constructor for term x64_vpsllq_c.
pub fn constructor_x64_vpsllq_c<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vpsllq_c_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5499.
    return v3;
}

// Generated as internal constructor for term x64_vpsllq_d.
pub fn constructor_x64_vpsllq_d<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: u8,
) -> Xmm {
    let v2 = &C::x64_vpsllq_d_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5504.
    return v3;
}

// Generated as internal constructor for term x64_vpslld_g.
pub fn constructor_x64_vpslld_g<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vpslld_g_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5509.
    return v3;
}

// Generated as internal constructor for term x64_vpslld_f.
pub fn constructor_x64_vpslld_f<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
    arg1: u8,
) -> Xmm {
    let v2 = &C::x64_vpslld_f_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5514.
    return v3;
}

// Generated as internal constructor for term x64_vpsllq_g.
pub fn constructor_x64_vpsllq_g<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vpsllq_g_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5519.
    return v3;
}

// Generated as internal constructor for term x64_vpsllq_f.
pub fn constructor_x64_vpsllq_f<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
    arg1: u8,
) -> Xmm {
    let v2 = &C::x64_vpsllq_f_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5524.
    return v3;
}

// Generated as internal constructor for term x64_psraw_a.
pub fn constructor_x64_psraw_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_psraw_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5529.
    return v3;
}

// Generated as internal constructor for term x64_psraw_a_or_avx.
pub fn constructor_x64_psraw_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vpsraw_c(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 5531.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_psraw_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 5534.
    return v5;
}

// Generated as internal constructor for term x64_psraw_b.
pub fn constructor_x64_psraw_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: u8,
) -> Xmm {
    let v2 = &C::x64_psraw_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5539.
    return v3;
}

// Generated as internal constructor for term x64_psraw_b_or_avx.
pub fn constructor_x64_psraw_b_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: u8,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vpsraw_d(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 5541.
        return v3;
    }
    let v4 = constructor_x64_psraw_b(ctx, arg0, arg1);
    // Rule at <OUT_DIR>/assembler.isle line 5544.
    return v4;
}

// Generated as internal constructor for term x64_psrad_a.
pub fn constructor_x64_psrad_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_psrad_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5549.
    return v3;
}

// Generated as internal constructor for term x64_psrad_a_or_avx.
pub fn constructor_x64_psrad_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vpsrad_c(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 5551.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_psrad_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 5554.
    return v5;
}

// Generated as internal constructor for term x64_psrad_b.
pub fn constructor_x64_psrad_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: u8,
) -> Xmm {
    let v2 = &C::x64_psrad_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5559.
    return v3;
}

// Generated as internal constructor for term x64_psrad_b_or_avx.
pub fn constructor_x64_psrad_b_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: u8,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vpsrad_d(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 5561.
        return v3;
    }
    let v4 = constructor_x64_psrad_b(ctx, arg0, arg1);
    // Rule at <OUT_DIR>/assembler.isle line 5564.
    return v4;
}

// Generated as internal constructor for term x64_psrlw_a.
pub fn constructor_x64_psrlw_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_psrlw_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5569.
    return v3;
}

// Generated as internal constructor for term x64_psrlw_a_or_avx.
pub fn constructor_x64_psrlw_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vpsrlw_c(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 5571.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_psrlw_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 5574.
    return v5;
}

// Generated as internal constructor for term x64_psrlw_b.
pub fn constructor_x64_psrlw_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: u8,
) -> Xmm {
    let v2 = &C::x64_psrlw_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5579.
    return v3;
}

// Generated as internal constructor for term x64_psrlw_b_or_avx.
pub fn constructor_x64_psrlw_b_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: u8,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vpsrlw_d(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 5581.
        return v3;
    }
    let v4 = constructor_x64_psrlw_b(ctx, arg0, arg1);
    // Rule at <OUT_DIR>/assembler.isle line 5584.
    return v4;
}

// Generated as internal constructor for term x64_psrld_a.
pub fn constructor_x64_psrld_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_psrld_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5589.
    return v3;
}

// Generated as internal constructor for term x64_psrld_a_or_avx.
pub fn constructor_x64_psrld_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vpsrld_c(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 5591.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_psrld_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 5594.
    return v5;
}

// Generated as internal constructor for term x64_psrld_b.
pub fn constructor_x64_psrld_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: u8,
) -> Xmm {
    let v2 = &C::x64_psrld_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5599.
    return v3;
}

// Generated as internal constructor for term x64_psrld_b_or_avx.
pub fn constructor_x64_psrld_b_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: u8,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vpsrld_d(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 5601.
        return v3;
    }
    let v4 = constructor_x64_psrld_b(ctx, arg0, arg1);
    // Rule at <OUT_DIR>/assembler.isle line 5604.
    return v4;
}

// Generated as internal constructor for term x64_psrlq_a.
pub fn constructor_x64_psrlq_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_psrlq_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5609.
    return v3;
}

// Generated as internal constructor for term x64_psrlq_a_or_avx.
pub fn constructor_x64_psrlq_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vpsrlq_c(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 5611.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_psrlq_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 5614.
    return v5;
}

// Generated as internal constructor for term x64_psrlq_b.
pub fn constructor_x64_psrlq_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: u8,
) -> Xmm {
    let v2 = &C::x64_psrlq_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5619.
    return v3;
}

// Generated as internal constructor for term x64_psrlq_b_or_avx.
pub fn constructor_x64_psrlq_b_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: u8,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vpsrlq_d(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 5621.
        return v3;
    }
    let v4 = constructor_x64_psrlq_b(ctx, arg0, arg1);
    // Rule at <OUT_DIR>/assembler.isle line 5624.
    return v4;
}

// Generated as internal constructor for term x64_vpsraw_c.
pub fn constructor_x64_vpsraw_c<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vpsraw_c_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5629.
    return v3;
}

// Generated as internal constructor for term x64_vpsraw_d.
pub fn constructor_x64_vpsraw_d<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: u8,
) -> Xmm {
    let v2 = &C::x64_vpsraw_d_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5634.
    return v3;
}

// Generated as internal constructor for term x64_vpsrad_c.
pub fn constructor_x64_vpsrad_c<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vpsrad_c_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5639.
    return v3;
}

// Generated as internal constructor for term x64_vpsrad_d.
pub fn constructor_x64_vpsrad_d<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: u8,
) -> Xmm {
    let v2 = &C::x64_vpsrad_d_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5644.
    return v3;
}

// Generated as internal constructor for term x64_vpsrlw_c.
pub fn constructor_x64_vpsrlw_c<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vpsrlw_c_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5649.
    return v3;
}

// Generated as internal constructor for term x64_vpsrlw_d.
pub fn constructor_x64_vpsrlw_d<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: u8,
) -> Xmm {
    let v2 = &C::x64_vpsrlw_d_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5654.
    return v3;
}

// Generated as internal constructor for term x64_vpsrld_c.
pub fn constructor_x64_vpsrld_c<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vpsrld_c_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5659.
    return v3;
}

// Generated as internal constructor for term x64_vpsrld_d.
pub fn constructor_x64_vpsrld_d<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: u8,
) -> Xmm {
    let v2 = &C::x64_vpsrld_d_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5664.
    return v3;
}

// Generated as internal constructor for term x64_vpsrlq_c.
pub fn constructor_x64_vpsrlq_c<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vpsrlq_c_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5669.
    return v3;
}

// Generated as internal constructor for term x64_vpsrlq_d.
pub fn constructor_x64_vpsrlq_d<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: u8,
) -> Xmm {
    let v2 = &C::x64_vpsrlq_d_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5674.
    return v3;
}

// Generated as internal constructor for term x64_vpsrad_g.
pub fn constructor_x64_vpsrad_g<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vpsrad_g_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5679.
    return v3;
}

// Generated as internal constructor for term x64_vpsrad_f.
pub fn constructor_x64_vpsrad_f<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
    arg1: u8,
) -> Xmm {
    let v2 = &C::x64_vpsrad_f_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5684.
    return v3;
}

// Generated as internal constructor for term x64_vpsraq_g.
pub fn constructor_x64_vpsraq_g<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vpsraq_g_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5689.
    return v3;
}

// Generated as internal constructor for term x64_vpsraq_f.
pub fn constructor_x64_vpsraq_f<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
    arg1: u8,
) -> Xmm {
    let v2 = &C::x64_vpsraq_f_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5694.
    return v3;
}

// Generated as internal constructor for term x64_vpsrld_g.
pub fn constructor_x64_vpsrld_g<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vpsrld_g_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5699.
    return v3;
}

// Generated as internal constructor for term x64_vpsrld_f.
pub fn constructor_x64_vpsrld_f<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
    arg1: u8,
) -> Xmm {
    let v2 = &C::x64_vpsrld_f_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5704.
    return v3;
}

// Generated as internal constructor for term x64_vpsrlq_g.
pub fn constructor_x64_vpsrlq_g<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vpsrlq_g_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5709.
    return v3;
}

// Generated as internal constructor for term x64_vpsrlq_f.
pub fn constructor_x64_vpsrlq_f<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
    arg1: u8,
) -> Xmm {
    let v2 = &C::x64_vpsrlq_f_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5714.
    return v3;
}

// Generated as internal constructor for term x64_sqrtss_a.
pub fn constructor_x64_sqrtss_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_sqrtss_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5719.
    return v3;
}

// Generated as internal constructor for term x64_sqrtss_a_or_avx.
pub fn constructor_x64_sqrtss_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vsqrtss_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 5721.
        return v3;
    }
    let v4 = constructor_x64_sqrtss_a(ctx, arg0, arg1);
    // Rule at <OUT_DIR>/assembler.isle line 5724.
    return v4;
}

// Generated as internal constructor for term x64_sqrtsd_a.
pub fn constructor_x64_sqrtsd_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_sqrtsd_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5729.
    return v3;
}

// Generated as internal constructor for term x64_sqrtsd_a_or_avx.
pub fn constructor_x64_sqrtsd_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vsqrtsd_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 5731.
        return v3;
    }
    let v4 = constructor_x64_sqrtsd_a(ctx, arg0, arg1);
    // Rule at <OUT_DIR>/assembler.isle line 5734.
    return v4;
}

// Generated as internal constructor for term x64_sqrtps_a.
pub fn constructor_x64_sqrtps_a<C: Context>(
    ctx: &mut C,
    arg0: &XmmMemAligned,
) -> Xmm {
    let v1 = &C::x64_sqrtps_a_raw(ctx, arg0);
    let v2 = constructor_emit_ret_xmm(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 5739.
    return v2;
}

// Generated as internal constructor for term x64_sqrtps_a_or_avx.
pub fn constructor_x64_sqrtps_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = C::has_avx(ctx);
    if v1 == true {
        let v2 = constructor_x64_vsqrtps_b(ctx, arg0);
        // Rule at <OUT_DIR>/assembler.isle line 5741.
        return v2;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg0);
    let v4 = constructor_x64_sqrtps_a(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5744.
    return v4;
}

// Generated as internal constructor for term x64_sqrtpd_a.
pub fn constructor_x64_sqrtpd_a<C: Context>(
    ctx: &mut C,
    arg0: &XmmMemAligned,
) -> Xmm {
    let v1 = &C::x64_sqrtpd_a_raw(ctx, arg0);
    let v2 = constructor_emit_ret_xmm(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 5749.
    return v2;
}

// Generated as internal constructor for term x64_sqrtpd_a_or_avx.
pub fn constructor_x64_sqrtpd_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = C::has_avx(ctx);
    if v1 == true {
        let v2 = constructor_x64_vsqrtpd_b(ctx, arg0);
        // Rule at <OUT_DIR>/assembler.isle line 5751.
        return v2;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg0);
    let v4 = constructor_x64_sqrtpd_a(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5754.
    return v4;
}

// Generated as internal constructor for term x64_vsqrtss_b.
pub fn constructor_x64_vsqrtss_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vsqrtss_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5759.
    return v3;
}

// Generated as internal constructor for term x64_vsqrtsd_b.
pub fn constructor_x64_vsqrtsd_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vsqrtsd_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5764.
    return v3;
}

// Generated as internal constructor for term x64_vsqrtps_b.
pub fn constructor_x64_vsqrtps_b<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = &C::x64_vsqrtps_b_raw(ctx, arg0);
    let v2 = constructor_emit_ret_xmm(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 5769.
    return v2;
}

// Generated as internal constructor for term x64_vsqrtpd_b.
pub fn constructor_x64_vsqrtpd_b<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem,
) -> Xmm {
    let v1 = &C::x64_vsqrtpd_b_raw(ctx, arg0);
    let v2 = constructor_emit_ret_xmm(ctx, v1);
    // Rule at <OUT_DIR>/assembler.isle line 5774.
    return v2;
}

// Generated as internal constructor for term x64_popw_m.
pub fn constructor_x64_popw_m<C: Context>(
    ctx: &mut C,
) -> Gpr {
    let v0 = C::temp_writable_gpr(ctx);
    let v1 = &constructor_writable_gpr_to_gpr_mem(ctx, v0);
    let v2 = &C::x64_popw_m_raw(ctx, v1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5779.
    return v3;
}

// Generated as internal constructor for term x64_popw_m_mem.
pub fn constructor_x64_popw_m_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
) -> SideEffectNoResult {
    let v1 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v2 = &C::x64_popw_m_raw(ctx, v1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5781.
    return v3.clone();
}

// Generated as internal constructor for term x64_popq_m.
pub fn constructor_x64_popq_m<C: Context>(
    ctx: &mut C,
) -> Gpr {
    let v0 = C::temp_writable_gpr(ctx);
    let v1 = &constructor_writable_gpr_to_gpr_mem(ctx, v0);
    let v2 = &C::x64_popq_m_raw(ctx, v1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5786.
    return v3;
}

// Generated as internal constructor for term x64_popq_m_mem.
pub fn constructor_x64_popq_m_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
) -> SideEffectNoResult {
    let v1 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v2 = &C::x64_popq_m_raw(ctx, v1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5788.
    return v3.clone();
}

// Generated as internal constructor for term x64_popw_o.
pub fn constructor_x64_popw_o<C: Context>(
    ctx: &mut C,
) -> Gpr {
    let v0 = &C::x64_popw_o_raw(ctx);
    let v1 = constructor_emit_ret_gpr(ctx, v0);
    // Rule at <OUT_DIR>/assembler.isle line 5793.
    return v1;
}

// Generated as internal constructor for term x64_popq_o.
pub fn constructor_x64_popq_o<C: Context>(
    ctx: &mut C,
) -> Gpr {
    let v0 = &C::x64_popq_o_raw(ctx);
    let v1 = constructor_emit_ret_gpr(ctx, v0);
    // Rule at <OUT_DIR>/assembler.isle line 5798.
    return v1;
}

// Generated as internal constructor for term x64_subb_i.
pub fn constructor_x64_subb_i<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: u8,
) -> Gpr {
    let v2 = &C::x64_subb_i_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5803.
    return v3;
}

// Generated as internal constructor for term x64_subw_i.
pub fn constructor_x64_subw_i<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: u16,
) -> Gpr {
    let v2 = &C::x64_subw_i_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5808.
    return v3;
}

// Generated as internal constructor for term x64_subl_i.
pub fn constructor_x64_subl_i<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: u32,
) -> Gpr {
    let v2 = &C::x64_subl_i_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5813.
    return v3;
}

// Generated as internal constructor for term x64_subq_i_sxl.
pub fn constructor_x64_subq_i_sxl<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: i32,
) -> Gpr {
    let v2 = &C::x64_subq_i_sxl_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5818.
    return v3;
}

// Generated as internal constructor for term x64_subb_mi.
pub fn constructor_x64_subb_mi<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: u8,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_subb_mi_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5823.
    return v4;
}

// Generated as internal constructor for term x64_subb_mi_mem.
pub fn constructor_x64_subb_mi_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: u8,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_subb_mi_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5825.
    return v4.clone();
}

// Generated as internal constructor for term x64_subw_mi.
pub fn constructor_x64_subw_mi<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: u16,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_subw_mi_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5830.
    return v4;
}

// Generated as internal constructor for term x64_subw_mi_mem.
pub fn constructor_x64_subw_mi_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: u16,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_subw_mi_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5832.
    return v4.clone();
}

// Generated as internal constructor for term x64_subl_mi.
pub fn constructor_x64_subl_mi<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: u32,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_subl_mi_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5837.
    return v4;
}

// Generated as internal constructor for term x64_subl_mi_mem.
pub fn constructor_x64_subl_mi_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: u32,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_subl_mi_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5839.
    return v4.clone();
}

// Generated as internal constructor for term x64_subq_mi_sxl.
pub fn constructor_x64_subq_mi_sxl<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: i32,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_subq_mi_sxl_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5844.
    return v4;
}

// Generated as internal constructor for term x64_subq_mi_sxl_mem.
pub fn constructor_x64_subq_mi_sxl_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: i32,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_subq_mi_sxl_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5846.
    return v4.clone();
}

// Generated as internal constructor for term x64_subl_mi_sxb.
pub fn constructor_x64_subl_mi_sxb<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: i8,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_subl_mi_sxb_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5851.
    return v4;
}

// Generated as internal constructor for term x64_subl_mi_sxb_mem.
pub fn constructor_x64_subl_mi_sxb_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: i8,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_subl_mi_sxb_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5853.
    return v4.clone();
}

// Generated as internal constructor for term x64_subq_mi_sxb.
pub fn constructor_x64_subq_mi_sxb<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: i8,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_subq_mi_sxb_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5858.
    return v4;
}

// Generated as internal constructor for term x64_subq_mi_sxb_mem.
pub fn constructor_x64_subq_mi_sxb_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: i8,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_subq_mi_sxb_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5860.
    return v4.clone();
}

// Generated as internal constructor for term x64_subb_mr.
pub fn constructor_x64_subb_mr<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: Gpr,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_subb_mr_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5865.
    return v4;
}

// Generated as internal constructor for term x64_subb_mr_mem.
pub fn constructor_x64_subb_mr_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Gpr,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_subb_mr_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5867.
    return v4.clone();
}

// Generated as internal constructor for term x64_subw_mr.
pub fn constructor_x64_subw_mr<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: Gpr,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_subw_mr_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5872.
    return v4;
}

// Generated as internal constructor for term x64_subw_mr_mem.
pub fn constructor_x64_subw_mr_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Gpr,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_subw_mr_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5874.
    return v4.clone();
}

// Generated as internal constructor for term x64_subl_mr.
pub fn constructor_x64_subl_mr<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: Gpr,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_subl_mr_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5879.
    return v4;
}

// Generated as internal constructor for term x64_subl_mr_mem.
pub fn constructor_x64_subl_mr_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Gpr,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_subl_mr_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5881.
    return v4.clone();
}

// Generated as internal constructor for term x64_subq_mr.
pub fn constructor_x64_subq_mr<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: Gpr,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_subq_mr_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5886.
    return v4;
}

// Generated as internal constructor for term x64_subq_mr_mem.
pub fn constructor_x64_subq_mr_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Gpr,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_subq_mr_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5888.
    return v4.clone();
}

// Generated as internal constructor for term x64_subb_rm.
pub fn constructor_x64_subb_rm<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
) -> Gpr {
    let v2 = &C::x64_subb_rm_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5893.
    return v3;
}

// Generated as internal constructor for term x64_subw_rm.
pub fn constructor_x64_subw_rm<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
) -> Gpr {
    let v2 = &C::x64_subw_rm_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5898.
    return v3;
}

// Generated as internal constructor for term x64_subl_rm.
pub fn constructor_x64_subl_rm<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
) -> Gpr {
    let v2 = &C::x64_subl_rm_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5903.
    return v3;
}

// Generated as internal constructor for term x64_subq_rm.
pub fn constructor_x64_subq_rm<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
) -> Gpr {
    let v2 = &C::x64_subq_rm_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5908.
    return v3;
}

// Generated as internal constructor for term x64_sbbb_i.
pub fn constructor_x64_sbbb_i<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: u8,
) -> Gpr {
    let v2 = &C::x64_sbbb_i_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5913.
    return v3;
}

// Generated as internal constructor for term x64_sbbw_i.
pub fn constructor_x64_sbbw_i<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: u16,
) -> Gpr {
    let v2 = &C::x64_sbbw_i_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5918.
    return v3;
}

// Generated as internal constructor for term x64_sbbl_i.
pub fn constructor_x64_sbbl_i<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: u32,
) -> Gpr {
    let v2 = &C::x64_sbbl_i_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5923.
    return v3;
}

// Generated as internal constructor for term x64_sbbq_i_sxl.
pub fn constructor_x64_sbbq_i_sxl<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: i32,
) -> Gpr {
    let v2 = &C::x64_sbbq_i_sxl_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 5928.
    return v3;
}

// Generated as internal constructor for term x64_sbbb_mi.
pub fn constructor_x64_sbbb_mi<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: u8,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_sbbb_mi_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5933.
    return v4;
}

// Generated as internal constructor for term x64_sbbb_mi_mem.
pub fn constructor_x64_sbbb_mi_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: u8,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_sbbb_mi_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5935.
    return v4.clone();
}

// Generated as internal constructor for term x64_sbbw_mi.
pub fn constructor_x64_sbbw_mi<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: u16,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_sbbw_mi_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5940.
    return v4;
}

// Generated as internal constructor for term x64_sbbw_mi_mem.
pub fn constructor_x64_sbbw_mi_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: u16,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_sbbw_mi_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5942.
    return v4.clone();
}

// Generated as internal constructor for term x64_sbbl_mi.
pub fn constructor_x64_sbbl_mi<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: u32,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_sbbl_mi_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5947.
    return v4;
}

// Generated as internal constructor for term x64_sbbl_mi_mem.
pub fn constructor_x64_sbbl_mi_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: u32,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_sbbl_mi_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5949.
    return v4.clone();
}

// Generated as internal constructor for term x64_sbbq_mi_sxl.
pub fn constructor_x64_sbbq_mi_sxl<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: i32,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_sbbq_mi_sxl_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5954.
    return v4;
}

// Generated as internal constructor for term x64_sbbq_mi_sxl_mem.
pub fn constructor_x64_sbbq_mi_sxl_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: i32,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_sbbq_mi_sxl_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5956.
    return v4.clone();
}

// Generated as internal constructor for term x64_sbbl_mi_sxb.
pub fn constructor_x64_sbbl_mi_sxb<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: i8,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_sbbl_mi_sxb_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5961.
    return v4;
}

// Generated as internal constructor for term x64_sbbl_mi_sxb_mem.
pub fn constructor_x64_sbbl_mi_sxb_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: i8,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_sbbl_mi_sxb_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5963.
    return v4.clone();
}

// Generated as internal constructor for term x64_sbbq_mi_sxb.
pub fn constructor_x64_sbbq_mi_sxb<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: i8,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_sbbq_mi_sxb_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5968.
    return v4;
}

// Generated as internal constructor for term x64_sbbq_mi_sxb_mem.
pub fn constructor_x64_sbbq_mi_sxb_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: i8,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_sbbq_mi_sxb_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5970.
    return v4.clone();
}

// Generated as internal constructor for term x64_sbbb_mr.
pub fn constructor_x64_sbbb_mr<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: Gpr,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_sbbb_mr_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5975.
    return v4;
}

// Generated as internal constructor for term x64_sbbb_mr_mem.
pub fn constructor_x64_sbbb_mr_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Gpr,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_sbbb_mr_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5977.
    return v4.clone();
}

// Generated as internal constructor for term x64_sbbw_mr.
pub fn constructor_x64_sbbw_mr<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: Gpr,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_sbbw_mr_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5982.
    return v4;
}

// Generated as internal constructor for term x64_sbbw_mr_mem.
pub fn constructor_x64_sbbw_mr_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Gpr,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_sbbw_mr_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5984.
    return v4.clone();
}

// Generated as internal constructor for term x64_sbbl_mr.
pub fn constructor_x64_sbbl_mr<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: Gpr,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_sbbl_mr_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5989.
    return v4;
}

// Generated as internal constructor for term x64_sbbl_mr_mem.
pub fn constructor_x64_sbbl_mr_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Gpr,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_sbbl_mr_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5991.
    return v4.clone();
}

// Generated as internal constructor for term x64_sbbq_mr.
pub fn constructor_x64_sbbq_mr<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: Gpr,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_sbbq_mr_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5996.
    return v4;
}

// Generated as internal constructor for term x64_sbbq_mr_mem.
pub fn constructor_x64_sbbq_mr_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Gpr,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_sbbq_mr_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 5998.
    return v4.clone();
}

// Generated as internal constructor for term x64_sbbb_rm.
pub fn constructor_x64_sbbb_rm<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
) -> Gpr {
    let v2 = &C::x64_sbbb_rm_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 6003.
    return v3;
}

// Generated as internal constructor for term x64_sbbw_rm.
pub fn constructor_x64_sbbw_rm<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
) -> Gpr {
    let v2 = &C::x64_sbbw_rm_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 6008.
    return v3;
}

// Generated as internal constructor for term x64_sbbl_rm.
pub fn constructor_x64_sbbl_rm<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
) -> Gpr {
    let v2 = &C::x64_sbbl_rm_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 6013.
    return v3;
}

// Generated as internal constructor for term x64_sbbq_rm.
pub fn constructor_x64_sbbq_rm<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
) -> Gpr {
    let v2 = &C::x64_sbbq_rm_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 6018.
    return v3;
}

// Generated as internal constructor for term x64_lock_subb_mi_mem.
pub fn constructor_x64_lock_subb_mi_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: u8,
) -> SideEffectNoResult {
    let v2 = &C::x64_lock_subb_mi_raw(ctx, arg0, arg1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 6023.
    return v3.clone();
}

// Generated as internal constructor for term x64_lock_subw_mi_mem.
pub fn constructor_x64_lock_subw_mi_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: u16,
) -> SideEffectNoResult {
    let v2 = &C::x64_lock_subw_mi_raw(ctx, arg0, arg1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 6028.
    return v3.clone();
}

// Generated as internal constructor for term x64_lock_subl_mi_mem.
pub fn constructor_x64_lock_subl_mi_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: u32,
) -> SideEffectNoResult {
    let v2 = &C::x64_lock_subl_mi_raw(ctx, arg0, arg1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 6033.
    return v3.clone();
}

// Generated as internal constructor for term x64_lock_subq_mi_sxl_mem.
pub fn constructor_x64_lock_subq_mi_sxl_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: i32,
) -> SideEffectNoResult {
    let v2 = &C::x64_lock_subq_mi_sxl_raw(ctx, arg0, arg1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 6038.
    return v3.clone();
}

// Generated as internal constructor for term x64_lock_subl_mi_sxb_mem.
pub fn constructor_x64_lock_subl_mi_sxb_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: i8,
) -> SideEffectNoResult {
    let v2 = &C::x64_lock_subl_mi_sxb_raw(ctx, arg0, arg1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 6043.
    return v3.clone();
}

// Generated as internal constructor for term x64_lock_subq_mi_sxb_mem.
pub fn constructor_x64_lock_subq_mi_sxb_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: i8,
) -> SideEffectNoResult {
    let v2 = &C::x64_lock_subq_mi_sxb_raw(ctx, arg0, arg1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 6048.
    return v3.clone();
}

// Generated as internal constructor for term x64_lock_subb_mr_mem.
pub fn constructor_x64_lock_subb_mr_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Gpr,
) -> SideEffectNoResult {
    let v2 = &C::x64_lock_subb_mr_raw(ctx, arg0, arg1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 6053.
    return v3.clone();
}

// Generated as internal constructor for term x64_lock_subw_mr_mem.
pub fn constructor_x64_lock_subw_mr_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Gpr,
) -> SideEffectNoResult {
    let v2 = &C::x64_lock_subw_mr_raw(ctx, arg0, arg1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 6058.
    return v3.clone();
}

// Generated as internal constructor for term x64_lock_subl_mr_mem.
pub fn constructor_x64_lock_subl_mr_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Gpr,
) -> SideEffectNoResult {
    let v2 = &C::x64_lock_subl_mr_raw(ctx, arg0, arg1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 6063.
    return v3.clone();
}

// Generated as internal constructor for term x64_lock_subq_mr_mem.
pub fn constructor_x64_lock_subq_mr_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Gpr,
) -> SideEffectNoResult {
    let v2 = &C::x64_lock_subq_mr_raw(ctx, arg0, arg1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 6068.
    return v3.clone();
}

// Generated as internal constructor for term x64_lock_sbbb_mi_mem.
pub fn constructor_x64_lock_sbbb_mi_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: u8,
) -> SideEffectNoResult {
    let v2 = &C::x64_lock_sbbb_mi_raw(ctx, arg0, arg1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 6073.
    return v3.clone();
}

// Generated as internal constructor for term x64_lock_sbbw_mi_mem.
pub fn constructor_x64_lock_sbbw_mi_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: u16,
) -> SideEffectNoResult {
    let v2 = &C::x64_lock_sbbw_mi_raw(ctx, arg0, arg1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 6078.
    return v3.clone();
}

// Generated as internal constructor for term x64_lock_sbbl_mi_mem.
pub fn constructor_x64_lock_sbbl_mi_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: u32,
) -> SideEffectNoResult {
    let v2 = &C::x64_lock_sbbl_mi_raw(ctx, arg0, arg1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 6083.
    return v3.clone();
}

// Generated as internal constructor for term x64_lock_sbbq_mi_sxl_mem.
pub fn constructor_x64_lock_sbbq_mi_sxl_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: i32,
) -> SideEffectNoResult {
    let v2 = &C::x64_lock_sbbq_mi_sxl_raw(ctx, arg0, arg1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 6088.
    return v3.clone();
}

// Generated as internal constructor for term x64_lock_sbbl_mi_sxb_mem.
pub fn constructor_x64_lock_sbbl_mi_sxb_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: i8,
) -> SideEffectNoResult {
    let v2 = &C::x64_lock_sbbl_mi_sxb_raw(ctx, arg0, arg1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 6093.
    return v3.clone();
}

// Generated as internal constructor for term x64_lock_sbbq_mi_sxb_mem.
pub fn constructor_x64_lock_sbbq_mi_sxb_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: i8,
) -> SideEffectNoResult {
    let v2 = &C::x64_lock_sbbq_mi_sxb_raw(ctx, arg0, arg1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 6098.
    return v3.clone();
}

// Generated as internal constructor for term x64_lock_sbbb_mr_mem.
pub fn constructor_x64_lock_sbbb_mr_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Gpr,
) -> SideEffectNoResult {
    let v2 = &C::x64_lock_sbbb_mr_raw(ctx, arg0, arg1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 6103.
    return v3.clone();
}

// Generated as internal constructor for term x64_lock_sbbw_mr_mem.
pub fn constructor_x64_lock_sbbw_mr_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Gpr,
) -> SideEffectNoResult {
    let v2 = &C::x64_lock_sbbw_mr_raw(ctx, arg0, arg1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 6108.
    return v3.clone();
}

// Generated as internal constructor for term x64_lock_sbbl_mr_mem.
pub fn constructor_x64_lock_sbbl_mr_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Gpr,
) -> SideEffectNoResult {
    let v2 = &C::x64_lock_sbbl_mr_raw(ctx, arg0, arg1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 6113.
    return v3.clone();
}

// Generated as internal constructor for term x64_lock_sbbq_mr_mem.
pub fn constructor_x64_lock_sbbq_mr_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Gpr,
) -> SideEffectNoResult {
    let v2 = &C::x64_lock_sbbq_mr_raw(ctx, arg0, arg1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 6118.
    return v3.clone();
}

// Generated as internal constructor for term x64_subss_a.
pub fn constructor_x64_subss_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_subss_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 6123.
    return v3;
}

// Generated as internal constructor for term x64_subss_a_or_avx.
pub fn constructor_x64_subss_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vsubss_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 6125.
        return v3;
    }
    let v4 = constructor_x64_subss_a(ctx, arg0, arg1);
    // Rule at <OUT_DIR>/assembler.isle line 6128.
    return v4;
}

// Generated as internal constructor for term x64_subsd_a.
pub fn constructor_x64_subsd_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_subsd_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 6133.
    return v3;
}

// Generated as internal constructor for term x64_subsd_a_or_avx.
pub fn constructor_x64_subsd_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vsubsd_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 6135.
        return v3;
    }
    let v4 = constructor_x64_subsd_a(ctx, arg0, arg1);
    // Rule at <OUT_DIR>/assembler.isle line 6138.
    return v4;
}

// Generated as internal constructor for term x64_subps_a.
pub fn constructor_x64_subps_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_subps_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 6143.
    return v3;
}

// Generated as internal constructor for term x64_subps_a_or_avx.
pub fn constructor_x64_subps_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vsubps_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 6145.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_subps_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 6148.
    return v5;
}

// Generated as internal constructor for term x64_subpd_a.
pub fn constructor_x64_subpd_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_subpd_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 6153.
    return v3;
}

// Generated as internal constructor for term x64_subpd_a_or_avx.
pub fn constructor_x64_subpd_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vsubpd_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 6155.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_subpd_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 6158.
    return v5;
}

// Generated as internal constructor for term x64_psubb_a.
pub fn constructor_x64_psubb_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_psubb_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 6163.
    return v3;
}

// Generated as internal constructor for term x64_psubb_a_or_avx.
pub fn constructor_x64_psubb_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vpsubb_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 6165.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_psubb_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 6168.
    return v5;
}

// Generated as internal constructor for term x64_psubw_a.
pub fn constructor_x64_psubw_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_psubw_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 6173.
    return v3;
}

// Generated as internal constructor for term x64_psubw_a_or_avx.
pub fn constructor_x64_psubw_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vpsubw_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 6175.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_psubw_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 6178.
    return v5;
}

// Generated as internal constructor for term x64_psubd_a.
pub fn constructor_x64_psubd_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_psubd_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 6183.
    return v3;
}

// Generated as internal constructor for term x64_psubd_a_or_avx.
pub fn constructor_x64_psubd_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vpsubd_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 6185.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_psubd_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 6188.
    return v5;
}

// Generated as internal constructor for term x64_psubq_a.
pub fn constructor_x64_psubq_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_psubq_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 6193.
    return v3;
}

// Generated as internal constructor for term x64_psubq_a_or_avx.
pub fn constructor_x64_psubq_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vpsubq_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 6195.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_psubq_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 6198.
    return v5;
}

// Generated as internal constructor for term x64_psubsb_a.
pub fn constructor_x64_psubsb_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_psubsb_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 6203.
    return v3;
}

// Generated as internal constructor for term x64_psubsb_a_or_avx.
pub fn constructor_x64_psubsb_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vpsubsb_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 6205.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_psubsb_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 6208.
    return v5;
}

// Generated as internal constructor for term x64_psubsw_a.
pub fn constructor_x64_psubsw_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_psubsw_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 6213.
    return v3;
}

// Generated as internal constructor for term x64_psubsw_a_or_avx.
pub fn constructor_x64_psubsw_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vpsubsw_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 6215.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_psubsw_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 6218.
    return v5;
}

// Generated as internal constructor for term x64_psubusb_a.
pub fn constructor_x64_psubusb_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_psubusb_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 6223.
    return v3;
}

// Generated as internal constructor for term x64_psubusb_a_or_avx.
pub fn constructor_x64_psubusb_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vpsubusb_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 6225.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_psubusb_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 6228.
    return v5;
}

// Generated as internal constructor for term x64_psubusw_a.
pub fn constructor_x64_psubusw_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_psubusw_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 6233.
    return v3;
}

// Generated as internal constructor for term x64_psubusw_a_or_avx.
pub fn constructor_x64_psubusw_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vpsubusw_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 6235.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_psubusw_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 6238.
    return v5;
}

// Generated as internal constructor for term x64_vsubss_b.
pub fn constructor_x64_vsubss_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vsubss_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 6243.
    return v3;
}

// Generated as internal constructor for term x64_vsubsd_b.
pub fn constructor_x64_vsubsd_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vsubsd_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 6248.
    return v3;
}

// Generated as internal constructor for term x64_vsubps_b.
pub fn constructor_x64_vsubps_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vsubps_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 6253.
    return v3;
}

// Generated as internal constructor for term x64_vsubpd_b.
pub fn constructor_x64_vsubpd_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vsubpd_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 6258.
    return v3;
}

// Generated as internal constructor for term x64_vpsubb_b.
pub fn constructor_x64_vpsubb_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vpsubb_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 6263.
    return v3;
}

// Generated as internal constructor for term x64_vpsubw_b.
pub fn constructor_x64_vpsubw_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vpsubw_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 6268.
    return v3;
}

// Generated as internal constructor for term x64_vpsubd_b.
pub fn constructor_x64_vpsubd_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vpsubd_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 6273.
    return v3;
}

// Generated as internal constructor for term x64_vpsubq_b.
pub fn constructor_x64_vpsubq_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vpsubq_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 6278.
    return v3;
}

// Generated as internal constructor for term x64_vpsubsb_b.
pub fn constructor_x64_vpsubsb_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vpsubsb_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 6283.
    return v3;
}

// Generated as internal constructor for term x64_vpsubsw_b.
pub fn constructor_x64_vpsubsw_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vpsubsw_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 6288.
    return v3;
}

// Generated as internal constructor for term x64_vpsubusb_b.
pub fn constructor_x64_vpsubusb_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vpsubusb_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 6293.
    return v3;
}

// Generated as internal constructor for term x64_vpsubusw_b.
pub fn constructor_x64_vpsubusw_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vpsubusw_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 6298.
    return v3;
}

// Generated as internal constructor for term x64_unpcklps_a.
pub fn constructor_x64_unpcklps_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_unpcklps_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 6303.
    return v3;
}

// Generated as internal constructor for term x64_unpcklps_a_or_avx.
pub fn constructor_x64_unpcklps_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vunpcklps_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 6305.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_unpcklps_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 6308.
    return v5;
}

// Generated as internal constructor for term x64_unpcklpd_a.
pub fn constructor_x64_unpcklpd_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_unpcklpd_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 6313.
    return v3;
}

// Generated as internal constructor for term x64_unpcklpd_a_or_avx.
pub fn constructor_x64_unpcklpd_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vunpcklpd_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 6315.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_unpcklpd_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 6318.
    return v5;
}

// Generated as internal constructor for term x64_unpckhps_a.
pub fn constructor_x64_unpckhps_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_unpckhps_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 6323.
    return v3;
}

// Generated as internal constructor for term x64_unpckhps_a_or_avx.
pub fn constructor_x64_unpckhps_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vunpckhps_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 6325.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_unpckhps_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 6328.
    return v5;
}

// Generated as internal constructor for term x64_vunpcklps_b.
pub fn constructor_x64_vunpcklps_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vunpcklps_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 6333.
    return v3;
}

// Generated as internal constructor for term x64_vunpcklpd_b.
pub fn constructor_x64_vunpcklpd_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vunpcklpd_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 6338.
    return v3;
}

// Generated as internal constructor for term x64_vunpckhps_b.
pub fn constructor_x64_vunpckhps_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vunpckhps_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 6343.
    return v3;
}

// Generated as internal constructor for term x64_punpckhbw_a.
pub fn constructor_x64_punpckhbw_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_punpckhbw_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 6348.
    return v3;
}

// Generated as internal constructor for term x64_punpckhbw_a_or_avx.
pub fn constructor_x64_punpckhbw_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vpunpckhbw_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 6350.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_punpckhbw_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 6353.
    return v5;
}

// Generated as internal constructor for term x64_punpckhwd_a.
pub fn constructor_x64_punpckhwd_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_punpckhwd_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 6358.
    return v3;
}

// Generated as internal constructor for term x64_punpckhwd_a_or_avx.
pub fn constructor_x64_punpckhwd_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vpunpckhwd_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 6360.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_punpckhwd_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 6363.
    return v5;
}

// Generated as internal constructor for term x64_punpckhdq_a.
pub fn constructor_x64_punpckhdq_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_punpckhdq_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 6368.
    return v3;
}

// Generated as internal constructor for term x64_punpckhdq_a_or_avx.
pub fn constructor_x64_punpckhdq_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vpunpckhdq_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 6370.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_punpckhdq_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 6373.
    return v5;
}

// Generated as internal constructor for term x64_punpckhqdq_a.
pub fn constructor_x64_punpckhqdq_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_punpckhqdq_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 6378.
    return v3;
}

// Generated as internal constructor for term x64_punpckhqdq_a_or_avx.
pub fn constructor_x64_punpckhqdq_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vpunpckhqdq_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 6380.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_punpckhqdq_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 6383.
    return v5;
}

// Generated as internal constructor for term x64_punpcklwd_a.
pub fn constructor_x64_punpcklwd_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_punpcklwd_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 6388.
    return v3;
}

// Generated as internal constructor for term x64_punpcklwd_a_or_avx.
pub fn constructor_x64_punpcklwd_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vpunpcklwd_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 6390.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_punpcklwd_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 6393.
    return v5;
}

// Generated as internal constructor for term x64_punpcklbw_a.
pub fn constructor_x64_punpcklbw_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_punpcklbw_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 6398.
    return v3;
}

// Generated as internal constructor for term x64_punpcklbw_a_or_avx.
pub fn constructor_x64_punpcklbw_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vpunpcklbw_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 6400.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_punpcklbw_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 6403.
    return v5;
}

// Generated as internal constructor for term x64_punpckldq_a.
pub fn constructor_x64_punpckldq_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_punpckldq_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 6408.
    return v3;
}

// Generated as internal constructor for term x64_punpckldq_a_or_avx.
pub fn constructor_x64_punpckldq_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vpunpckldq_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 6410.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_punpckldq_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 6413.
    return v5;
}

// Generated as internal constructor for term x64_punpcklqdq_a.
pub fn constructor_x64_punpcklqdq_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_punpcklqdq_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 6418.
    return v3;
}

// Generated as internal constructor for term x64_punpcklqdq_a_or_avx.
pub fn constructor_x64_punpcklqdq_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vpunpcklqdq_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 6420.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_punpcklqdq_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 6423.
    return v5;
}

// Generated as internal constructor for term x64_vpunpckhbw_b.
pub fn constructor_x64_vpunpckhbw_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vpunpckhbw_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 6428.
    return v3;
}

// Generated as internal constructor for term x64_vpunpckhwd_b.
pub fn constructor_x64_vpunpckhwd_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vpunpckhwd_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 6433.
    return v3;
}

// Generated as internal constructor for term x64_vpunpckhdq_b.
pub fn constructor_x64_vpunpckhdq_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vpunpckhdq_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 6438.
    return v3;
}

// Generated as internal constructor for term x64_vpunpckhqdq_b.
pub fn constructor_x64_vpunpckhqdq_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vpunpckhqdq_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 6443.
    return v3;
}

// Generated as internal constructor for term x64_vpunpcklwd_b.
pub fn constructor_x64_vpunpcklwd_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vpunpcklwd_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 6448.
    return v3;
}

// Generated as internal constructor for term x64_vpunpcklbw_b.
pub fn constructor_x64_vpunpcklbw_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vpunpcklbw_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 6453.
    return v3;
}

// Generated as internal constructor for term x64_vpunpckldq_b.
pub fn constructor_x64_vpunpckldq_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vpunpckldq_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 6458.
    return v3;
}

// Generated as internal constructor for term x64_vpunpcklqdq_b.
pub fn constructor_x64_vpunpcklqdq_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vpunpcklqdq_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 6463.
    return v3;
}

// Generated as internal constructor for term x64_xorb_i.
pub fn constructor_x64_xorb_i<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: u8,
) -> Gpr {
    let v2 = &C::x64_xorb_i_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 6468.
    return v3;
}

// Generated as internal constructor for term x64_xorw_i.
pub fn constructor_x64_xorw_i<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: u16,
) -> Gpr {
    let v2 = &C::x64_xorw_i_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 6473.
    return v3;
}

// Generated as internal constructor for term x64_xorl_i.
pub fn constructor_x64_xorl_i<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: u32,
) -> Gpr {
    let v2 = &C::x64_xorl_i_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 6478.
    return v3;
}

// Generated as internal constructor for term x64_xorq_i_sxl.
pub fn constructor_x64_xorq_i_sxl<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: i32,
) -> Gpr {
    let v2 = &C::x64_xorq_i_sxl_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 6483.
    return v3;
}

// Generated as internal constructor for term x64_xorb_mi.
pub fn constructor_x64_xorb_mi<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: u8,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_xorb_mi_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 6488.
    return v4;
}

// Generated as internal constructor for term x64_xorb_mi_mem.
pub fn constructor_x64_xorb_mi_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: u8,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_xorb_mi_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 6490.
    return v4.clone();
}

// Generated as internal constructor for term x64_xorw_mi.
pub fn constructor_x64_xorw_mi<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: u16,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_xorw_mi_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 6495.
    return v4;
}

// Generated as internal constructor for term x64_xorw_mi_mem.
pub fn constructor_x64_xorw_mi_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: u16,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_xorw_mi_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 6497.
    return v4.clone();
}

// Generated as internal constructor for term x64_xorl_mi.
pub fn constructor_x64_xorl_mi<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: u32,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_xorl_mi_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 6502.
    return v4;
}

// Generated as internal constructor for term x64_xorl_mi_mem.
pub fn constructor_x64_xorl_mi_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: u32,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_xorl_mi_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 6504.
    return v4.clone();
}

// Generated as internal constructor for term x64_xorq_mi_sxl.
pub fn constructor_x64_xorq_mi_sxl<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: i32,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_xorq_mi_sxl_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 6509.
    return v4;
}

// Generated as internal constructor for term x64_xorq_mi_sxl_mem.
pub fn constructor_x64_xorq_mi_sxl_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: i32,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_xorq_mi_sxl_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 6511.
    return v4.clone();
}

// Generated as internal constructor for term x64_xorl_mi_sxb.
pub fn constructor_x64_xorl_mi_sxb<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: i8,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_xorl_mi_sxb_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 6516.
    return v4;
}

// Generated as internal constructor for term x64_xorl_mi_sxb_mem.
pub fn constructor_x64_xorl_mi_sxb_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: i8,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_xorl_mi_sxb_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 6518.
    return v4.clone();
}

// Generated as internal constructor for term x64_xorq_mi_sxb.
pub fn constructor_x64_xorq_mi_sxb<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: i8,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_xorq_mi_sxb_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 6523.
    return v4;
}

// Generated as internal constructor for term x64_xorq_mi_sxb_mem.
pub fn constructor_x64_xorq_mi_sxb_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: i8,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_xorq_mi_sxb_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 6525.
    return v4.clone();
}

// Generated as internal constructor for term x64_xorb_mr.
pub fn constructor_x64_xorb_mr<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: Gpr,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_xorb_mr_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 6530.
    return v4;
}

// Generated as internal constructor for term x64_xorb_mr_mem.
pub fn constructor_x64_xorb_mr_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Gpr,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_xorb_mr_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 6532.
    return v4.clone();
}

// Generated as internal constructor for term x64_xorw_mr.
pub fn constructor_x64_xorw_mr<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: Gpr,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_xorw_mr_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 6537.
    return v4;
}

// Generated as internal constructor for term x64_xorw_mr_mem.
pub fn constructor_x64_xorw_mr_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Gpr,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_xorw_mr_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 6539.
    return v4.clone();
}

// Generated as internal constructor for term x64_xorl_mr.
pub fn constructor_x64_xorl_mr<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: Gpr,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_xorl_mr_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 6544.
    return v4;
}

// Generated as internal constructor for term x64_xorl_mr_mem.
pub fn constructor_x64_xorl_mr_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Gpr,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_xorl_mr_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 6546.
    return v4.clone();
}

// Generated as internal constructor for term x64_xorq_mr.
pub fn constructor_x64_xorq_mr<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: Gpr,
) -> Gpr {
    let v2 = &C::gpr_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_xorq_mr_raw(ctx, v2, arg1);
    let v4 = constructor_emit_ret_gpr(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 6551.
    return v4;
}

// Generated as internal constructor for term x64_xorq_mr_mem.
pub fn constructor_x64_xorq_mr_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Gpr,
) -> SideEffectNoResult {
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg0);
    let v3 = &C::x64_xorq_mr_raw(ctx, v2, arg1);
    let v4 = &constructor_defer_side_effect(ctx, v3);
    // Rule at <OUT_DIR>/assembler.isle line 6553.
    return v4.clone();
}

// Generated as internal constructor for term x64_xorb_rm.
pub fn constructor_x64_xorb_rm<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
) -> Gpr {
    let v2 = &C::x64_xorb_rm_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 6558.
    return v3;
}

// Generated as internal constructor for term x64_xorw_rm.
pub fn constructor_x64_xorw_rm<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
) -> Gpr {
    let v2 = &C::x64_xorw_rm_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 6563.
    return v3;
}

// Generated as internal constructor for term x64_xorl_rm.
pub fn constructor_x64_xorl_rm<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
) -> Gpr {
    let v2 = &C::x64_xorl_rm_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 6568.
    return v3;
}

// Generated as internal constructor for term x64_xorq_rm.
pub fn constructor_x64_xorq_rm<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
) -> Gpr {
    let v2 = &C::x64_xorq_rm_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_gpr(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 6573.
    return v3;
}

// Generated as internal constructor for term x64_lock_xorb_mi_mem.
pub fn constructor_x64_lock_xorb_mi_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: u8,
) -> SideEffectNoResult {
    let v2 = &C::x64_lock_xorb_mi_raw(ctx, arg0, arg1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 6578.
    return v3.clone();
}

// Generated as internal constructor for term x64_lock_xorw_mi_mem.
pub fn constructor_x64_lock_xorw_mi_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: u16,
) -> SideEffectNoResult {
    let v2 = &C::x64_lock_xorw_mi_raw(ctx, arg0, arg1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 6583.
    return v3.clone();
}

// Generated as internal constructor for term x64_lock_xorl_mi_mem.
pub fn constructor_x64_lock_xorl_mi_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: u32,
) -> SideEffectNoResult {
    let v2 = &C::x64_lock_xorl_mi_raw(ctx, arg0, arg1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 6588.
    return v3.clone();
}

// Generated as internal constructor for term x64_lock_xorq_mi_sxl_mem.
pub fn constructor_x64_lock_xorq_mi_sxl_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: i32,
) -> SideEffectNoResult {
    let v2 = &C::x64_lock_xorq_mi_sxl_raw(ctx, arg0, arg1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 6593.
    return v3.clone();
}

// Generated as internal constructor for term x64_lock_xorl_mi_sxb_mem.
pub fn constructor_x64_lock_xorl_mi_sxb_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: i8,
) -> SideEffectNoResult {
    let v2 = &C::x64_lock_xorl_mi_sxb_raw(ctx, arg0, arg1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 6598.
    return v3.clone();
}

// Generated as internal constructor for term x64_lock_xorq_mi_sxb_mem.
pub fn constructor_x64_lock_xorq_mi_sxb_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: i8,
) -> SideEffectNoResult {
    let v2 = &C::x64_lock_xorq_mi_sxb_raw(ctx, arg0, arg1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 6603.
    return v3.clone();
}

// Generated as internal constructor for term x64_lock_xorb_mr_mem.
pub fn constructor_x64_lock_xorb_mr_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Gpr,
) -> SideEffectNoResult {
    let v2 = &C::x64_lock_xorb_mr_raw(ctx, arg0, arg1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 6608.
    return v3.clone();
}

// Generated as internal constructor for term x64_lock_xorw_mr_mem.
pub fn constructor_x64_lock_xorw_mr_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Gpr,
) -> SideEffectNoResult {
    let v2 = &C::x64_lock_xorw_mr_raw(ctx, arg0, arg1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 6613.
    return v3.clone();
}

// Generated as internal constructor for term x64_lock_xorl_mr_mem.
pub fn constructor_x64_lock_xorl_mr_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Gpr,
) -> SideEffectNoResult {
    let v2 = &C::x64_lock_xorl_mr_raw(ctx, arg0, arg1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 6618.
    return v3.clone();
}

// Generated as internal constructor for term x64_lock_xorq_mr_mem.
pub fn constructor_x64_lock_xorq_mr_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Gpr,
) -> SideEffectNoResult {
    let v2 = &C::x64_lock_xorq_mr_raw(ctx, arg0, arg1);
    let v3 = &constructor_defer_side_effect(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 6623.
    return v3.clone();
}

// Generated as internal constructor for term x64_xorps_a.
pub fn constructor_x64_xorps_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_xorps_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 6628.
    return v3;
}

// Generated as internal constructor for term x64_xorps_a_or_avx.
pub fn constructor_x64_xorps_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vxorps_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 6630.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_xorps_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 6633.
    return v5;
}

// Generated as internal constructor for term x64_xorpd_a.
pub fn constructor_x64_xorpd_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_xorpd_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 6638.
    return v3;
}

// Generated as internal constructor for term x64_xorpd_a_or_avx.
pub fn constructor_x64_xorpd_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vxorpd_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 6640.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_xorpd_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 6643.
    return v5;
}

// Generated as internal constructor for term x64_pxor_a.
pub fn constructor_x64_pxor_a<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = &C::x64_pxor_a_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 6648.
    return v3;
}

// Generated as internal constructor for term x64_pxor_a_or_avx.
pub fn constructor_x64_pxor_a_or_avx<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::has_avx(ctx);
    if v2 == true {
        let v3 = constructor_x64_vpxor_b(ctx, arg0, arg1);
        // Rule at <OUT_DIR>/assembler.isle line 6650.
        return v3;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_x64_pxor_a(ctx, arg0, v4);
    // Rule at <OUT_DIR>/assembler.isle line 6653.
    return v5;
}

// Generated as internal constructor for term x64_vxorps_b.
pub fn constructor_x64_vxorps_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vxorps_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 6658.
    return v3;
}

// Generated as internal constructor for term x64_vxorpd_b.
pub fn constructor_x64_vxorpd_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vxorpd_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 6663.
    return v3;
}

// Generated as internal constructor for term x64_vpxor_b.
pub fn constructor_x64_vpxor_b<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = &C::x64_vpxor_b_raw(ctx, arg0, arg1);
    let v3 = constructor_emit_ret_xmm(ctx, v2);
    // Rule at <OUT_DIR>/assembler.isle line 6668.
    return v3;
}
