// 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_udiv(&mut self, arg0: Type, arg1: Imm64, arg2: Imm64) -> Option<Imm64>;
    fn imm64_srem(&mut self, arg0: Type, arg1: Imm64, arg2: Imm64) -> Option<Imm64>;
    fn imm64_urem(&mut self, arg0: Type, arg1: Imm64, arg2: Imm64) -> Option<Imm64>;
    fn imm64_add(&mut self, arg0: Type, arg1: Imm64, arg2: Imm64) -> Imm64;
    fn imm64_sub(&mut self, arg0: Type, arg1: Imm64, arg2: Imm64) -> Imm64;
    fn imm64_mul(&mut self, arg0: Type, arg1: Imm64, arg2: Imm64) -> Imm64;
    fn imm64_and(&mut self, arg0: Type, arg1: Imm64, arg2: Imm64) -> Imm64;
    fn imm64_or(&mut self, arg0: Type, arg1: Imm64, arg2: Imm64) -> Imm64;
    fn imm64_xor(&mut self, arg0: Type, arg1: Imm64, arg2: Imm64) -> Imm64;
    fn imm64_not(&mut self, arg0: Type, arg1: Imm64) -> Imm64;
    fn imm64_neg(&mut self, arg0: Type, arg1: Imm64) -> Imm64;
    fn imm64_abs(&mut self, arg0: Type, arg1: Imm64) -> Option<Imm64>;
    fn imm64_ilog2(&mut self, arg0: Type, arg1: Imm64) -> Option<Imm64>;
    fn imm64_umin(&mut self, arg0: Type, arg1: Imm64, arg2: Imm64) -> Imm64;
    fn imm64_umax(&mut self, arg0: Type, arg1: Imm64, arg2: Imm64) -> Imm64;
    fn imm64_smin(&mut self, arg0: Type, arg1: Imm64, arg2: Imm64) -> Imm64;
    fn imm64_smax(&mut self, arg0: Type, arg1: Imm64, arg2: Imm64) -> Imm64;
    fn imm64_shl(&mut self, arg0: Type, arg1: Imm64, arg2: Imm64) -> Imm64;
    fn imm64_ushr(&mut self, arg0: Type, arg1: Imm64, arg2: Imm64) -> Imm64;
    fn imm64_sshr(&mut self, arg0: Type, arg1: Imm64, arg2: Imm64) -> Imm64;
    fn imm64_rotl(&mut self, arg0: Type, arg1: Imm64, arg2: Imm64) -> Imm64;
    fn imm64_rotr(&mut self, arg0: Type, arg1: Imm64, arg2: Imm64) -> Imm64;
    fn i64_sextend_u64(&mut self, arg0: Type, arg1: u64) -> i64;
    fn i64_sextend_imm64(&mut self, arg0: Type, arg1: Imm64) -> i64;
    fn u64_uextend_imm64(&mut self, arg0: Type, arg1: Imm64) -> u64;
    fn imm64_icmp(&mut self, arg0: Type, arg1: &IntCC, arg2: Imm64, arg3: Imm64) -> Imm64;
    fn imm64_clz(&mut self, arg0: Type, arg1: Imm64) -> Imm64;
    fn imm64_ctz(&mut self, arg0: Type, arg1: Imm64) -> Imm64;
    fn u128_replicated_u64(&mut self, arg0: u128) -> Option<u64>;
    fn u64_replicated_u32(&mut self, arg0: u64) -> Option<u32>;
    fn u32_replicated_u16(&mut self, arg0: u32) -> Option<u16>;
    fn u16_replicated_u8(&mut self, arg0: u16) -> Option<u8>;
    fn u128_low_bits(&mut self, arg0: u128) -> u64;
    fn u128_high_bits(&mut self, arg0: u128) -> u64;
    fn f16_min(&mut self, arg0: Ieee16, arg1: Ieee16) -> Option<Ieee16>;
    fn f16_max(&mut self, arg0: Ieee16, arg1: Ieee16) -> Option<Ieee16>;
    fn f16_neg(&mut self, arg0: Ieee16) -> Ieee16;
    fn f16_abs(&mut self, arg0: Ieee16) -> Ieee16;
    fn f16_copysign(&mut self, arg0: Ieee16, arg1: Ieee16) -> Ieee16;
    fn f32_add(&mut self, arg0: Ieee32, arg1: Ieee32) -> Option<Ieee32>;
    fn f32_sub(&mut self, arg0: Ieee32, arg1: Ieee32) -> Option<Ieee32>;
    fn f32_mul(&mut self, arg0: Ieee32, arg1: Ieee32) -> Option<Ieee32>;
    fn f32_div(&mut self, arg0: Ieee32, arg1: Ieee32) -> Option<Ieee32>;
    fn f32_sqrt(&mut self, arg0: Ieee32) -> Option<Ieee32>;
    fn f32_ceil(&mut self, arg0: Ieee32) -> Option<Ieee32>;
    fn f32_floor(&mut self, arg0: Ieee32) -> Option<Ieee32>;
    fn f32_trunc(&mut self, arg0: Ieee32) -> Option<Ieee32>;
    fn f32_nearest(&mut self, arg0: Ieee32) -> Option<Ieee32>;
    fn f32_min(&mut self, arg0: Ieee32, arg1: Ieee32) -> Option<Ieee32>;
    fn f32_max(&mut self, arg0: Ieee32, arg1: Ieee32) -> Option<Ieee32>;
    fn f32_neg(&mut self, arg0: Ieee32) -> Ieee32;
    fn f32_abs(&mut self, arg0: Ieee32) -> Ieee32;
    fn f32_copysign(&mut self, arg0: Ieee32, arg1: Ieee32) -> Ieee32;
    fn f64_add(&mut self, arg0: Ieee64, arg1: Ieee64) -> Option<Ieee64>;
    fn f64_sub(&mut self, arg0: Ieee64, arg1: Ieee64) -> Option<Ieee64>;
    fn f64_mul(&mut self, arg0: Ieee64, arg1: Ieee64) -> Option<Ieee64>;
    fn f64_div(&mut self, arg0: Ieee64, arg1: Ieee64) -> Option<Ieee64>;
    fn f64_sqrt(&mut self, arg0: Ieee64) -> Option<Ieee64>;
    fn f64_ceil(&mut self, arg0: Ieee64) -> Option<Ieee64>;
    fn f64_floor(&mut self, arg0: Ieee64) -> Option<Ieee64>;
    fn f64_trunc(&mut self, arg0: Ieee64) -> Option<Ieee64>;
    fn f64_nearest(&mut self, arg0: Ieee64) -> Option<Ieee64>;
    fn f64_min(&mut self, arg0: Ieee64, arg1: Ieee64) -> Option<Ieee64>;
    fn f64_max(&mut self, arg0: Ieee64, arg1: Ieee64) -> Option<Ieee64>;
    fn f64_neg(&mut self, arg0: Ieee64) -> Ieee64;
    fn f64_abs(&mut self, arg0: Ieee64) -> Ieee64;
    fn f64_copysign(&mut self, arg0: Ieee64, arg1: Ieee64) -> Ieee64;
    fn f128_min(&mut self, arg0: Ieee128, arg1: Ieee128) -> Option<Ieee128>;
    fn f128_max(&mut self, arg0: Ieee128, arg1: Ieee128) -> Option<Ieee128>;
    fn f128_neg(&mut self, arg0: Ieee128) -> Ieee128;
    fn f128_abs(&mut self, arg0: Ieee128) -> Ieee128;
    fn f128_copysign(&mut self, arg0: Ieee128, arg1: Ieee128) -> Ieee128;
    fn ty_umin(&mut self, arg0: Type) -> u64;
    fn ty_umax(&mut self, arg0: Type) -> u64;
    fn ty_smin(&mut self, arg0: Type) -> u64;
    fn ty_smax(&mut self, arg0: Type) -> u64;
    fn ty_bits(&mut self, arg0: Type) -> u8;
    fn ty_bits_u16(&mut self, arg0: Type) -> u16;
    fn ty_bits_u64(&mut self, arg0: Type) -> u64;
    fn ty_mask(&mut self, arg0: Type) -> u64;
    fn ty_lane_mask(&mut self, arg0: Type) -> u64;
    fn ty_lane_count(&mut self, arg0: Type) -> u64;
    fn ty_bytes(&mut self, arg0: Type) -> u16;
    fn lane_type(&mut self, arg0: Type) -> Type;
    fn ty_half_lanes(&mut self, arg0: Type) -> Option<Type>;
    fn ty_half_width(&mut self, arg0: Type) -> Option<Type>;
    fn ty_equal(&mut self, arg0: Type, arg1: Type) -> bool;
    fn mem_flags_trusted(&mut self, ) -> MemFlags;
    fn mem_flags_data(&mut self, arg0: MemFlags) -> Option<MemFlagsData>;
    fn mem_flags_intern(&mut self, arg0: MemFlagsData) -> MemFlags;
    fn mem_flags_trusted_data(&mut self, ) -> MemFlagsData;
    fn little_or_native_endian(&mut self, arg0: MemFlags) -> Option<MemFlagsData>;
    fn intcc_swap_args(&mut self, arg0: &IntCC) -> IntCC;
    fn intcc_complement(&mut self, arg0: &IntCC) -> IntCC;
    fn intcc_without_eq(&mut self, arg0: &IntCC) -> IntCC;
    fn floatcc_swap_args(&mut self, arg0: &FloatCC) -> FloatCC;
    fn floatcc_complement(&mut self, arg0: &FloatCC) -> FloatCC;
    fn floatcc_unordered(&mut self, arg0: &FloatCC) -> bool;
    fn fits_in_16(&mut self, arg0: Type) -> Option<Type>;
    fn fits_in_32(&mut self, arg0: Type) -> Option<Type>;
    fn lane_fits_in_32(&mut self, arg0: Type) -> Option<Type>;
    fn fits_in_64(&mut self, arg0: Type) -> Option<Type>;
    fn ty_16(&mut self, arg0: Type) -> Option<Type>;
    fn ty_32(&mut self, arg0: Type) -> Option<Type>;
    fn ty_64(&mut self, arg0: Type) -> Option<Type>;
    fn ty_128(&mut self, arg0: Type) -> Option<Type>;
    fn ty_int_ref_scalar_64_extract(&mut self, arg0: Type) -> Option<Type>;
    fn ty_int_ref_scalar_64(&mut self, arg0: Type) -> Option<Type>;
    fn ty_32_or_64(&mut self, arg0: Type) -> Option<Type>;
    fn ty_8_or_16(&mut self, arg0: Type) -> Option<Type>;
    fn ty_16_or_32(&mut self, arg0: Type) -> Option<Type>;
    fn int_fits_in_32(&mut self, arg0: Type) -> Option<Type>;
    fn ty_int_ref_64(&mut self, arg0: Type) -> Option<Type>;
    fn ty_int_ref_16_to_64(&mut self, arg0: Type) -> Option<Type>;
    fn ty_int(&mut self, arg0: Type) -> Option<Type>;
    fn ty_scalar(&mut self, arg0: Type) -> Option<Type>;
    fn ty_scalar_float(&mut self, arg0: Type) -> Option<Type>;
    fn ty_float_or_vec(&mut self, arg0: Type) -> Option<Type>;
    fn ty_vector_float(&mut self, arg0: Type) -> Option<Type>;
    fn ty_vector_not_float(&mut self, arg0: Type) -> Option<Type>;
    fn ty_vec64(&mut self, arg0: Type) -> Option<Type>;
    fn ty_vec64_ctor(&mut self, arg0: Type) -> Option<Type>;
    fn ty_vec128(&mut self, arg0: Type) -> Option<Type>;
    fn ty_int_vec128(&mut self, arg0: Type) -> Option<Type>;
    fn ty_dyn_vec64(&mut self, arg0: Type) -> Option<Type>;
    fn ty_dyn_vec128(&mut self, arg0: Type) -> Option<Type>;
    fn ty_vec64_int(&mut self, arg0: Type) -> Option<Type>;
    fn ty_vec128_int(&mut self, arg0: Type) -> Option<Type>;
    fn ty_addr64(&mut self, arg0: Type) -> Option<Type>;
    fn not_vec32x2(&mut self, arg0: Type) -> Option<Type>;
    fn not_i64x2(&mut self, arg0: Type) -> Option<()>;
    fn u8_from_uimm8(&mut self, arg0: Uimm8) -> u8;
    fn u64_from_bool(&mut self, arg0: bool) -> u64;
    fn u64_from_imm64(&mut self, arg0: Imm64) -> u64;
    fn nonzero_u64_from_imm64(&mut self, arg0: Imm64) -> Option<u64>;
    fn imm64_power_of_two(&mut self, arg0: Imm64) -> Option<u64>;
    fn imm64(&mut self, arg0: u64) -> Imm64;
    fn imm64_masked(&mut self, arg0: Type, arg1: u64) -> Imm64;
    fn u16_from_ieee16(&mut self, arg0: Ieee16) -> u16;
    fn u32_from_ieee32(&mut self, arg0: Ieee32) -> u32;
    fn u64_from_ieee64(&mut self, arg0: Ieee64) -> u64;
    fn multi_lane(&mut self, arg0: Type) -> Option<(u32, u32)>;
    fn dynamic_lane(&mut self, arg0: Type) -> Option<(u32, u32)>;
    fn ty_dyn64_int(&mut self, arg0: Type) -> Option<Type>;
    fn ty_dyn128_int(&mut self, arg0: Type) -> Option<Type>;
    fn offset32_to_i32(&mut self, arg0: Offset32) -> i32;
    fn i32_to_offset32(&mut self, arg0: i32) -> Offset32;
    fn intcc_unsigned(&mut self, arg0: &IntCC) -> IntCC;
    fn signed_cond_code(&mut self, arg0: &IntCC) -> Option<IntCC>;
    fn unsigned_cond_code(&mut self, arg0: &IntCC) -> Option<IntCC>;
    fn trap_code_division_by_zero(&mut self, ) -> TrapCode;
    fn trap_code_integer_overflow(&mut self, ) -> TrapCode;
    fn trap_code_bad_conversion_to_integer(&mut self, ) -> TrapCode;
    fn value_reg(&mut self, arg0: Reg) -> ValueRegs;
    fn writable_value_reg(&mut self, arg0: WritableReg) -> WritableValueRegs;
    fn value_regs(&mut self, arg0: Reg, arg1: Reg) -> ValueRegs;
    fn writable_value_regs(&mut self, arg0: WritableReg, arg1: WritableReg) -> WritableValueRegs;
    fn value_regs_invalid(&mut self, ) -> ValueRegs;
    fn output_none(&mut self, ) -> InstOutput;
    fn output(&mut self, arg0: ValueRegs) -> InstOutput;
    fn output_pair(&mut self, arg0: ValueRegs, arg1: ValueRegs) -> InstOutput;
    fn output_vec(&mut self, arg0: &ValueRegsVec) -> InstOutput;
    fn temp_writable_reg(&mut self, arg0: Type) -> WritableReg;
    fn is_valid_reg(&mut self, arg0: Reg) -> bool;
    fn invalid_reg(&mut self, ) -> Reg;
    fn mark_value_used(&mut self, arg0: Value) -> Unit;
    fn put_in_reg(&mut self, arg0: Value) -> Reg;
    fn put_in_regs(&mut self, arg0: Value) -> ValueRegs;
    fn put_in_regs_vec(&mut self, arg0: ValueSlice) -> ValueRegsVec;
    fn value_regs_get(&mut self, arg0: ValueRegs, arg1: usize) -> Reg;
    fn value_regs_len(&mut self, arg0: ValueRegs) -> usize;
    fn preg_to_reg(&mut self, arg0: PReg) -> Reg;
    fn single_target(&mut self, arg0: &MachLabelSlice) -> Option<MachLabel>;
    fn two_targets(&mut self, arg0: &MachLabelSlice) -> Option<(MachLabel, MachLabel)>;
    fn jump_table_targets(&mut self, arg0: &MachLabelSlice) -> Option<(MachLabel, BoxVecMachLabel)>;
    fn jump_table_size(&mut self, arg0: &BoxVecMachLabel) -> u32;
    fn value_list_slice(&mut self, arg0: ValueList) -> ValueSlice;
    fn value_slice_empty(&mut self, arg0: ValueSlice) -> Option<()>;
    fn value_slice_unwrap(&mut self, arg0: ValueSlice) -> Option<(Value, ValueSlice)>;
    fn value_slice_len(&mut self, arg0: ValueSlice) -> usize;
    fn value_slice_get(&mut self, arg0: ValueSlice, arg1: usize) -> Value;
    fn writable_reg_to_reg(&mut self, arg0: WritableReg) -> Reg;
    fn inst_results(&mut self, arg0: Inst) -> ValueSlice;
    fn value_is_unused(&mut self, arg0: Value) -> bool;
    fn first_result(&mut self, arg0: Inst) -> Option<Value>;
    fn inst_data_value(&mut self, arg0: Inst) -> (Type, InstructionData);
    fn i64_from_iconst(&mut self, arg0: Value) -> Option<i64>;
    fn zero_value(&mut self, arg0: Value) -> Option<Value>;
    fn is_sinkable_inst(&mut self, arg0: Value) -> Option<Inst>;
    fn maybe_uextend(&mut self, arg0: Value) -> Option<Value>;
    fn uimm8(&mut self, arg0: Imm64) -> Option<u8>;
    fn block_exn_successor_label(&mut self, arg0: &Block, arg1: u64) -> MachLabel;
    fn emit(&mut self, arg0: &MInst) -> Unit;
    fn sink_inst(&mut self, arg0: Inst) -> Unit;
    fn emit_u64_le_const(&mut self, arg0: u64) -> VCodeConstant;
    fn emit_u64_be_const(&mut self, arg0: u64) -> VCodeConstant;
    fn emit_u128_le_const(&mut self, arg0: u128) -> VCodeConstant;
    fn emit_u128_be_const(&mut self, arg0: u128) -> VCodeConstant;
    fn const_to_vconst(&mut self, arg0: Constant) -> VCodeConstant;
    fn tls_model(&mut self, arg0: Type) -> TlsModel;
    fn tls_model_is_elf_gd(&mut self, ) -> Option<Unit>;
    fn tls_model_is_macho(&mut self, ) -> Option<Unit>;
    fn tls_model_is_coff(&mut self, ) -> Option<Unit>;
    fn preserve_frame_pointers(&mut self, ) -> Option<Unit>;
    fn stack_switch_model(&mut self, ) -> Option<StackSwitchModel>;
    fn box_external_name(&mut self, arg0: ExternalName) -> BoxExternalName;
    fn func_ref_data(&mut self, arg0: FuncRef) -> (SigRef, ExternalName, RelocDistance, bool);
    fn exception_sig(&mut self, arg0: ExceptionTable) -> SigRef;
    fn symbol_value_data(&mut self, arg0: GlobalValue) -> Option<(ExternalName, RelocDistance, i64)>;
    fn vec_mask_from_immediate(&mut self, arg0: Immediate) -> Option<VecMask>;
    fn u128_from_immediate(&mut self, arg0: Immediate) -> Option<u128>;
    fn vconst_from_immediate(&mut self, arg0: Immediate) -> Option<VCodeConstant>;
    fn u128_from_constant(&mut self, arg0: Constant) -> Option<u128>;
    fn u64_from_constant(&mut self, arg0: Constant) -> Option<u64>;
    fn shuffle64_from_imm(&mut self, arg0: Immediate) -> Option<(u8, u8)>;
    fn shuffle32_from_imm(&mut self, arg0: Immediate) -> Option<(u8, u8, u8, u8)>;
    fn shuffle16_from_imm(&mut self, arg0: Immediate) -> Option<(u8, u8, u8, u8, u8, u8, u8, u8)>;
    fn only_writable_reg(&mut self, arg0: WritableValueRegs) -> Option<WritableReg>;
    fn writable_regs_get(&mut self, arg0: WritableValueRegs, arg1: usize) -> WritableReg;
    fn abi_sig(&mut self, arg0: SigRef) -> Sig;
    fn abi_num_args(&mut self, arg0: Sig) -> usize;
    fn abi_get_arg(&mut self, arg0: Sig, arg1: usize) -> ABIArg;
    fn abi_num_rets(&mut self, arg0: Sig) -> usize;
    fn abi_get_ret(&mut self, arg0: Sig, arg1: usize) -> ABIArg;
    fn abi_ret_arg(&mut self, arg0: Sig) -> Option<ABIArg>;
    fn abi_no_ret_arg(&mut self, arg0: Sig) -> Option<()>;
    fn abi_unwrap_ret_area_ptr(&mut self, ) -> Reg;
    fn abi_stackslot_addr(&mut self, arg0: WritableReg, arg1: StackSlot, arg2: Offset32) -> MInst;
    fn abi_stackslot_offset_into_slot_region(&mut self, arg0: StackSlot, arg1: Offset32, arg2: Offset32) -> i32;
    fn abi_dynamic_stackslot_addr(&mut self, arg0: WritableReg, arg1: DynamicStackSlot) -> MInst;
    fn abi_arg_only_slot(&mut self, arg0: &ABIArg) -> Option<ABIArgSlot>;
    fn abi_arg_implicit_pointer(&mut self, arg0: &ABIArg) -> Option<(ABIArgSlot, i64, Type)>;
    fn real_reg_to_reg(&mut self, arg0: RealReg) -> Reg;
    fn real_reg_to_writable_reg(&mut self, arg0: RealReg) -> WritableReg;
    fn gen_move(&mut self, arg0: Type, arg1: WritableReg, arg2: Reg) -> MInst;
    fn gen_return(&mut self, arg0: &ValueRegsVec) -> Unit;
    fn gen_call_output(&mut self, arg0: SigRef) -> ValueRegsVec;
    fn gen_call_args(&mut self, arg0: Sig, arg1: &ValueRegsVec) -> CallArgList;
    fn gen_return_call_args(&mut self, arg0: Sig, arg1: &ValueRegsVec) -> CallArgList;
    fn gen_call_rets(&mut self, arg0: Sig, arg1: &ValueRegsVec) -> CallRetList;
    fn gen_try_call_rets(&mut self, arg0: Sig) -> CallRetList;
    fn gen_patchable_call_rets(&mut self, ) -> CallRetList;
    fn try_call_info(&mut self, arg0: ExceptionTable, arg1: &MachLabelSlice) -> OptionTryCallInfo;
    fn try_call_none(&mut self, ) -> OptionTryCallInfo;
    fn safe_divisor_from_imm64(&mut self, arg0: Type, arg1: Imm64) -> Option<u64>;
    fn operand_size_of_type_32_64(&mut self, arg0: Type) -> OperandSize;
    fn raw_operand_size_of_type(&mut self, arg0: Type) -> OperandSize;
    fn atomic128_rmw_seq_args(&mut self, arg0: &Atomic128RmwSeqOp, arg1: &SyntheticAmode, arg2: &SyntheticAmode, arg3: Gpr, arg4: Gpr, arg5: WritableGpr, arg6: WritableGpr, arg7: WritableGpr, arg8: WritableGpr) -> BoxAtomic128RmwSeqArgs;
    fn atomic128_xchg_seq_args(&mut self, arg0: &SyntheticAmode, arg1: &SyntheticAmode, arg2: Gpr, arg3: Gpr, arg4: WritableGpr, arg5: WritableGpr) -> BoxAtomic128XchgSeqArgs;
    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_try_offset(&mut self, arg0: &SyntheticAmode, arg1: i32) -> Option<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_gpr_mem_8(&mut self, arg0: Value) -> GprMem8;
    fn put_in_gpr_mem_imm_8(&mut self, arg0: Value) -> GprMemImm8;
    fn gpr_to_gpr_mem_8(&mut self, arg0: Gpr) -> GprMem8;
    fn gpr_to_gpr_mem_imm_8(&mut self, arg0: Gpr) -> GprMemImm8;
    fn gpr_mem_imm_8_imm(&mut self, arg0: u32) -> GprMemImm8;
    fn gpr_mem_8_to_gpr_mem(&mut self, arg0: &GprMem8) -> GprMem;
    fn gpr_mem_imm_8_to_gpr_mem_imm(&mut self, arg0: &GprMemImm8) -> GprMemImm;
    fn put_in_gpr_mem_16(&mut self, arg0: Value) -> GprMem16;
    fn put_in_gpr_mem_imm_16(&mut self, arg0: Value) -> GprMemImm16;
    fn gpr_to_gpr_mem_16(&mut self, arg0: Gpr) -> GprMem16;
    fn gpr_to_gpr_mem_imm_16(&mut self, arg0: Gpr) -> GprMemImm16;
    fn gpr_mem_imm_16_imm(&mut self, arg0: u32) -> GprMemImm16;
    fn gpr_mem_16_to_gpr_mem(&mut self, arg0: &GprMem16) -> GprMem;
    fn gpr_mem_imm_16_to_gpr_mem_imm(&mut self, arg0: &GprMemImm16) -> GprMemImm;
    fn put_in_gpr_mem_32(&mut self, arg0: Value) -> GprMem32;
    fn put_in_gpr_mem_imm_32(&mut self, arg0: Value) -> GprMemImm32;
    fn gpr_to_gpr_mem_32(&mut self, arg0: Gpr) -> GprMem32;
    fn gpr_to_gpr_mem_imm_32(&mut self, arg0: Gpr) -> GprMemImm32;
    fn gpr_mem_imm_32_imm(&mut self, arg0: u32) -> GprMemImm32;
    fn gpr_mem_32_to_gpr_mem(&mut self, arg0: &GprMem32) -> GprMem;
    fn gpr_mem_imm_32_to_gpr_mem_imm(&mut self, arg0: &GprMemImm32) -> GprMemImm;
    fn put_in_gpr_mem_64(&mut self, arg0: Value) -> GprMem64;
    fn put_in_gpr_mem_imm_64(&mut self, arg0: Value) -> GprMemImm64;
    fn gpr_to_gpr_mem_64(&mut self, arg0: Gpr) -> GprMem64;
    fn gpr_to_gpr_mem_imm_64(&mut self, arg0: Gpr) -> GprMemImm64;
    fn gpr_mem_imm_64_imm(&mut self, arg0: u32) -> GprMemImm64;
    fn gpr_mem_64_to_gpr_mem(&mut self, arg0: &GprMem64) -> GprMem;
    fn gpr_mem_imm_64_to_gpr_mem_imm(&mut self, arg0: &GprMemImm64) -> GprMemImm;
    fn put_in_xmm_mem_8(&mut self, arg0: Value) -> XmmMem8;
    fn put_in_xmm_mem_aligned_8(&mut self, arg0: Value) -> XmmMemAligned8;
    fn put_in_xmm_mem_imm_8(&mut self, arg0: Value) -> XmmMemImm8;
    fn put_in_xmm_mem_aligned_imm_8(&mut self, arg0: Value) -> XmmMemAlignedImm8;
    fn xmm_to_xmm_mem_8(&mut self, arg0: Xmm) -> XmmMem8;
    fn xmm_to_xmm_mem_aligned_8(&mut self, arg0: Xmm) -> XmmMemAligned8;
    fn xmm_to_xmm_mem_imm_8(&mut self, arg0: Xmm) -> XmmMemImm8;
    fn xmm_to_xmm_mem_aligned_imm_8(&mut self, arg0: Xmm) -> XmmMemAlignedImm8;
    fn xmm_mem_imm_8_imm(&mut self, arg0: u32) -> XmmMemImm8;
    fn xmm_mem_8_to_xmm_mem(&mut self, arg0: &XmmMem8) -> XmmMem;
    fn xmm_mem_aligned_8_to_xmm_mem_aligned(&mut self, arg0: &XmmMemAligned8) -> XmmMemAligned;
    fn xmm_mem_imm_8_to_xmm_mem_imm(&mut self, arg0: &XmmMemImm8) -> XmmMemImm;
    fn xmm_mem_aligned_imm_8_to_xmm_mem_aligned_imm(&mut self, arg0: &XmmMemAlignedImm8) -> XmmMemAlignedImm;
    fn put_in_xmm_mem_16(&mut self, arg0: Value) -> XmmMem16;
    fn put_in_xmm_mem_aligned_16(&mut self, arg0: Value) -> XmmMemAligned16;
    fn put_in_xmm_mem_imm_16(&mut self, arg0: Value) -> XmmMemImm16;
    fn put_in_xmm_mem_aligned_imm_16(&mut self, arg0: Value) -> XmmMemAlignedImm16;
    fn xmm_to_xmm_mem_16(&mut self, arg0: Xmm) -> XmmMem16;
    fn xmm_to_xmm_mem_aligned_16(&mut self, arg0: Xmm) -> XmmMemAligned16;
    fn xmm_to_xmm_mem_imm_16(&mut self, arg0: Xmm) -> XmmMemImm16;
    fn xmm_to_xmm_mem_aligned_imm_16(&mut self, arg0: Xmm) -> XmmMemAlignedImm16;
    fn xmm_mem_imm_16_imm(&mut self, arg0: u32) -> XmmMemImm16;
    fn xmm_mem_16_to_xmm_mem(&mut self, arg0: &XmmMem16) -> XmmMem;
    fn xmm_mem_aligned_16_to_xmm_mem_aligned(&mut self, arg0: &XmmMemAligned16) -> XmmMemAligned;
    fn xmm_mem_imm_16_to_xmm_mem_imm(&mut self, arg0: &XmmMemImm16) -> XmmMemImm;
    fn xmm_mem_aligned_imm_16_to_xmm_mem_aligned_imm(&mut self, arg0: &XmmMemAlignedImm16) -> XmmMemAlignedImm;
    fn put_in_xmm_mem_32(&mut self, arg0: Value) -> XmmMem32;
    fn put_in_xmm_mem_aligned_32(&mut self, arg0: Value) -> XmmMemAligned32;
    fn put_in_xmm_mem_imm_32(&mut self, arg0: Value) -> XmmMemImm32;
    fn put_in_xmm_mem_aligned_imm_32(&mut self, arg0: Value) -> XmmMemAlignedImm32;
    fn xmm_to_xmm_mem_32(&mut self, arg0: Xmm) -> XmmMem32;
    fn xmm_to_xmm_mem_aligned_32(&mut self, arg0: Xmm) -> XmmMemAligned32;
    fn xmm_to_xmm_mem_imm_32(&mut self, arg0: Xmm) -> XmmMemImm32;
    fn xmm_to_xmm_mem_aligned_imm_32(&mut self, arg0: Xmm) -> XmmMemAlignedImm32;
    fn xmm_mem_imm_32_imm(&mut self, arg0: u32) -> XmmMemImm32;
    fn xmm_mem_32_to_xmm_mem(&mut self, arg0: &XmmMem32) -> XmmMem;
    fn xmm_mem_aligned_32_to_xmm_mem_aligned(&mut self, arg0: &XmmMemAligned32) -> XmmMemAligned;
    fn xmm_mem_imm_32_to_xmm_mem_imm(&mut self, arg0: &XmmMemImm32) -> XmmMemImm;
    fn xmm_mem_aligned_imm_32_to_xmm_mem_aligned_imm(&mut self, arg0: &XmmMemAlignedImm32) -> XmmMemAlignedImm;
    fn put_in_xmm_mem_64(&mut self, arg0: Value) -> XmmMem64;
    fn put_in_xmm_mem_aligned_64(&mut self, arg0: Value) -> XmmMemAligned64;
    fn put_in_xmm_mem_imm_64(&mut self, arg0: Value) -> XmmMemImm64;
    fn put_in_xmm_mem_aligned_imm_64(&mut self, arg0: Value) -> XmmMemAlignedImm64;
    fn xmm_to_xmm_mem_64(&mut self, arg0: Xmm) -> XmmMem64;
    fn xmm_to_xmm_mem_aligned_64(&mut self, arg0: Xmm) -> XmmMemAligned64;
    fn xmm_to_xmm_mem_imm_64(&mut self, arg0: Xmm) -> XmmMemImm64;
    fn xmm_to_xmm_mem_aligned_imm_64(&mut self, arg0: Xmm) -> XmmMemAlignedImm64;
    fn xmm_mem_imm_64_imm(&mut self, arg0: u32) -> XmmMemImm64;
    fn xmm_mem_64_to_xmm_mem(&mut self, arg0: &XmmMem64) -> XmmMem;
    fn xmm_mem_aligned_64_to_xmm_mem_aligned(&mut self, arg0: &XmmMemAligned64) -> XmmMemAligned;
    fn xmm_mem_imm_64_to_xmm_mem_imm(&mut self, arg0: &XmmMemImm64) -> XmmMemImm;
    fn xmm_mem_aligned_imm_64_to_xmm_mem_aligned_imm(&mut self, arg0: &XmmMemAlignedImm64) -> XmmMemAlignedImm;
    fn put_in_xmm_mem_128(&mut self, arg0: Value) -> XmmMem128;
    fn put_in_xmm_mem_aligned_128(&mut self, arg0: Value) -> XmmMemAligned128;
    fn put_in_xmm_mem_imm_128(&mut self, arg0: Value) -> XmmMemImm128;
    fn put_in_xmm_mem_aligned_imm_128(&mut self, arg0: Value) -> XmmMemAlignedImm128;
    fn xmm_to_xmm_mem_128(&mut self, arg0: Xmm) -> XmmMem128;
    fn xmm_to_xmm_mem_aligned_128(&mut self, arg0: Xmm) -> XmmMemAligned128;
    fn xmm_to_xmm_mem_imm_128(&mut self, arg0: Xmm) -> XmmMemImm128;
    fn xmm_to_xmm_mem_aligned_imm_128(&mut self, arg0: Xmm) -> XmmMemAlignedImm128;
    fn xmm_mem_imm_128_imm(&mut self, arg0: u32) -> XmmMemImm128;
    fn xmm_mem_128_to_xmm_mem(&mut self, arg0: &XmmMem128) -> XmmMem;
    fn xmm_mem_aligned_128_to_xmm_mem_aligned(&mut self, arg0: &XmmMemAligned128) -> XmmMemAligned;
    fn xmm_mem_imm_128_to_xmm_mem_imm(&mut self, arg0: &XmmMemImm128) -> XmmMemImm;
    fn xmm_mem_aligned_imm_128_to_xmm_mem_aligned_imm(&mut self, arg0: &XmmMemAlignedImm128) -> XmmMemAlignedImm;
    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 is_xmm_32(&mut self, arg0: &XmmMem32) -> Option<Xmm>;
    fn is_xmm_64(&mut self, arg0: &XmmMem64) -> Option<Xmm>;
    fn is_xmm_128(&mut self, arg0: &XmmMem128) -> Option<Xmm>;
    fn is_mem_32(&mut self, arg0: &XmmMem32) -> Option<SyntheticAmode>;
    fn is_mem_64(&mut self, arg0: &XmmMem64) -> Option<SyntheticAmode>;
    fn is_mem_128(&mut self, arg0: &XmmMem128) -> 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 sinkable_load_8(&mut self, arg0: Value) -> Option<SinkableLoad8>;
    fn sinkable_load_16(&mut self, arg0: Value) -> Option<SinkableLoad16>;
    fn sinkable_load_32(&mut self, arg0: Value) -> Option<SinkableLoad32>;
    fn sinkable_load_64(&mut self, arg0: Value) -> Option<SinkableLoad64>;
    fn sinkable_load_128(&mut self, arg0: Value) -> Option<SinkableLoad128>;
    fn sink_load_8(&mut self, arg0: &SinkableLoad8) -> SyntheticAmode;
    fn sink_load_16(&mut self, arg0: &SinkableLoad16) -> SyntheticAmode;
    fn sink_load_32(&mut self, arg0: &SinkableLoad32) -> SyntheticAmode;
    fn sink_load_64(&mut self, arg0: &SinkableLoad64) -> SyntheticAmode;
    fn sink_load_128(&mut self, arg0: &SinkableLoad128) -> SyntheticAmode;
    fn sink_load_8_to_gpr_mem_8(&mut self, arg0: &SinkableLoad8) -> GprMem8;
    fn sink_load_16_to_gpr_mem_16(&mut self, arg0: &SinkableLoad16) -> GprMem16;
    fn sink_load_32_to_gpr_mem_32(&mut self, arg0: &SinkableLoad32) -> GprMem32;
    fn sink_load_64_to_gpr_mem_64(&mut self, arg0: &SinkableLoad64) -> GprMem64;
    fn sink_load_8_to_xmm_mem_8(&mut self, arg0: &SinkableLoad8) -> XmmMem8;
    fn sink_load_16_to_xmm_mem_16(&mut self, arg0: &SinkableLoad16) -> XmmMem16;
    fn sink_load_32_to_xmm_mem_32(&mut self, arg0: &SinkableLoad32) -> XmmMem32;
    fn sink_load_64_to_xmm_mem_64(&mut self, arg0: &SinkableLoad64) -> XmmMem64;
    fn sink_load_128_to_xmm_mem_128(&mut self, arg0: &SinkableLoad128) -> XmmMem128;
    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 gpr_mem_8_for_ty(&mut self, arg0: Type, arg1: &GprMem) -> GprMem8;
    fn gpr_mem_16_for_ty(&mut self, arg0: Type, arg1: &GprMem) -> GprMem16;
    fn gpr_mem_32_for_ty(&mut self, arg0: Type, arg1: &GprMem) -> GprMem32;
    fn gpr_mem_64_for_ty(&mut self, arg0: Type, arg1: &GprMem) -> GprMem64;
    fn gpr_mem_as_gpr_mem_32_or_widened_in_reg(&mut self, arg0: Type, arg1: &GprMem) -> GprMem32;
    fn xmm_mem_32_for_ty(&mut self, arg0: Type, arg1: &XmmMem) -> XmmMem32;
    fn xmm_mem_64_for_ty(&mut self, arg0: Type, arg1: &XmmMem) -> XmmMem64;
    fn xmm_mem_128_for_ty(&mut self, arg0: Type, arg1: &XmmMem) -> XmmMem128;
    fn xmm_mem_aligned_128_for_ty(&mut self, arg0: Type, arg1: &XmmMemAligned) -> XmmMemAligned128;
    fn const_to_synthetic_amode(&mut self, arg0: VCodeConstant) -> SyntheticAmode;
    fn const_to_xmm_mem_128(&mut self, arg0: VCodeConstant) -> XmmMem128;
    fn synthetic_amode_to_xmm_mem_8(&mut self, arg0: &SyntheticAmode) -> XmmMem8;
    fn synthetic_amode_to_xmm_mem_16(&mut self, arg0: &SyntheticAmode) -> XmmMem16;
    fn synthetic_amode_to_xmm_mem_32(&mut self, arg0: &SyntheticAmode) -> XmmMem32;
    fn synthetic_amode_to_xmm_mem_64(&mut self, arg0: &SyntheticAmode) -> XmmMem64;
    fn synthetic_amode_to_xmm_mem_128(&mut self, arg0: &SyntheticAmode) -> XmmMem128;
    fn synthetic_amode_to_gpr_mem_8(&mut self, arg0: &SyntheticAmode) -> GprMem8;
    fn synthetic_amode_to_gpr_mem_16(&mut self, arg0: &SyntheticAmode) -> GprMem16;
    fn synthetic_amode_to_gpr_mem_32(&mut self, arg0: &SyntheticAmode) -> GprMem32;
    fn synthetic_amode_to_gpr_mem_64(&mut self, arg0: &SyntheticAmode) -> GprMem64;
    fn reg_to_gpr_mem_8(&mut self, arg0: Reg) -> GprMem8;
    fn reg_to_gpr_mem_16(&mut self, arg0: Reg) -> GprMem16;
    fn reg_to_gpr_mem_32(&mut self, arg0: Reg) -> GprMem32;
    fn reg_to_gpr_mem_64(&mut self, arg0: Reg) -> GprMem64;
    fn writable_gpr_to_gpr_mem_8(&mut self, arg0: WritableGpr) -> GprMem8;
    fn writable_gpr_to_gpr_mem_16(&mut self, arg0: WritableGpr) -> GprMem16;
    fn writable_gpr_to_gpr_mem_32(&mut self, arg0: WritableGpr) -> GprMem32;
    fn writable_gpr_to_gpr_mem_64(&mut self, arg0: WritableGpr) -> GprMem64;
    fn writable_xmm_to_xmm_mem_128(&mut self, arg0: WritableXmm) -> XmmMem128;
    fn writable_xmm_to_xmm_mem_aligned_128(&mut self, arg0: WritableXmm) -> XmmMemAligned128;
    fn xmm_mem_32_to_xmm_mem_aligned_32(&mut self, arg0: &XmmMem32) -> XmmMemAligned32;
    fn xmm_mem_64_to_xmm_mem_aligned_64(&mut self, arg0: &XmmMem64) -> XmmMemAligned64;
    fn xmm_mem_128_to_xmm_mem_aligned_128(&mut self, arg0: &XmmMem128) -> XmmMemAligned128;
    fn gpr_mem_as_gpr_mem_8(&mut self, arg0: &GprMem) -> GprMem8;
    fn gpr_mem_as_gpr_mem_16(&mut self, arg0: &GprMem) -> GprMem16;
    fn gpr_mem_as_gpr_mem_32(&mut self, arg0: &GprMem) -> GprMem32;
    fn gpr_mem_as_gpr_mem_64(&mut self, arg0: &GprMem) -> GprMem64;
    fn xmm_mem_as_xmm_mem_32(&mut self, arg0: &XmmMem) -> XmmMem32;
    fn xmm_mem_as_xmm_mem_64(&mut self, arg0: &XmmMem) -> XmmMem64;
    fn xmm_mem_as_xmm_mem_128(&mut self, arg0: &XmmMem) -> XmmMem128;
    fn xmm_mem_aligned_as_xmm_mem_aligned_32(&mut self, arg0: &XmmMemAligned) -> XmmMemAligned32;
    fn xmm_mem_aligned_as_xmm_mem_aligned_64(&mut self, arg0: &XmmMemAligned) -> XmmMemAligned64;
    fn xmm_mem_aligned_as_xmm_mem_aligned_128(&mut self, arg0: &XmmMemAligned) -> XmmMemAligned128;
    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_rotl(&mut self, arg0: i8, arg1: u32) -> i8;
    fn i8_rotr(&mut self, arg0: i8, arg1: u32) -> i8;
    fn i8_is_zero(&mut self, arg0: i8) -> bool;
    fn i8_matches_zero(&mut self, arg0: i8) -> Option<bool>;
    fn i8_is_non_zero(&mut self, arg0: i8) -> bool;
    fn i8_matches_non_zero(&mut self, arg0: i8) -> Option<bool>;
    fn i8_is_odd(&mut self, arg0: i8) -> bool;
    fn i8_matches_odd(&mut self, arg0: i8) -> Option<bool>;
    fn i8_is_even(&mut self, arg0: i8) -> bool;
    fn i8_matches_even(&mut self, arg0: i8) -> Option<bool>;
    fn i8_checked_ilog2(&mut self, arg0: i8) -> Option<u32>;
    fn i8_ilog2(&mut self, arg0: i8) -> u32;
    fn i8_trailing_zeros(&mut self, arg0: i8) -> u32;
    fn i8_trailing_ones(&mut self, arg0: i8) -> u32;
    fn i8_leading_zeros(&mut self, arg0: i8) -> u32;
    fn i8_leading_ones(&mut self, arg0: i8) -> u32;
    fn i8_checked_neg(&mut self, arg0: i8) -> Option<i8>;
    fn i8_wrapping_neg(&mut self, arg0: i8) -> i8;
    fn i8_neg(&mut self, arg0: i8) -> i8;
    fn u8_eq(&mut self, arg0: u8, arg1: u8) -> bool;
    fn u8_ne(&mut self, arg0: u8, arg1: u8) -> bool;
    fn u8_lt(&mut self, arg0: u8, arg1: u8) -> bool;
    fn u8_lt_eq(&mut self, arg0: u8, arg1: u8) -> bool;
    fn u8_gt(&mut self, arg0: u8, arg1: u8) -> bool;
    fn u8_gt_eq(&mut self, arg0: u8, arg1: u8) -> bool;
    fn u8_checked_add(&mut self, arg0: u8, arg1: u8) -> Option<u8>;
    fn u8_wrapping_add(&mut self, arg0: u8, arg1: u8) -> u8;
    fn u8_add(&mut self, arg0: u8, arg1: u8) -> u8;
    fn u8_checked_sub(&mut self, arg0: u8, arg1: u8) -> Option<u8>;
    fn u8_wrapping_sub(&mut self, arg0: u8, arg1: u8) -> u8;
    fn u8_sub(&mut self, arg0: u8, arg1: u8) -> u8;
    fn u8_checked_mul(&mut self, arg0: u8, arg1: u8) -> Option<u8>;
    fn u8_wrapping_mul(&mut self, arg0: u8, arg1: u8) -> u8;
    fn u8_mul(&mut self, arg0: u8, arg1: u8) -> u8;
    fn u8_checked_div(&mut self, arg0: u8, arg1: u8) -> Option<u8>;
    fn u8_wrapping_div(&mut self, arg0: u8, arg1: u8) -> u8;
    fn u8_div(&mut self, arg0: u8, arg1: u8) -> u8;
    fn u8_checked_rem(&mut self, arg0: u8, arg1: u8) -> Option<u8>;
    fn u8_rem(&mut self, arg0: u8, arg1: u8) -> u8;
    fn u8_and(&mut self, arg0: u8, arg1: u8) -> u8;
    fn u8_or(&mut self, arg0: u8, arg1: u8) -> u8;
    fn u8_xor(&mut self, arg0: u8, arg1: u8) -> u8;
    fn u8_not(&mut self, arg0: u8) -> u8;
    fn u8_checked_shl(&mut self, arg0: u8, arg1: u32) -> Option<u8>;
    fn u8_wrapping_shl(&mut self, arg0: u8, arg1: u32) -> u8;
    fn u8_shl(&mut self, arg0: u8, arg1: u32) -> u8;
    fn u8_checked_shr(&mut self, arg0: u8, arg1: u32) -> Option<u8>;
    fn u8_wrapping_shr(&mut self, arg0: u8, arg1: u32) -> u8;
    fn u8_shr(&mut self, arg0: u8, arg1: u32) -> u8;
    fn u8_rotl(&mut self, arg0: u8, arg1: u32) -> u8;
    fn u8_rotr(&mut self, arg0: u8, arg1: u32) -> u8;
    fn u8_is_zero(&mut self, arg0: u8) -> bool;
    fn u8_matches_zero(&mut self, arg0: u8) -> Option<bool>;
    fn u8_is_non_zero(&mut self, arg0: u8) -> bool;
    fn u8_matches_non_zero(&mut self, arg0: u8) -> Option<bool>;
    fn u8_is_odd(&mut self, arg0: u8) -> bool;
    fn u8_matches_odd(&mut self, arg0: u8) -> Option<bool>;
    fn u8_is_even(&mut self, arg0: u8) -> bool;
    fn u8_matches_even(&mut self, arg0: u8) -> Option<bool>;
    fn u8_checked_ilog2(&mut self, arg0: u8) -> Option<u32>;
    fn u8_ilog2(&mut self, arg0: u8) -> u32;
    fn u8_trailing_zeros(&mut self, arg0: u8) -> u32;
    fn u8_trailing_ones(&mut self, arg0: u8) -> u32;
    fn u8_leading_zeros(&mut self, arg0: u8) -> u32;
    fn u8_leading_ones(&mut self, arg0: u8) -> u32;
    fn u8_is_power_of_two(&mut self, arg0: u8) -> bool;
    fn u8_matches_power_of_two(&mut self, arg0: u8) -> Option<bool>;
    fn i16_eq(&mut self, arg0: i16, arg1: i16) -> bool;
    fn i16_ne(&mut self, arg0: i16, arg1: i16) -> bool;
    fn i16_lt(&mut self, arg0: i16, arg1: i16) -> bool;
    fn i16_lt_eq(&mut self, arg0: i16, arg1: i16) -> bool;
    fn i16_gt(&mut self, arg0: i16, arg1: i16) -> bool;
    fn i16_gt_eq(&mut self, arg0: i16, arg1: i16) -> bool;
    fn i16_checked_add(&mut self, arg0: i16, arg1: i16) -> Option<i16>;
    fn i16_wrapping_add(&mut self, arg0: i16, arg1: i16) -> i16;
    fn i16_add(&mut self, arg0: i16, arg1: i16) -> i16;
    fn i16_checked_sub(&mut self, arg0: i16, arg1: i16) -> Option<i16>;
    fn i16_wrapping_sub(&mut self, arg0: i16, arg1: i16) -> i16;
    fn i16_sub(&mut self, arg0: i16, arg1: i16) -> i16;
    fn i16_checked_mul(&mut self, arg0: i16, arg1: i16) -> Option<i16>;
    fn i16_wrapping_mul(&mut self, arg0: i16, arg1: i16) -> i16;
    fn i16_mul(&mut self, arg0: i16, arg1: i16) -> i16;
    fn i16_checked_div(&mut self, arg0: i16, arg1: i16) -> Option<i16>;
    fn i16_wrapping_div(&mut self, arg0: i16, arg1: i16) -> i16;
    fn i16_div(&mut self, arg0: i16, arg1: i16) -> i16;
    fn i16_checked_rem(&mut self, arg0: i16, arg1: i16) -> Option<i16>;
    fn i16_rem(&mut self, arg0: i16, arg1: i16) -> i16;
    fn i16_and(&mut self, arg0: i16, arg1: i16) -> i16;
    fn i16_or(&mut self, arg0: i16, arg1: i16) -> i16;
    fn i16_xor(&mut self, arg0: i16, arg1: i16) -> i16;
    fn i16_not(&mut self, arg0: i16) -> i16;
    fn i16_checked_shl(&mut self, arg0: i16, arg1: u32) -> Option<i16>;
    fn i16_wrapping_shl(&mut self, arg0: i16, arg1: u32) -> i16;
    fn i16_shl(&mut self, arg0: i16, arg1: u32) -> i16;
    fn i16_checked_shr(&mut self, arg0: i16, arg1: u32) -> Option<i16>;
    fn i16_wrapping_shr(&mut self, arg0: i16, arg1: u32) -> i16;
    fn i16_shr(&mut self, arg0: i16, arg1: u32) -> i16;
    fn i16_rotl(&mut self, arg0: i16, arg1: u32) -> i16;
    fn i16_rotr(&mut self, arg0: i16, arg1: u32) -> i16;
    fn i16_is_zero(&mut self, arg0: i16) -> bool;
    fn i16_matches_zero(&mut self, arg0: i16) -> Option<bool>;
    fn i16_is_non_zero(&mut self, arg0: i16) -> bool;
    fn i16_matches_non_zero(&mut self, arg0: i16) -> Option<bool>;
    fn i16_is_odd(&mut self, arg0: i16) -> bool;
    fn i16_matches_odd(&mut self, arg0: i16) -> Option<bool>;
    fn i16_is_even(&mut self, arg0: i16) -> bool;
    fn i16_matches_even(&mut self, arg0: i16) -> Option<bool>;
    fn i16_checked_ilog2(&mut self, arg0: i16) -> Option<u32>;
    fn i16_ilog2(&mut self, arg0: i16) -> u32;
    fn i16_trailing_zeros(&mut self, arg0: i16) -> u32;
    fn i16_trailing_ones(&mut self, arg0: i16) -> u32;
    fn i16_leading_zeros(&mut self, arg0: i16) -> u32;
    fn i16_leading_ones(&mut self, arg0: i16) -> u32;
    fn i16_checked_neg(&mut self, arg0: i16) -> Option<i16>;
    fn i16_wrapping_neg(&mut self, arg0: i16) -> i16;
    fn i16_neg(&mut self, arg0: i16) -> i16;
    fn u16_eq(&mut self, arg0: u16, arg1: u16) -> bool;
    fn u16_ne(&mut self, arg0: u16, arg1: u16) -> bool;
    fn u16_lt(&mut self, arg0: u16, arg1: u16) -> bool;
    fn u16_lt_eq(&mut self, arg0: u16, arg1: u16) -> bool;
    fn u16_gt(&mut self, arg0: u16, arg1: u16) -> bool;
    fn u16_gt_eq(&mut self, arg0: u16, arg1: u16) -> bool;
    fn u16_checked_add(&mut self, arg0: u16, arg1: u16) -> Option<u16>;
    fn u16_wrapping_add(&mut self, arg0: u16, arg1: u16) -> u16;
    fn u16_add(&mut self, arg0: u16, arg1: u16) -> u16;
    fn u16_checked_sub(&mut self, arg0: u16, arg1: u16) -> Option<u16>;
    fn u16_wrapping_sub(&mut self, arg0: u16, arg1: u16) -> u16;
    fn u16_sub(&mut self, arg0: u16, arg1: u16) -> u16;
    fn u16_checked_mul(&mut self, arg0: u16, arg1: u16) -> Option<u16>;
    fn u16_wrapping_mul(&mut self, arg0: u16, arg1: u16) -> u16;
    fn u16_mul(&mut self, arg0: u16, arg1: u16) -> u16;
    fn u16_checked_div(&mut self, arg0: u16, arg1: u16) -> Option<u16>;
    fn u16_wrapping_div(&mut self, arg0: u16, arg1: u16) -> u16;
    fn u16_div(&mut self, arg0: u16, arg1: u16) -> u16;
    fn u16_checked_rem(&mut self, arg0: u16, arg1: u16) -> Option<u16>;
    fn u16_rem(&mut self, arg0: u16, arg1: u16) -> u16;
    fn u16_and(&mut self, arg0: u16, arg1: u16) -> u16;
    fn u16_or(&mut self, arg0: u16, arg1: u16) -> u16;
    fn u16_xor(&mut self, arg0: u16, arg1: u16) -> u16;
    fn u16_not(&mut self, arg0: u16) -> u16;
    fn u16_checked_shl(&mut self, arg0: u16, arg1: u32) -> Option<u16>;
    fn u16_wrapping_shl(&mut self, arg0: u16, arg1: u32) -> u16;
    fn u16_shl(&mut self, arg0: u16, arg1: u32) -> u16;
    fn u16_checked_shr(&mut self, arg0: u16, arg1: u32) -> Option<u16>;
    fn u16_wrapping_shr(&mut self, arg0: u16, arg1: u32) -> u16;
    fn u16_shr(&mut self, arg0: u16, arg1: u32) -> u16;
    fn u16_rotl(&mut self, arg0: u16, arg1: u32) -> u16;
    fn u16_rotr(&mut self, arg0: u16, arg1: u32) -> u16;
    fn u16_is_zero(&mut self, arg0: u16) -> bool;
    fn u16_matches_zero(&mut self, arg0: u16) -> Option<bool>;
    fn u16_is_non_zero(&mut self, arg0: u16) -> bool;
    fn u16_matches_non_zero(&mut self, arg0: u16) -> Option<bool>;
    fn u16_is_odd(&mut self, arg0: u16) -> bool;
    fn u16_matches_odd(&mut self, arg0: u16) -> Option<bool>;
    fn u16_is_even(&mut self, arg0: u16) -> bool;
    fn u16_matches_even(&mut self, arg0: u16) -> Option<bool>;
    fn u16_checked_ilog2(&mut self, arg0: u16) -> Option<u32>;
    fn u16_ilog2(&mut self, arg0: u16) -> u32;
    fn u16_trailing_zeros(&mut self, arg0: u16) -> u32;
    fn u16_trailing_ones(&mut self, arg0: u16) -> u32;
    fn u16_leading_zeros(&mut self, arg0: u16) -> u32;
    fn u16_leading_ones(&mut self, arg0: u16) -> u32;
    fn u16_is_power_of_two(&mut self, arg0: u16) -> bool;
    fn u16_matches_power_of_two(&mut self, arg0: u16) -> Option<bool>;
    fn i32_eq(&mut self, arg0: i32, arg1: i32) -> bool;
    fn i32_ne(&mut self, arg0: i32, arg1: i32) -> bool;
    fn i32_lt(&mut self, arg0: i32, arg1: i32) -> bool;
    fn i32_lt_eq(&mut self, arg0: i32, arg1: i32) -> bool;
    fn i32_gt(&mut self, arg0: i32, arg1: i32) -> bool;
    fn i32_gt_eq(&mut self, arg0: i32, arg1: i32) -> bool;
    fn i32_checked_add(&mut self, arg0: i32, arg1: i32) -> Option<i32>;
    fn i32_wrapping_add(&mut self, arg0: i32, arg1: i32) -> i32;
    fn i32_add(&mut self, arg0: i32, arg1: i32) -> i32;
    fn i32_checked_sub(&mut self, arg0: i32, arg1: i32) -> Option<i32>;
    fn i32_wrapping_sub(&mut self, arg0: i32, arg1: i32) -> i32;
    fn i32_sub(&mut self, arg0: i32, arg1: i32) -> i32;
    fn i32_checked_mul(&mut self, arg0: i32, arg1: i32) -> Option<i32>;
    fn i32_wrapping_mul(&mut self, arg0: i32, arg1: i32) -> i32;
    fn i32_mul(&mut self, arg0: i32, arg1: i32) -> i32;
    fn i32_checked_div(&mut self, arg0: i32, arg1: i32) -> Option<i32>;
    fn i32_wrapping_div(&mut self, arg0: i32, arg1: i32) -> i32;
    fn i32_div(&mut self, arg0: i32, arg1: i32) -> i32;
    fn i32_checked_rem(&mut self, arg0: i32, arg1: i32) -> Option<i32>;
    fn i32_rem(&mut self, arg0: i32, arg1: i32) -> i32;
    fn i32_and(&mut self, arg0: i32, arg1: i32) -> i32;
    fn i32_or(&mut self, arg0: i32, arg1: i32) -> i32;
    fn i32_xor(&mut self, arg0: i32, arg1: i32) -> i32;
    fn i32_not(&mut self, arg0: i32) -> i32;
    fn i32_checked_shl(&mut self, arg0: i32, arg1: u32) -> Option<i32>;
    fn i32_wrapping_shl(&mut self, arg0: i32, arg1: u32) -> i32;
    fn i32_shl(&mut self, arg0: i32, arg1: u32) -> i32;
    fn i32_checked_shr(&mut self, arg0: i32, arg1: u32) -> Option<i32>;
    fn i32_wrapping_shr(&mut self, arg0: i32, arg1: u32) -> i32;
    fn i32_shr(&mut self, arg0: i32, arg1: u32) -> i32;
    fn i32_rotl(&mut self, arg0: i32, arg1: u32) -> i32;
    fn i32_rotr(&mut self, arg0: i32, arg1: u32) -> i32;
    fn i32_is_zero(&mut self, arg0: i32) -> bool;
    fn i32_matches_zero(&mut self, arg0: i32) -> Option<bool>;
    fn i32_is_non_zero(&mut self, arg0: i32) -> bool;
    fn i32_matches_non_zero(&mut self, arg0: i32) -> Option<bool>;
    fn i32_is_odd(&mut self, arg0: i32) -> bool;
    fn i32_matches_odd(&mut self, arg0: i32) -> Option<bool>;
    fn i32_is_even(&mut self, arg0: i32) -> bool;
    fn i32_matches_even(&mut self, arg0: i32) -> Option<bool>;
    fn i32_checked_ilog2(&mut self, arg0: i32) -> Option<u32>;
    fn i32_ilog2(&mut self, arg0: i32) -> u32;
    fn i32_trailing_zeros(&mut self, arg0: i32) -> u32;
    fn i32_trailing_ones(&mut self, arg0: i32) -> u32;
    fn i32_leading_zeros(&mut self, arg0: i32) -> u32;
    fn i32_leading_ones(&mut self, arg0: i32) -> u32;
    fn i32_checked_neg(&mut self, arg0: i32) -> Option<i32>;
    fn i32_wrapping_neg(&mut self, arg0: i32) -> i32;
    fn i32_neg(&mut self, arg0: i32) -> i32;
    fn u32_eq(&mut self, arg0: u32, arg1: u32) -> bool;
    fn u32_ne(&mut self, arg0: u32, arg1: u32) -> bool;
    fn u32_lt(&mut self, arg0: u32, arg1: u32) -> bool;
    fn u32_lt_eq(&mut self, arg0: u32, arg1: u32) -> bool;
    fn u32_gt(&mut self, arg0: u32, arg1: u32) -> bool;
    fn u32_gt_eq(&mut self, arg0: u32, arg1: u32) -> bool;
    fn u32_checked_add(&mut self, arg0: u32, arg1: u32) -> Option<u32>;
    fn u32_wrapping_add(&mut self, arg0: u32, arg1: u32) -> u32;
    fn u32_add(&mut self, arg0: u32, arg1: u32) -> u32;
    fn u32_checked_sub(&mut self, arg0: u32, arg1: u32) -> Option<u32>;
    fn u32_wrapping_sub(&mut self, arg0: u32, arg1: u32) -> u32;
    fn u32_sub(&mut self, arg0: u32, arg1: u32) -> u32;
    fn u32_checked_mul(&mut self, arg0: u32, arg1: u32) -> Option<u32>;
    fn u32_wrapping_mul(&mut self, arg0: u32, arg1: u32) -> u32;
    fn u32_mul(&mut self, arg0: u32, arg1: u32) -> u32;
    fn u32_checked_div(&mut self, arg0: u32, arg1: u32) -> Option<u32>;
    fn u32_wrapping_div(&mut self, arg0: u32, arg1: u32) -> u32;
    fn u32_div(&mut self, arg0: u32, arg1: u32) -> u32;
    fn u32_checked_rem(&mut self, arg0: u32, arg1: u32) -> Option<u32>;
    fn u32_rem(&mut self, arg0: u32, arg1: u32) -> u32;
    fn u32_and(&mut self, arg0: u32, arg1: u32) -> u32;
    fn u32_or(&mut self, arg0: u32, arg1: u32) -> u32;
    fn u32_xor(&mut self, arg0: u32, arg1: u32) -> u32;
    fn u32_not(&mut self, arg0: u32) -> u32;
    fn u32_checked_shl(&mut self, arg0: u32, arg1: u32) -> Option<u32>;
    fn u32_wrapping_shl(&mut self, arg0: u32, arg1: u32) -> u32;
    fn u32_shl(&mut self, arg0: u32, arg1: u32) -> u32;
    fn u32_checked_shr(&mut self, arg0: u32, arg1: u32) -> Option<u32>;
    fn u32_wrapping_shr(&mut self, arg0: u32, arg1: u32) -> u32;
    fn u32_shr(&mut self, arg0: u32, arg1: u32) -> u32;
    fn u32_rotl(&mut self, arg0: u32, arg1: u32) -> u32;
    fn u32_rotr(&mut self, arg0: u32, arg1: u32) -> u32;
    fn u32_is_zero(&mut self, arg0: u32) -> bool;
    fn u32_matches_zero(&mut self, arg0: u32) -> Option<bool>;
    fn u32_is_non_zero(&mut self, arg0: u32) -> bool;
    fn u32_matches_non_zero(&mut self, arg0: u32) -> Option<bool>;
    fn u32_is_odd(&mut self, arg0: u32) -> bool;
    fn u32_matches_odd(&mut self, arg0: u32) -> Option<bool>;
    fn u32_is_even(&mut self, arg0: u32) -> bool;
    fn u32_matches_even(&mut self, arg0: u32) -> Option<bool>;
    fn u32_checked_ilog2(&mut self, arg0: u32) -> Option<u32>;
    fn u32_ilog2(&mut self, arg0: u32) -> u32;
    fn u32_trailing_zeros(&mut self, arg0: u32) -> u32;
    fn u32_trailing_ones(&mut self, arg0: u32) -> u32;
    fn u32_leading_zeros(&mut self, arg0: u32) -> u32;
    fn u32_leading_ones(&mut self, arg0: u32) -> u32;
    fn u32_is_power_of_two(&mut self, arg0: u32) -> bool;
    fn u32_matches_power_of_two(&mut self, arg0: u32) -> Option<bool>;
    fn i64_eq(&mut self, arg0: i64, arg1: i64) -> bool;
    fn i64_ne(&mut self, arg0: i64, arg1: i64) -> bool;
    fn i64_lt(&mut self, arg0: i64, arg1: i64) -> bool;
    fn i64_lt_eq(&mut self, arg0: i64, arg1: i64) -> bool;
    fn i64_gt(&mut self, arg0: i64, arg1: i64) -> bool;
    fn i64_gt_eq(&mut self, arg0: i64, arg1: i64) -> bool;
    fn i64_checked_add(&mut self, arg0: i64, arg1: i64) -> Option<i64>;
    fn i64_wrapping_add(&mut self, arg0: i64, arg1: i64) -> i64;
    fn i64_add(&mut self, arg0: i64, arg1: i64) -> i64;
    fn i64_checked_sub(&mut self, arg0: i64, arg1: i64) -> Option<i64>;
    fn i64_wrapping_sub(&mut self, arg0: i64, arg1: i64) -> i64;
    fn i64_sub(&mut self, arg0: i64, arg1: i64) -> i64;
    fn i64_checked_mul(&mut self, arg0: i64, arg1: i64) -> Option<i64>;
    fn i64_wrapping_mul(&mut self, arg0: i64, arg1: i64) -> i64;
    fn i64_mul(&mut self, arg0: i64, arg1: i64) -> i64;
    fn i64_checked_div(&mut self, arg0: i64, arg1: i64) -> Option<i64>;
    fn i64_wrapping_div(&mut self, arg0: i64, arg1: i64) -> i64;
    fn i64_div(&mut self, arg0: i64, arg1: i64) -> i64;
    fn i64_checked_rem(&mut self, arg0: i64, arg1: i64) -> Option<i64>;
    fn i64_rem(&mut self, arg0: i64, arg1: i64) -> i64;
    fn i64_and(&mut self, arg0: i64, arg1: i64) -> i64;
    fn i64_or(&mut self, arg0: i64, arg1: i64) -> i64;
    fn i64_xor(&mut self, arg0: i64, arg1: i64) -> i64;
    fn i64_not(&mut self, arg0: i64) -> i64;
    fn i64_checked_shl(&mut self, arg0: i64, arg1: u32) -> Option<i64>;
    fn i64_wrapping_shl(&mut self, arg0: i64, arg1: u32) -> i64;
    fn i64_shl(&mut self, arg0: i64, arg1: u32) -> i64;
    fn i64_checked_shr(&mut self, arg0: i64, arg1: u32) -> Option<i64>;
    fn i64_wrapping_shr(&mut self, arg0: i64, arg1: u32) -> i64;
    fn i64_shr(&mut self, arg0: i64, arg1: u32) -> i64;
    fn i64_rotl(&mut self, arg0: i64, arg1: u32) -> i64;
    fn i64_rotr(&mut self, arg0: i64, arg1: u32) -> i64;
    fn i64_is_zero(&mut self, arg0: i64) -> bool;
    fn i64_matches_zero(&mut self, arg0: i64) -> Option<bool>;
    fn i64_is_non_zero(&mut self, arg0: i64) -> bool;
    fn i64_matches_non_zero(&mut self, arg0: i64) -> Option<bool>;
    fn i64_is_odd(&mut self, arg0: i64) -> bool;
    fn i64_matches_odd(&mut self, arg0: i64) -> Option<bool>;
    fn i64_is_even(&mut self, arg0: i64) -> bool;
    fn i64_matches_even(&mut self, arg0: i64) -> Option<bool>;
    fn i64_checked_ilog2(&mut self, arg0: i64) -> Option<u32>;
    fn i64_ilog2(&mut self, arg0: i64) -> u32;
    fn i64_trailing_zeros(&mut self, arg0: i64) -> u32;
    fn i64_trailing_ones(&mut self, arg0: i64) -> u32;
    fn i64_leading_zeros(&mut self, arg0: i64) -> u32;
    fn i64_leading_ones(&mut self, arg0: i64) -> u32;
    fn i64_checked_neg(&mut self, arg0: i64) -> Option<i64>;
    fn i64_wrapping_neg(&mut self, arg0: i64) -> i64;
    fn i64_neg(&mut self, arg0: i64) -> i64;
    fn u64_eq(&mut self, arg0: u64, arg1: u64) -> bool;
    fn u64_ne(&mut self, arg0: u64, arg1: u64) -> bool;
    fn u64_lt(&mut self, arg0: u64, arg1: u64) -> bool;
    fn u64_lt_eq(&mut self, arg0: u64, arg1: u64) -> bool;
    fn u64_gt(&mut self, arg0: u64, arg1: u64) -> bool;
    fn u64_gt_eq(&mut self, arg0: u64, arg1: u64) -> bool;
    fn u64_checked_add(&mut self, arg0: u64, arg1: u64) -> Option<u64>;
    fn u64_wrapping_add(&mut self, arg0: u64, arg1: u64) -> u64;
    fn u64_add(&mut self, arg0: u64, arg1: u64) -> u64;
    fn u64_checked_sub(&mut self, arg0: u64, arg1: u64) -> Option<u64>;
    fn u64_wrapping_sub(&mut self, arg0: u64, arg1: u64) -> u64;
    fn u64_sub(&mut self, arg0: u64, arg1: u64) -> u64;
    fn u64_checked_mul(&mut self, arg0: u64, arg1: u64) -> Option<u64>;
    fn u64_wrapping_mul(&mut self, arg0: u64, arg1: u64) -> u64;
    fn u64_mul(&mut self, arg0: u64, arg1: u64) -> u64;
    fn u64_checked_div(&mut self, arg0: u64, arg1: u64) -> Option<u64>;
    fn u64_wrapping_div(&mut self, arg0: u64, arg1: u64) -> u64;
    fn u64_div(&mut self, arg0: u64, arg1: u64) -> u64;
    fn u64_checked_rem(&mut self, arg0: u64, arg1: u64) -> Option<u64>;
    fn u64_rem(&mut self, arg0: u64, arg1: u64) -> u64;
    fn u64_and(&mut self, arg0: u64, arg1: u64) -> u64;
    fn u64_or(&mut self, arg0: u64, arg1: u64) -> u64;
    fn u64_xor(&mut self, arg0: u64, arg1: u64) -> u64;
    fn u64_not(&mut self, arg0: u64) -> u64;
    fn u64_checked_shl(&mut self, arg0: u64, arg1: u32) -> Option<u64>;
    fn u64_wrapping_shl(&mut self, arg0: u64, arg1: u32) -> u64;
    fn u64_shl(&mut self, arg0: u64, arg1: u32) -> u64;
    fn u64_checked_shr(&mut self, arg0: u64, arg1: u32) -> Option<u64>;
    fn u64_wrapping_shr(&mut self, arg0: u64, arg1: u32) -> u64;
    fn u64_shr(&mut self, arg0: u64, arg1: u32) -> u64;
    fn u64_rotl(&mut self, arg0: u64, arg1: u32) -> u64;
    fn u64_rotr(&mut self, arg0: u64, arg1: u32) -> u64;
    fn u64_is_zero(&mut self, arg0: u64) -> bool;
    fn u64_matches_zero(&mut self, arg0: u64) -> Option<bool>;
    fn u64_is_non_zero(&mut self, arg0: u64) -> bool;
    fn u64_matches_non_zero(&mut self, arg0: u64) -> Option<bool>;
    fn u64_is_odd(&mut self, arg0: u64) -> bool;
    fn u64_matches_odd(&mut self, arg0: u64) -> Option<bool>;
    fn u64_is_even(&mut self, arg0: u64) -> bool;
    fn u64_matches_even(&mut self, arg0: u64) -> Option<bool>;
    fn u64_checked_ilog2(&mut self, arg0: u64) -> Option<u32>;
    fn u64_ilog2(&mut self, arg0: u64) -> u32;
    fn u64_trailing_zeros(&mut self, arg0: u64) -> u32;
    fn u64_trailing_ones(&mut self, arg0: u64) -> u32;
    fn u64_leading_zeros(&mut self, arg0: u64) -> u32;
    fn u64_leading_ones(&mut self, arg0: u64) -> u32;
    fn u64_is_power_of_two(&mut self, arg0: u64) -> bool;
    fn u64_matches_power_of_two(&mut self, arg0: u64) -> Option<bool>;
    fn i128_eq(&mut self, arg0: i128, arg1: i128) -> bool;
    fn i128_ne(&mut self, arg0: i128, arg1: i128) -> bool;
    fn i128_lt(&mut self, arg0: i128, arg1: i128) -> bool;
    fn i128_lt_eq(&mut self, arg0: i128, arg1: i128) -> bool;
    fn i128_gt(&mut self, arg0: i128, arg1: i128) -> bool;
    fn i128_gt_eq(&mut self, arg0: i128, arg1: i128) -> bool;
    fn i128_checked_add(&mut self, arg0: i128, arg1: i128) -> Option<i128>;
    fn i128_wrapping_add(&mut self, arg0: i128, arg1: i128) -> i128;
    fn i128_add(&mut self, arg0: i128, arg1: i128) -> i128;
    fn i128_checked_sub(&mut self, arg0: i128, arg1: i128) -> Option<i128>;
    fn i128_wrapping_sub(&mut self, arg0: i128, arg1: i128) -> i128;
    fn i128_sub(&mut self, arg0: i128, arg1: i128) -> i128;
    fn i128_checked_mul(&mut self, arg0: i128, arg1: i128) -> Option<i128>;
    fn i128_wrapping_mul(&mut self, arg0: i128, arg1: i128) -> i128;
    fn i128_mul(&mut self, arg0: i128, arg1: i128) -> i128;
    fn i128_checked_div(&mut self, arg0: i128, arg1: i128) -> Option<i128>;
    fn i128_wrapping_div(&mut self, arg0: i128, arg1: i128) -> i128;
    fn i128_div(&mut self, arg0: i128, arg1: i128) -> i128;
    fn i128_checked_rem(&mut self, arg0: i128, arg1: i128) -> Option<i128>;
    fn i128_rem(&mut self, arg0: i128, arg1: i128) -> i128;
    fn i128_and(&mut self, arg0: i128, arg1: i128) -> i128;
    fn i128_or(&mut self, arg0: i128, arg1: i128) -> i128;
    fn i128_xor(&mut self, arg0: i128, arg1: i128) -> i128;
    fn i128_not(&mut self, arg0: i128) -> i128;
    fn i128_checked_shl(&mut self, arg0: i128, arg1: u32) -> Option<i128>;
    fn i128_wrapping_shl(&mut self, arg0: i128, arg1: u32) -> i128;
    fn i128_shl(&mut self, arg0: i128, arg1: u32) -> i128;
    fn i128_checked_shr(&mut self, arg0: i128, arg1: u32) -> Option<i128>;
    fn i128_wrapping_shr(&mut self, arg0: i128, arg1: u32) -> i128;
    fn i128_shr(&mut self, arg0: i128, arg1: u32) -> i128;
    fn i128_rotl(&mut self, arg0: i128, arg1: u32) -> i128;
    fn i128_rotr(&mut self, arg0: i128, arg1: u32) -> i128;
    fn i128_is_zero(&mut self, arg0: i128) -> bool;
    fn i128_matches_zero(&mut self, arg0: i128) -> Option<bool>;
    fn i128_is_non_zero(&mut self, arg0: i128) -> bool;
    fn i128_matches_non_zero(&mut self, arg0: i128) -> Option<bool>;
    fn i128_is_odd(&mut self, arg0: i128) -> bool;
    fn i128_matches_odd(&mut self, arg0: i128) -> Option<bool>;
    fn i128_is_even(&mut self, arg0: i128) -> bool;
    fn i128_matches_even(&mut self, arg0: i128) -> Option<bool>;
    fn i128_checked_ilog2(&mut self, arg0: i128) -> Option<u32>;
    fn i128_ilog2(&mut self, arg0: i128) -> u32;
    fn i128_trailing_zeros(&mut self, arg0: i128) -> u32;
    fn i128_trailing_ones(&mut self, arg0: i128) -> u32;
    fn i128_leading_zeros(&mut self, arg0: i128) -> u32;
    fn i128_leading_ones(&mut self, arg0: i128) -> u32;
    fn i128_checked_neg(&mut self, arg0: i128) -> Option<i128>;
    fn i128_wrapping_neg(&mut self, arg0: i128) -> i128;
    fn i128_neg(&mut self, arg0: i128) -> i128;
    fn u128_eq(&mut self, arg0: u128, arg1: u128) -> bool;
    fn u128_ne(&mut self, arg0: u128, arg1: u128) -> bool;
    fn u128_lt(&mut self, arg0: u128, arg1: u128) -> bool;
    fn u128_lt_eq(&mut self, arg0: u128, arg1: u128) -> bool;
    fn u128_gt(&mut self, arg0: u128, arg1: u128) -> bool;
    fn u128_gt_eq(&mut self, arg0: u128, arg1: u128) -> bool;
    fn u128_checked_add(&mut self, arg0: u128, arg1: u128) -> Option<u128>;
    fn u128_wrapping_add(&mut self, arg0: u128, arg1: u128) -> u128;
    fn u128_add(&mut self, arg0: u128, arg1: u128) -> u128;
    fn u128_checked_sub(&mut self, arg0: u128, arg1: u128) -> Option<u128>;
    fn u128_wrapping_sub(&mut self, arg0: u128, arg1: u128) -> u128;
    fn u128_sub(&mut self, arg0: u128, arg1: u128) -> u128;
    fn u128_checked_mul(&mut self, arg0: u128, arg1: u128) -> Option<u128>;
    fn u128_wrapping_mul(&mut self, arg0: u128, arg1: u128) -> u128;
    fn u128_mul(&mut self, arg0: u128, arg1: u128) -> u128;
    fn u128_checked_div(&mut self, arg0: u128, arg1: u128) -> Option<u128>;
    fn u128_wrapping_div(&mut self, arg0: u128, arg1: u128) -> u128;
    fn u128_div(&mut self, arg0: u128, arg1: u128) -> u128;
    fn u128_checked_rem(&mut self, arg0: u128, arg1: u128) -> Option<u128>;
    fn u128_rem(&mut self, arg0: u128, arg1: u128) -> u128;
    fn u128_and(&mut self, arg0: u128, arg1: u128) -> u128;
    fn u128_or(&mut self, arg0: u128, arg1: u128) -> u128;
    fn u128_xor(&mut self, arg0: u128, arg1: u128) -> u128;
    fn u128_not(&mut self, arg0: u128) -> u128;
    fn u128_checked_shl(&mut self, arg0: u128, arg1: u32) -> Option<u128>;
    fn u128_wrapping_shl(&mut self, arg0: u128, arg1: u32) -> u128;
    fn u128_shl(&mut self, arg0: u128, arg1: u32) -> u128;
    fn u128_checked_shr(&mut self, arg0: u128, arg1: u32) -> Option<u128>;
    fn u128_wrapping_shr(&mut self, arg0: u128, arg1: u32) -> u128;
    fn u128_shr(&mut self, arg0: u128, arg1: u32) -> u128;
    fn u128_rotl(&mut self, arg0: u128, arg1: u32) -> u128;
    fn u128_rotr(&mut self, arg0: u128, arg1: u32) -> u128;
    fn u128_is_zero(&mut self, arg0: u128) -> bool;
    fn u128_matches_zero(&mut self, arg0: u128) -> Option<bool>;
    fn u128_is_non_zero(&mut self, arg0: u128) -> bool;
    fn u128_matches_non_zero(&mut self, arg0: u128) -> Option<bool>;
    fn u128_is_odd(&mut self, arg0: u128) -> bool;
    fn u128_matches_odd(&mut self, arg0: u128) -> Option<bool>;
    fn u128_is_even(&mut self, arg0: u128) -> bool;
    fn u128_matches_even(&mut self, arg0: u128) -> Option<bool>;
    fn u128_checked_ilog2(&mut self, arg0: u128) -> Option<u32>;
    fn u128_ilog2(&mut self, arg0: u128) -> u32;
    fn u128_trailing_zeros(&mut self, arg0: u128) -> u32;
    fn u128_trailing_ones(&mut self, arg0: u128) -> u32;
    fn u128_leading_zeros(&mut self, arg0: u128) -> u32;
    fn u128_leading_ones(&mut self, arg0: u128) -> u32;
    fn u128_is_power_of_two(&mut self, arg0: u128) -> bool;
    fn u128_matches_power_of_two(&mut self, arg0: u128) -> Option<bool>;
    fn i8_try_into_u8(&mut self, arg0: i8) -> Option<u8>;
    fn i8_unwrap_into_u8(&mut self, arg0: i8) -> u8;
    fn i8_cast_unsigned(&mut self, arg0: i8) -> u8;
    fn i8_from_u8(&mut self, arg0: i8) -> Option<u8>;
    fn i8_into_i16(&mut self, arg0: i8) -> i16;
    fn i8_from_i16(&mut self, arg0: i8) -> Option<i16>;
    fn i8_try_into_u16(&mut self, arg0: i8) -> Option<u16>;
    fn i8_unwrap_into_u16(&mut self, arg0: i8) -> u16;
    fn i8_from_u16(&mut self, arg0: i8) -> Option<u16>;
    fn i8_into_i32(&mut self, arg0: i8) -> i32;
    fn i8_from_i32(&mut self, arg0: i8) -> Option<i32>;
    fn i8_try_into_u32(&mut self, arg0: i8) -> Option<u32>;
    fn i8_unwrap_into_u32(&mut self, arg0: i8) -> u32;
    fn i8_from_u32(&mut self, arg0: i8) -> Option<u32>;
    fn i8_into_i64(&mut self, arg0: i8) -> i64;
    fn i8_from_i64(&mut self, arg0: i8) -> Option<i64>;
    fn i8_try_into_u64(&mut self, arg0: i8) -> Option<u64>;
    fn i8_unwrap_into_u64(&mut self, arg0: i8) -> u64;
    fn i8_from_u64(&mut self, arg0: i8) -> Option<u64>;
    fn i8_into_i128(&mut self, arg0: i8) -> i128;
    fn i8_from_i128(&mut self, arg0: i8) -> Option<i128>;
    fn i8_try_into_u128(&mut self, arg0: i8) -> Option<u128>;
    fn i8_unwrap_into_u128(&mut self, arg0: i8) -> u128;
    fn i8_from_u128(&mut self, arg0: i8) -> Option<u128>;
    fn u8_try_into_i8(&mut self, arg0: u8) -> Option<i8>;
    fn u8_unwrap_into_i8(&mut self, arg0: u8) -> i8;
    fn u8_cast_signed(&mut self, arg0: u8) -> i8;
    fn u8_from_i8(&mut self, arg0: u8) -> Option<i8>;
    fn u8_into_i16(&mut self, arg0: u8) -> i16;
    fn u8_from_i16(&mut self, arg0: u8) -> Option<i16>;
    fn u8_into_u16(&mut self, arg0: u8) -> u16;
    fn u8_from_u16(&mut self, arg0: u8) -> Option<u16>;
    fn u8_into_i32(&mut self, arg0: u8) -> i32;
    fn u8_from_i32(&mut self, arg0: u8) -> Option<i32>;
    fn u8_into_u32(&mut self, arg0: u8) -> u32;
    fn u8_from_u32(&mut self, arg0: u8) -> Option<u32>;
    fn u8_into_i64(&mut self, arg0: u8) -> i64;
    fn u8_from_i64(&mut self, arg0: u8) -> Option<i64>;
    fn u8_into_u64(&mut self, arg0: u8) -> u64;
    fn u8_from_u64(&mut self, arg0: u8) -> Option<u64>;
    fn u8_into_i128(&mut self, arg0: u8) -> i128;
    fn u8_from_i128(&mut self, arg0: u8) -> Option<i128>;
    fn u8_into_u128(&mut self, arg0: u8) -> u128;
    fn u8_from_u128(&mut self, arg0: u8) -> Option<u128>;
    fn i16_try_into_i8(&mut self, arg0: i16) -> Option<i8>;
    fn i16_unwrap_into_i8(&mut self, arg0: i16) -> i8;
    fn i16_truncate_into_i8(&mut self, arg0: i16) -> i8;
    fn i16_from_i8(&mut self, arg0: i16) -> Option<i8>;
    fn i16_try_into_u8(&mut self, arg0: i16) -> Option<u8>;
    fn i16_unwrap_into_u8(&mut self, arg0: i16) -> u8;
    fn i16_from_u8(&mut self, arg0: i16) -> Option<u8>;
    fn i16_try_into_u16(&mut self, arg0: i16) -> Option<u16>;
    fn i16_unwrap_into_u16(&mut self, arg0: i16) -> u16;
    fn i16_cast_unsigned(&mut self, arg0: i16) -> u16;
    fn i16_from_u16(&mut self, arg0: i16) -> Option<u16>;
    fn i16_into_i32(&mut self, arg0: i16) -> i32;
    fn i16_from_i32(&mut self, arg0: i16) -> Option<i32>;
    fn i16_try_into_u32(&mut self, arg0: i16) -> Option<u32>;
    fn i16_unwrap_into_u32(&mut self, arg0: i16) -> u32;
    fn i16_from_u32(&mut self, arg0: i16) -> Option<u32>;
    fn i16_into_i64(&mut self, arg0: i16) -> i64;
    fn i16_from_i64(&mut self, arg0: i16) -> Option<i64>;
    fn i16_try_into_u64(&mut self, arg0: i16) -> Option<u64>;
    fn i16_unwrap_into_u64(&mut self, arg0: i16) -> u64;
    fn i16_from_u64(&mut self, arg0: i16) -> Option<u64>;
    fn i16_into_i128(&mut self, arg0: i16) -> i128;
    fn i16_from_i128(&mut self, arg0: i16) -> Option<i128>;
    fn i16_try_into_u128(&mut self, arg0: i16) -> Option<u128>;
    fn i16_unwrap_into_u128(&mut self, arg0: i16) -> u128;
    fn i16_from_u128(&mut self, arg0: i16) -> Option<u128>;
    fn u16_try_into_i8(&mut self, arg0: u16) -> Option<i8>;
    fn u16_unwrap_into_i8(&mut self, arg0: u16) -> i8;
    fn u16_from_i8(&mut self, arg0: u16) -> Option<i8>;
    fn u16_try_into_u8(&mut self, arg0: u16) -> Option<u8>;
    fn u16_unwrap_into_u8(&mut self, arg0: u16) -> u8;
    fn u16_truncate_into_u8(&mut self, arg0: u16) -> u8;
    fn u16_from_u8(&mut self, arg0: u16) -> Option<u8>;
    fn u16_try_into_i16(&mut self, arg0: u16) -> Option<i16>;
    fn u16_unwrap_into_i16(&mut self, arg0: u16) -> i16;
    fn u16_cast_signed(&mut self, arg0: u16) -> i16;
    fn u16_from_i16(&mut self, arg0: u16) -> Option<i16>;
    fn u16_into_i32(&mut self, arg0: u16) -> i32;
    fn u16_from_i32(&mut self, arg0: u16) -> Option<i32>;
    fn u16_into_u32(&mut self, arg0: u16) -> u32;
    fn u16_from_u32(&mut self, arg0: u16) -> Option<u32>;
    fn u16_into_i64(&mut self, arg0: u16) -> i64;
    fn u16_from_i64(&mut self, arg0: u16) -> Option<i64>;
    fn u16_into_u64(&mut self, arg0: u16) -> u64;
    fn u16_from_u64(&mut self, arg0: u16) -> Option<u64>;
    fn u16_into_i128(&mut self, arg0: u16) -> i128;
    fn u16_from_i128(&mut self, arg0: u16) -> Option<i128>;
    fn u16_into_u128(&mut self, arg0: u16) -> u128;
    fn u16_from_u128(&mut self, arg0: u16) -> Option<u128>;
    fn i32_try_into_i8(&mut self, arg0: i32) -> Option<i8>;
    fn i32_unwrap_into_i8(&mut self, arg0: i32) -> i8;
    fn i32_truncate_into_i8(&mut self, arg0: i32) -> i8;
    fn i32_from_i8(&mut self, arg0: i32) -> Option<i8>;
    fn i32_try_into_u8(&mut self, arg0: i32) -> Option<u8>;
    fn i32_unwrap_into_u8(&mut self, arg0: i32) -> u8;
    fn i32_from_u8(&mut self, arg0: i32) -> Option<u8>;
    fn i32_try_into_i16(&mut self, arg0: i32) -> Option<i16>;
    fn i32_unwrap_into_i16(&mut self, arg0: i32) -> i16;
    fn i32_truncate_into_i16(&mut self, arg0: i32) -> i16;
    fn i32_from_i16(&mut self, arg0: i32) -> Option<i16>;
    fn i32_try_into_u16(&mut self, arg0: i32) -> Option<u16>;
    fn i32_unwrap_into_u16(&mut self, arg0: i32) -> u16;
    fn i32_from_u16(&mut self, arg0: i32) -> Option<u16>;
    fn i32_try_into_u32(&mut self, arg0: i32) -> Option<u32>;
    fn i32_unwrap_into_u32(&mut self, arg0: i32) -> u32;
    fn i32_cast_unsigned(&mut self, arg0: i32) -> u32;
    fn i32_from_u32(&mut self, arg0: i32) -> Option<u32>;
    fn i32_into_i64(&mut self, arg0: i32) -> i64;
    fn i32_from_i64(&mut self, arg0: i32) -> Option<i64>;
    fn i32_try_into_u64(&mut self, arg0: i32) -> Option<u64>;
    fn i32_unwrap_into_u64(&mut self, arg0: i32) -> u64;
    fn i32_from_u64(&mut self, arg0: i32) -> Option<u64>;
    fn i32_into_i128(&mut self, arg0: i32) -> i128;
    fn i32_from_i128(&mut self, arg0: i32) -> Option<i128>;
    fn i32_try_into_u128(&mut self, arg0: i32) -> Option<u128>;
    fn i32_unwrap_into_u128(&mut self, arg0: i32) -> u128;
    fn i32_from_u128(&mut self, arg0: i32) -> Option<u128>;
    fn u32_try_into_i8(&mut self, arg0: u32) -> Option<i8>;
    fn u32_unwrap_into_i8(&mut self, arg0: u32) -> i8;
    fn u32_from_i8(&mut self, arg0: u32) -> Option<i8>;
    fn u32_try_into_u8(&mut self, arg0: u32) -> Option<u8>;
    fn u32_unwrap_into_u8(&mut self, arg0: u32) -> u8;
    fn u32_truncate_into_u8(&mut self, arg0: u32) -> u8;
    fn u32_from_u8(&mut self, arg0: u32) -> Option<u8>;
    fn u32_try_into_i16(&mut self, arg0: u32) -> Option<i16>;
    fn u32_unwrap_into_i16(&mut self, arg0: u32) -> i16;
    fn u32_from_i16(&mut self, arg0: u32) -> Option<i16>;
    fn u32_try_into_u16(&mut self, arg0: u32) -> Option<u16>;
    fn u32_unwrap_into_u16(&mut self, arg0: u32) -> u16;
    fn u32_truncate_into_u16(&mut self, arg0: u32) -> u16;
    fn u32_from_u16(&mut self, arg0: u32) -> Option<u16>;
    fn u32_try_into_i32(&mut self, arg0: u32) -> Option<i32>;
    fn u32_unwrap_into_i32(&mut self, arg0: u32) -> i32;
    fn u32_cast_signed(&mut self, arg0: u32) -> i32;
    fn u32_from_i32(&mut self, arg0: u32) -> Option<i32>;
    fn u32_into_i64(&mut self, arg0: u32) -> i64;
    fn u32_from_i64(&mut self, arg0: u32) -> Option<i64>;
    fn u32_into_u64(&mut self, arg0: u32) -> u64;
    fn u32_from_u64(&mut self, arg0: u32) -> Option<u64>;
    fn u32_into_i128(&mut self, arg0: u32) -> i128;
    fn u32_from_i128(&mut self, arg0: u32) -> Option<i128>;
    fn u32_into_u128(&mut self, arg0: u32) -> u128;
    fn u32_from_u128(&mut self, arg0: u32) -> Option<u128>;
    fn i64_try_into_i8(&mut self, arg0: i64) -> Option<i8>;
    fn i64_unwrap_into_i8(&mut self, arg0: i64) -> i8;
    fn i64_truncate_into_i8(&mut self, arg0: i64) -> i8;
    fn i64_from_i8(&mut self, arg0: i64) -> Option<i8>;
    fn i64_try_into_u8(&mut self, arg0: i64) -> Option<u8>;
    fn i64_unwrap_into_u8(&mut self, arg0: i64) -> u8;
    fn i64_from_u8(&mut self, arg0: i64) -> Option<u8>;
    fn i64_try_into_i16(&mut self, arg0: i64) -> Option<i16>;
    fn i64_unwrap_into_i16(&mut self, arg0: i64) -> i16;
    fn i64_truncate_into_i16(&mut self, arg0: i64) -> i16;
    fn i64_from_i16(&mut self, arg0: i64) -> Option<i16>;
    fn i64_try_into_u16(&mut self, arg0: i64) -> Option<u16>;
    fn i64_unwrap_into_u16(&mut self, arg0: i64) -> u16;
    fn i64_from_u16(&mut self, arg0: i64) -> Option<u16>;
    fn i64_try_into_i32(&mut self, arg0: i64) -> Option<i32>;
    fn i64_unwrap_into_i32(&mut self, arg0: i64) -> i32;
    fn i64_truncate_into_i32(&mut self, arg0: i64) -> i32;
    fn i64_from_i32(&mut self, arg0: i64) -> Option<i32>;
    fn i64_try_into_u32(&mut self, arg0: i64) -> Option<u32>;
    fn i64_unwrap_into_u32(&mut self, arg0: i64) -> u32;
    fn i64_from_u32(&mut self, arg0: i64) -> Option<u32>;
    fn i64_try_into_u64(&mut self, arg0: i64) -> Option<u64>;
    fn i64_unwrap_into_u64(&mut self, arg0: i64) -> u64;
    fn i64_cast_unsigned(&mut self, arg0: i64) -> u64;
    fn i64_from_u64(&mut self, arg0: i64) -> Option<u64>;
    fn i64_into_i128(&mut self, arg0: i64) -> i128;
    fn i64_from_i128(&mut self, arg0: i64) -> Option<i128>;
    fn i64_try_into_u128(&mut self, arg0: i64) -> Option<u128>;
    fn i64_unwrap_into_u128(&mut self, arg0: i64) -> u128;
    fn i64_from_u128(&mut self, arg0: i64) -> Option<u128>;
    fn u64_try_into_i8(&mut self, arg0: u64) -> Option<i8>;
    fn u64_unwrap_into_i8(&mut self, arg0: u64) -> i8;
    fn u64_from_i8(&mut self, arg0: u64) -> Option<i8>;
    fn u64_try_into_u8(&mut self, arg0: u64) -> Option<u8>;
    fn u64_unwrap_into_u8(&mut self, arg0: u64) -> u8;
    fn u64_truncate_into_u8(&mut self, arg0: u64) -> u8;
    fn u64_from_u8(&mut self, arg0: u64) -> Option<u8>;
    fn u64_try_into_i16(&mut self, arg0: u64) -> Option<i16>;
    fn u64_unwrap_into_i16(&mut self, arg0: u64) -> i16;
    fn u64_from_i16(&mut self, arg0: u64) -> Option<i16>;
    fn u64_try_into_u16(&mut self, arg0: u64) -> Option<u16>;
    fn u64_unwrap_into_u16(&mut self, arg0: u64) -> u16;
    fn u64_truncate_into_u16(&mut self, arg0: u64) -> u16;
    fn u64_from_u16(&mut self, arg0: u64) -> Option<u16>;
    fn u64_try_into_i32(&mut self, arg0: u64) -> Option<i32>;
    fn u64_unwrap_into_i32(&mut self, arg0: u64) -> i32;
    fn u64_from_i32(&mut self, arg0: u64) -> Option<i32>;
    fn u64_try_into_u32(&mut self, arg0: u64) -> Option<u32>;
    fn u64_unwrap_into_u32(&mut self, arg0: u64) -> u32;
    fn u64_truncate_into_u32(&mut self, arg0: u64) -> u32;
    fn u64_from_u32(&mut self, arg0: u64) -> Option<u32>;
    fn u64_try_into_i64(&mut self, arg0: u64) -> Option<i64>;
    fn u64_unwrap_into_i64(&mut self, arg0: u64) -> i64;
    fn u64_cast_signed(&mut self, arg0: u64) -> i64;
    fn u64_from_i64(&mut self, arg0: u64) -> Option<i64>;
    fn u64_into_i128(&mut self, arg0: u64) -> i128;
    fn u64_from_i128(&mut self, arg0: u64) -> Option<i128>;
    fn u64_into_u128(&mut self, arg0: u64) -> u128;
    fn u64_from_u128(&mut self, arg0: u64) -> Option<u128>;
    fn i128_try_into_i8(&mut self, arg0: i128) -> Option<i8>;
    fn i128_unwrap_into_i8(&mut self, arg0: i128) -> i8;
    fn i128_truncate_into_i8(&mut self, arg0: i128) -> i8;
    fn i128_from_i8(&mut self, arg0: i128) -> Option<i8>;
    fn i128_try_into_u8(&mut self, arg0: i128) -> Option<u8>;
    fn i128_unwrap_into_u8(&mut self, arg0: i128) -> u8;
    fn i128_from_u8(&mut self, arg0: i128) -> Option<u8>;
    fn i128_try_into_i16(&mut self, arg0: i128) -> Option<i16>;
    fn i128_unwrap_into_i16(&mut self, arg0: i128) -> i16;
    fn i128_truncate_into_i16(&mut self, arg0: i128) -> i16;
    fn i128_from_i16(&mut self, arg0: i128) -> Option<i16>;
    fn i128_try_into_u16(&mut self, arg0: i128) -> Option<u16>;
    fn i128_unwrap_into_u16(&mut self, arg0: i128) -> u16;
    fn i128_from_u16(&mut self, arg0: i128) -> Option<u16>;
    fn i128_try_into_i32(&mut self, arg0: i128) -> Option<i32>;
    fn i128_unwrap_into_i32(&mut self, arg0: i128) -> i32;
    fn i128_truncate_into_i32(&mut self, arg0: i128) -> i32;
    fn i128_from_i32(&mut self, arg0: i128) -> Option<i32>;
    fn i128_try_into_u32(&mut self, arg0: i128) -> Option<u32>;
    fn i128_unwrap_into_u32(&mut self, arg0: i128) -> u32;
    fn i128_from_u32(&mut self, arg0: i128) -> Option<u32>;
    fn i128_try_into_i64(&mut self, arg0: i128) -> Option<i64>;
    fn i128_unwrap_into_i64(&mut self, arg0: i128) -> i64;
    fn i128_truncate_into_i64(&mut self, arg0: i128) -> i64;
    fn i128_from_i64(&mut self, arg0: i128) -> Option<i64>;
    fn i128_try_into_u64(&mut self, arg0: i128) -> Option<u64>;
    fn i128_unwrap_into_u64(&mut self, arg0: i128) -> u64;
    fn i128_from_u64(&mut self, arg0: i128) -> Option<u64>;
    fn i128_try_into_u128(&mut self, arg0: i128) -> Option<u128>;
    fn i128_unwrap_into_u128(&mut self, arg0: i128) -> u128;
    fn i128_cast_unsigned(&mut self, arg0: i128) -> u128;
    fn i128_from_u128(&mut self, arg0: i128) -> Option<u128>;
    fn u128_try_into_i8(&mut self, arg0: u128) -> Option<i8>;
    fn u128_unwrap_into_i8(&mut self, arg0: u128) -> i8;
    fn u128_from_i8(&mut self, arg0: u128) -> Option<i8>;
    fn u128_try_into_u8(&mut self, arg0: u128) -> Option<u8>;
    fn u128_unwrap_into_u8(&mut self, arg0: u128) -> u8;
    fn u128_truncate_into_u8(&mut self, arg0: u128) -> u8;
    fn u128_from_u8(&mut self, arg0: u128) -> Option<u8>;
    fn u128_try_into_i16(&mut self, arg0: u128) -> Option<i16>;
    fn u128_unwrap_into_i16(&mut self, arg0: u128) -> i16;
    fn u128_from_i16(&mut self, arg0: u128) -> Option<i16>;
    fn u128_try_into_u16(&mut self, arg0: u128) -> Option<u16>;
    fn u128_unwrap_into_u16(&mut self, arg0: u128) -> u16;
    fn u128_truncate_into_u16(&mut self, arg0: u128) -> u16;
    fn u128_from_u16(&mut self, arg0: u128) -> Option<u16>;
    fn u128_try_into_i32(&mut self, arg0: u128) -> Option<i32>;
    fn u128_unwrap_into_i32(&mut self, arg0: u128) -> i32;
    fn u128_from_i32(&mut self, arg0: u128) -> Option<i32>;
    fn u128_try_into_u32(&mut self, arg0: u128) -> Option<u32>;
    fn u128_unwrap_into_u32(&mut self, arg0: u128) -> u32;
    fn u128_truncate_into_u32(&mut self, arg0: u128) -> u32;
    fn u128_from_u32(&mut self, arg0: u128) -> Option<u32>;
    fn u128_try_into_i64(&mut self, arg0: u128) -> Option<i64>;
    fn u128_unwrap_into_i64(&mut self, arg0: u128) -> i64;
    fn u128_from_i64(&mut self, arg0: u128) -> Option<i64>;
    fn u128_try_into_u64(&mut self, arg0: u128) -> Option<u64>;
    fn u128_unwrap_into_u64(&mut self, arg0: u128) -> u64;
    fn u128_truncate_into_u64(&mut self, arg0: u128) -> u64;
    fn u128_from_u64(&mut self, arg0: u128) -> Option<u64>;
    fn u128_try_into_i128(&mut self, arg0: u128) -> Option<i128>;
    fn u128_unwrap_into_i128(&mut self, arg0: u128) -> i128;
    fn u128_cast_signed(&mut self, arg0: u128) -> i128;
    fn u128_from_i128(&mut self, arg0: u128) -> Option<i128>;
    fn unpack_value_array_2(&mut self, arg0: &ValueArray2) -> (Value, Value);
    fn pack_value_array_2(&mut self, arg0: Value, arg1: Value) -> ValueArray2;
    fn unpack_value_array_3(&mut self, arg0: &ValueArray3) -> (Value, Value, Value);
    fn pack_value_array_3(&mut self, arg0: Value, arg1: Value, arg2: Value) -> ValueArray3;
    fn unpack_block_array_2(&mut self, arg0: &BlockArray2) -> (BlockCall, BlockCall);
    fn pack_block_array_2(&mut self, arg0: BlockCall, arg1: BlockCall) -> BlockArray2;
    fn x64_pabsb_a_raw(&mut self, arg0: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_vpabsb_a_raw(&mut self, arg0: &XmmMem128) -> AssemblerOutputs;
    fn x64_pabsw_a_raw(&mut self, arg0: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_vpabsw_a_raw(&mut self, arg0: &XmmMem128) -> AssemblerOutputs;
    fn x64_pabsd_a_raw(&mut self, arg0: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_vpabsd_a_raw(&mut self, arg0: &XmmMem128) -> AssemblerOutputs;
    fn x64_vpabsd_c_raw(&mut self, arg0: &XmmMem128) -> AssemblerOutputs;
    fn x64_vpabsq_c_raw(&mut self, arg0: &XmmMem128) -> 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: &GprMem8, arg1: u8) -> AssemblerOutputs;
    fn x64_addw_mi_raw(&mut self, arg0: &GprMem16, arg1: u16) -> AssemblerOutputs;
    fn x64_addl_mi_raw(&mut self, arg0: &GprMem32, arg1: u32) -> AssemblerOutputs;
    fn x64_addq_mi_sxl_raw(&mut self, arg0: &GprMem64, arg1: i32) -> AssemblerOutputs;
    fn x64_addl_mi_sxb_raw(&mut self, arg0: &GprMem32, arg1: i8) -> AssemblerOutputs;
    fn x64_addq_mi_sxb_raw(&mut self, arg0: &GprMem64, arg1: i8) -> AssemblerOutputs;
    fn x64_addb_mr_raw(&mut self, arg0: &GprMem8, arg1: Gpr) -> AssemblerOutputs;
    fn x64_addw_mr_raw(&mut self, arg0: &GprMem16, arg1: Gpr) -> AssemblerOutputs;
    fn x64_addl_mr_raw(&mut self, arg0: &GprMem32, arg1: Gpr) -> AssemblerOutputs;
    fn x64_addq_mr_raw(&mut self, arg0: &GprMem64, arg1: Gpr) -> AssemblerOutputs;
    fn x64_addb_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem8) -> AssemblerOutputs;
    fn x64_addw_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem16) -> AssemblerOutputs;
    fn x64_addl_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem32) -> AssemblerOutputs;
    fn x64_addq_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem64) -> 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: &GprMem8, arg1: u8) -> AssemblerOutputs;
    fn x64_adcw_mi_raw(&mut self, arg0: &GprMem16, arg1: u16) -> AssemblerOutputs;
    fn x64_adcl_mi_raw(&mut self, arg0: &GprMem32, arg1: u32) -> AssemblerOutputs;
    fn x64_adcq_mi_sxl_raw(&mut self, arg0: &GprMem64, arg1: i32) -> AssemblerOutputs;
    fn x64_adcl_mi_sxb_raw(&mut self, arg0: &GprMem32, arg1: i8) -> AssemblerOutputs;
    fn x64_adcq_mi_sxb_raw(&mut self, arg0: &GprMem64, arg1: i8) -> AssemblerOutputs;
    fn x64_adcb_mr_raw(&mut self, arg0: &GprMem8, arg1: Gpr) -> AssemblerOutputs;
    fn x64_adcw_mr_raw(&mut self, arg0: &GprMem16, arg1: Gpr) -> AssemblerOutputs;
    fn x64_adcl_mr_raw(&mut self, arg0: &GprMem32, arg1: Gpr) -> AssemblerOutputs;
    fn x64_adcq_mr_raw(&mut self, arg0: &GprMem64, arg1: Gpr) -> AssemblerOutputs;
    fn x64_adcb_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem8) -> AssemblerOutputs;
    fn x64_adcw_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem16) -> AssemblerOutputs;
    fn x64_adcl_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem32) -> AssemblerOutputs;
    fn x64_adcq_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem64) -> 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: &XmmMem32) -> AssemblerOutputs;
    fn x64_addsd_a_raw(&mut self, arg0: Xmm, arg1: &XmmMem64) -> AssemblerOutputs;
    fn x64_addps_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_addpd_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_paddb_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_paddw_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_paddd_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_paddq_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_paddsb_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_paddsw_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_paddusb_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_paddusw_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_phaddw_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_phaddd_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_vaddss_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem32) -> AssemblerOutputs;
    fn x64_vaddsd_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem64) -> AssemblerOutputs;
    fn x64_vaddps_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_vaddpd_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_vpaddb_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_vpaddw_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_vpaddd_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_vpaddq_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_vpaddsb_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_vpaddsw_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_vpaddusb_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_vpaddusw_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_vphaddw_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_vphaddd_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_vaddpd_c_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_palignr_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128, arg2: u8) -> AssemblerOutputs;
    fn x64_vpalignr_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem128, 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: &GprMem8, arg1: u8) -> AssemblerOutputs;
    fn x64_andw_mi_raw(&mut self, arg0: &GprMem16, arg1: u16) -> AssemblerOutputs;
    fn x64_andl_mi_raw(&mut self, arg0: &GprMem32, arg1: u32) -> AssemblerOutputs;
    fn x64_andq_mi_sxl_raw(&mut self, arg0: &GprMem64, arg1: i32) -> AssemblerOutputs;
    fn x64_andl_mi_sxb_raw(&mut self, arg0: &GprMem32, arg1: i8) -> AssemblerOutputs;
    fn x64_andq_mi_sxb_raw(&mut self, arg0: &GprMem64, arg1: i8) -> AssemblerOutputs;
    fn x64_andb_mr_raw(&mut self, arg0: &GprMem8, arg1: Gpr) -> AssemblerOutputs;
    fn x64_andw_mr_raw(&mut self, arg0: &GprMem16, arg1: Gpr) -> AssemblerOutputs;
    fn x64_andl_mr_raw(&mut self, arg0: &GprMem32, arg1: Gpr) -> AssemblerOutputs;
    fn x64_andq_mr_raw(&mut self, arg0: &GprMem64, arg1: Gpr) -> AssemblerOutputs;
    fn x64_andb_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem8) -> AssemblerOutputs;
    fn x64_andw_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem16) -> AssemblerOutputs;
    fn x64_andl_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem32) -> AssemblerOutputs;
    fn x64_andq_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem64) -> AssemblerOutputs;
    fn x64_andnl_rvm_raw(&mut self, arg0: Gpr, arg1: &GprMem32) -> AssemblerOutputs;
    fn x64_andnq_rvm_raw(&mut self, arg0: Gpr, arg1: &GprMem64) -> 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: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_andpd_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_andnps_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_andnpd_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_pand_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_pandn_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_vandps_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_vandpd_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_vandnps_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_vandnpd_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_vpand_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_vpandn_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> 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: &GprMem8, arg1: Gpr, arg2: Gpr) -> AssemblerOutputs;
    fn x64_cmpxchgw_mr_raw(&mut self, arg0: &GprMem16, arg1: Gpr, arg2: Gpr) -> AssemblerOutputs;
    fn x64_cmpxchgl_mr_raw(&mut self, arg0: &GprMem32, arg1: Gpr, arg2: Gpr) -> AssemblerOutputs;
    fn x64_cmpxchgq_mr_raw(&mut self, arg0: &GprMem64, 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: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_pavgw_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_vpavgb_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_vpavgw_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_bsfw_rm_raw(&mut self, arg0: &GprMem16) -> AssemblerOutputs;
    fn x64_bsfl_rm_raw(&mut self, arg0: &GprMem32) -> AssemblerOutputs;
    fn x64_bsfq_rm_raw(&mut self, arg0: &GprMem64) -> AssemblerOutputs;
    fn x64_bsrw_rm_raw(&mut self, arg0: &GprMem16) -> AssemblerOutputs;
    fn x64_bsrl_rm_raw(&mut self, arg0: &GprMem32) -> AssemblerOutputs;
    fn x64_bsrq_rm_raw(&mut self, arg0: &GprMem64) -> AssemblerOutputs;
    fn x64_tzcntw_a_raw(&mut self, arg0: &GprMem16) -> AssemblerOutputs;
    fn x64_tzcntl_a_raw(&mut self, arg0: &GprMem32) -> AssemblerOutputs;
    fn x64_tzcntq_a_raw(&mut self, arg0: &GprMem64) -> AssemblerOutputs;
    fn x64_lzcntw_rm_raw(&mut self, arg0: &GprMem16) -> AssemblerOutputs;
    fn x64_lzcntl_rm_raw(&mut self, arg0: &GprMem32) -> AssemblerOutputs;
    fn x64_lzcntq_rm_raw(&mut self, arg0: &GprMem64) -> AssemblerOutputs;
    fn x64_popcntw_rm_raw(&mut self, arg0: &GprMem16) -> AssemblerOutputs;
    fn x64_popcntl_rm_raw(&mut self, arg0: &GprMem32) -> AssemblerOutputs;
    fn x64_popcntq_rm_raw(&mut self, arg0: &GprMem64) -> AssemblerOutputs;
    fn x64_btw_mr_raw(&mut self, arg0: &GprMem16, arg1: Gpr) -> AssemblerOutputs;
    fn x64_btl_mr_raw(&mut self, arg0: &GprMem32, arg1: Gpr) -> AssemblerOutputs;
    fn x64_btq_mr_raw(&mut self, arg0: &GprMem64, arg1: Gpr) -> AssemblerOutputs;
    fn x64_btw_mi_raw(&mut self, arg0: &GprMem16, arg1: u8) -> AssemblerOutputs;
    fn x64_btl_mi_raw(&mut self, arg0: &GprMem32, arg1: u8) -> AssemblerOutputs;
    fn x64_btq_mi_raw(&mut self, arg0: &GprMem64, 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: &GprMem32) -> AssemblerOutputs;
    fn x64_blsrq_vm_raw(&mut self, arg0: &GprMem64) -> AssemblerOutputs;
    fn x64_blsmskl_vm_raw(&mut self, arg0: &GprMem32) -> AssemblerOutputs;
    fn x64_blsmskq_vm_raw(&mut self, arg0: &GprMem64) -> AssemblerOutputs;
    fn x64_blsil_vm_raw(&mut self, arg0: &GprMem32) -> AssemblerOutputs;
    fn x64_blsiq_vm_raw(&mut self, arg0: &GprMem64) -> AssemblerOutputs;
    fn x64_bzhil_rmv_raw(&mut self, arg0: &GprMem32, arg1: Gpr) -> AssemblerOutputs;
    fn x64_bzhiq_rmv_raw(&mut self, arg0: &GprMem64, arg1: Gpr) -> AssemblerOutputs;
    fn x64_vpopcntb_a_raw(&mut self, arg0: &XmmMem128) -> AssemblerOutputs;
    fn x64_vpopcntw_a_raw(&mut self, arg0: &XmmMem128) -> AssemblerOutputs;
    fn x64_cmovaw_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem16) -> AssemblerOutputs;
    fn x64_cmoval_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem32) -> AssemblerOutputs;
    fn x64_cmovaq_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem64) -> AssemblerOutputs;
    fn x64_cmovaew_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem16) -> AssemblerOutputs;
    fn x64_cmovael_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem32) -> AssemblerOutputs;
    fn x64_cmovaeq_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem64) -> AssemblerOutputs;
    fn x64_cmovbw_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem16) -> AssemblerOutputs;
    fn x64_cmovbl_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem32) -> AssemblerOutputs;
    fn x64_cmovbq_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem64) -> AssemblerOutputs;
    fn x64_cmovbew_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem16) -> AssemblerOutputs;
    fn x64_cmovbel_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem32) -> AssemblerOutputs;
    fn x64_cmovbeq_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem64) -> AssemblerOutputs;
    fn x64_cmovew_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem16) -> AssemblerOutputs;
    fn x64_cmovel_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem32) -> AssemblerOutputs;
    fn x64_cmoveq_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem64) -> AssemblerOutputs;
    fn x64_cmovgw_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem16) -> AssemblerOutputs;
    fn x64_cmovgl_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem32) -> AssemblerOutputs;
    fn x64_cmovgq_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem64) -> AssemblerOutputs;
    fn x64_cmovgew_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem16) -> AssemblerOutputs;
    fn x64_cmovgel_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem32) -> AssemblerOutputs;
    fn x64_cmovgeq_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem64) -> AssemblerOutputs;
    fn x64_cmovlw_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem16) -> AssemblerOutputs;
    fn x64_cmovll_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem32) -> AssemblerOutputs;
    fn x64_cmovlq_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem64) -> AssemblerOutputs;
    fn x64_cmovlew_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem16) -> AssemblerOutputs;
    fn x64_cmovlel_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem32) -> AssemblerOutputs;
    fn x64_cmovleq_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem64) -> AssemblerOutputs;
    fn x64_cmovnew_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem16) -> AssemblerOutputs;
    fn x64_cmovnel_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem32) -> AssemblerOutputs;
    fn x64_cmovneq_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem64) -> AssemblerOutputs;
    fn x64_cmovnow_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem16) -> AssemblerOutputs;
    fn x64_cmovnol_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem32) -> AssemblerOutputs;
    fn x64_cmovnoq_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem64) -> AssemblerOutputs;
    fn x64_cmovnpw_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem16) -> AssemblerOutputs;
    fn x64_cmovnpl_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem32) -> AssemblerOutputs;
    fn x64_cmovnpq_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem64) -> AssemblerOutputs;
    fn x64_cmovnsw_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem16) -> AssemblerOutputs;
    fn x64_cmovnsl_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem32) -> AssemblerOutputs;
    fn x64_cmovnsq_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem64) -> AssemblerOutputs;
    fn x64_cmovow_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem16) -> AssemblerOutputs;
    fn x64_cmovol_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem32) -> AssemblerOutputs;
    fn x64_cmovoq_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem64) -> AssemblerOutputs;
    fn x64_cmovpw_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem16) -> AssemblerOutputs;
    fn x64_cmovpl_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem32) -> AssemblerOutputs;
    fn x64_cmovpq_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem64) -> AssemblerOutputs;
    fn x64_cmovsw_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem16) -> AssemblerOutputs;
    fn x64_cmovsl_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem32) -> AssemblerOutputs;
    fn x64_cmovsq_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem64) -> 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: &GprMem8, arg1: u8) -> AssemblerOutputs;
    fn x64_cmpw_mi_raw(&mut self, arg0: &GprMem16, arg1: u16) -> AssemblerOutputs;
    fn x64_cmpl_mi_raw(&mut self, arg0: &GprMem32, arg1: u32) -> AssemblerOutputs;
    fn x64_cmpq_mi_raw(&mut self, arg0: &GprMem64, arg1: i32) -> AssemblerOutputs;
    fn x64_cmpw_mi_sxb_raw(&mut self, arg0: &GprMem16, arg1: i8) -> AssemblerOutputs;
    fn x64_cmpl_mi_sxb_raw(&mut self, arg0: &GprMem32, arg1: i8) -> AssemblerOutputs;
    fn x64_cmpq_mi_sxb_raw(&mut self, arg0: &GprMem64, arg1: i8) -> AssemblerOutputs;
    fn x64_cmpb_mr_raw(&mut self, arg0: &GprMem8, arg1: Gpr) -> AssemblerOutputs;
    fn x64_cmpw_mr_raw(&mut self, arg0: &GprMem16, arg1: Gpr) -> AssemblerOutputs;
    fn x64_cmpl_mr_raw(&mut self, arg0: &GprMem32, arg1: Gpr) -> AssemblerOutputs;
    fn x64_cmpq_mr_raw(&mut self, arg0: &GprMem64, arg1: Gpr) -> AssemblerOutputs;
    fn x64_cmpb_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem8) -> AssemblerOutputs;
    fn x64_cmpw_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem16) -> AssemblerOutputs;
    fn x64_cmpl_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem32) -> AssemblerOutputs;
    fn x64_cmpq_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem64) -> 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: &GprMem8, arg1: u8) -> AssemblerOutputs;
    fn x64_testw_mi_raw(&mut self, arg0: &GprMem16, arg1: u16) -> AssemblerOutputs;
    fn x64_testl_mi_raw(&mut self, arg0: &GprMem32, arg1: u32) -> AssemblerOutputs;
    fn x64_testq_mi_raw(&mut self, arg0: &GprMem64, arg1: i32) -> AssemblerOutputs;
    fn x64_testb_mr_raw(&mut self, arg0: &GprMem8, arg1: Gpr) -> AssemblerOutputs;
    fn x64_testw_mr_raw(&mut self, arg0: &GprMem16, arg1: Gpr) -> AssemblerOutputs;
    fn x64_testl_mr_raw(&mut self, arg0: &GprMem32, arg1: Gpr) -> AssemblerOutputs;
    fn x64_testq_mr_raw(&mut self, arg0: &GprMem64, arg1: Gpr) -> AssemblerOutputs;
    fn x64_ptest_rm_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_vptest_rm_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_ucomiss_a_raw(&mut self, arg0: Xmm, arg1: &XmmMem32) -> AssemblerOutputs;
    fn x64_ucomisd_a_raw(&mut self, arg0: Xmm, arg1: &XmmMem64) -> AssemblerOutputs;
    fn x64_vucomiss_a_raw(&mut self, arg0: Xmm, arg1: &XmmMem32) -> AssemblerOutputs;
    fn x64_vucomisd_a_raw(&mut self, arg0: Xmm, arg1: &XmmMem64) -> AssemblerOutputs;
    fn x64_cmpss_a_raw(&mut self, arg0: Xmm, arg1: &XmmMem32, arg2: u8) -> AssemblerOutputs;
    fn x64_cmpsd_a_raw(&mut self, arg0: Xmm, arg1: &XmmMem64, arg2: u8) -> AssemblerOutputs;
    fn x64_cmpps_a_raw(&mut self, arg0: Xmm, arg1: &XmmMem128, arg2: u8) -> AssemblerOutputs;
    fn x64_cmppd_a_raw(&mut self, arg0: Xmm, arg1: &XmmMem128, arg2: u8) -> AssemblerOutputs;
    fn x64_vcmpss_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem32, arg2: u8) -> AssemblerOutputs;
    fn x64_vcmpsd_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem64, arg2: u8) -> AssemblerOutputs;
    fn x64_vcmpps_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem128, arg2: u8) -> AssemblerOutputs;
    fn x64_vcmppd_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem128, arg2: u8) -> AssemblerOutputs;
    fn x64_pcmpeqb_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_pcmpeqw_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_pcmpeqd_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_pcmpeqq_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_pcmpgtb_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_pcmpgtw_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_pcmpgtd_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_pcmpgtq_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_vpcmpeqb_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_vpcmpeqw_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_vpcmpeqd_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_vpcmpeqq_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_vpcmpgtb_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_vpcmpgtw_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_vpcmpgtd_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_vpcmpgtq_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_cvtps2pd_a_raw(&mut self, arg0: &XmmMem64) -> AssemblerOutputs;
    fn x64_cvttps2dq_a_raw(&mut self, arg0: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_cvtss2sd_a_raw(&mut self, arg0: Xmm, arg1: &XmmMem32) -> AssemblerOutputs;
    fn x64_cvtss2si_a_raw(&mut self, arg0: &XmmMem32) -> AssemblerOutputs;
    fn x64_cvtss2si_aq_raw(&mut self, arg0: &XmmMem32) -> AssemblerOutputs;
    fn x64_cvttss2si_a_raw(&mut self, arg0: &XmmMem32) -> AssemblerOutputs;
    fn x64_cvttss2si_aq_raw(&mut self, arg0: &XmmMem32) -> AssemblerOutputs;
    fn x64_vcvtps2pd_a_raw(&mut self, arg0: &XmmMem64) -> AssemblerOutputs;
    fn x64_vcvttps2dq_a_raw(&mut self, arg0: &XmmMem128) -> AssemblerOutputs;
    fn x64_vcvtss2sd_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem32) -> AssemblerOutputs;
    fn x64_vcvtss2si_a_raw(&mut self, arg0: &XmmMem32) -> AssemblerOutputs;
    fn x64_vcvtss2si_aq_raw(&mut self, arg0: &XmmMem32) -> AssemblerOutputs;
    fn x64_vcvttss2si_a_raw(&mut self, arg0: &XmmMem32) -> AssemblerOutputs;
    fn x64_vcvttss2si_aq_raw(&mut self, arg0: &XmmMem32) -> AssemblerOutputs;
    fn x64_cvtpd2ps_a_raw(&mut self, arg0: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_cvttpd2dq_a_raw(&mut self, arg0: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_cvtsd2ss_a_raw(&mut self, arg0: Xmm, arg1: &XmmMem64) -> AssemblerOutputs;
    fn x64_cvtsd2si_a_raw(&mut self, arg0: &XmmMem64) -> AssemblerOutputs;
    fn x64_cvtsd2si_aq_raw(&mut self, arg0: &XmmMem64) -> AssemblerOutputs;
    fn x64_cvttsd2si_a_raw(&mut self, arg0: &XmmMem64) -> AssemblerOutputs;
    fn x64_cvttsd2si_aq_raw(&mut self, arg0: &XmmMem64) -> AssemblerOutputs;
    fn x64_vcvtpd2ps_a_raw(&mut self, arg0: &XmmMem128) -> AssemblerOutputs;
    fn x64_vcvttpd2dq_a_raw(&mut self, arg0: &XmmMem128) -> AssemblerOutputs;
    fn x64_vcvtsd2ss_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem64) -> AssemblerOutputs;
    fn x64_vcvtsd2si_a_raw(&mut self, arg0: &XmmMem64) -> AssemblerOutputs;
    fn x64_vcvtsd2si_aq_raw(&mut self, arg0: &XmmMem64) -> AssemblerOutputs;
    fn x64_vcvttsd2si_a_raw(&mut self, arg0: &XmmMem64) -> AssemblerOutputs;
    fn x64_vcvttsd2si_aq_raw(&mut self, arg0: &XmmMem64) -> AssemblerOutputs;
    fn x64_cvtdq2ps_a_raw(&mut self, arg0: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_cvtdq2pd_a_raw(&mut self, arg0: &XmmMem64) -> AssemblerOutputs;
    fn x64_cvtsi2ssl_a_raw(&mut self, arg0: Xmm, arg1: &GprMem32) -> AssemblerOutputs;
    fn x64_cvtsi2ssq_a_raw(&mut self, arg0: Xmm, arg1: &GprMem64) -> AssemblerOutputs;
    fn x64_cvtsi2sdl_a_raw(&mut self, arg0: Xmm, arg1: &GprMem32) -> AssemblerOutputs;
    fn x64_cvtsi2sdq_a_raw(&mut self, arg0: Xmm, arg1: &GprMem64) -> AssemblerOutputs;
    fn x64_vcvtdq2pd_a_raw(&mut self, arg0: &XmmMem64) -> AssemblerOutputs;
    fn x64_vcvtdq2ps_a_raw(&mut self, arg0: &XmmMem128) -> AssemblerOutputs;
    fn x64_vcvtsi2sdl_b_raw(&mut self, arg0: Xmm, arg1: &GprMem32) -> AssemblerOutputs;
    fn x64_vcvtsi2sdq_b_raw(&mut self, arg0: Xmm, arg1: &GprMem64) -> AssemblerOutputs;
    fn x64_vcvtsi2ssl_b_raw(&mut self, arg0: Xmm, arg1: &GprMem32) -> AssemblerOutputs;
    fn x64_vcvtsi2ssq_b_raw(&mut self, arg0: Xmm, arg1: &GprMem64) -> AssemblerOutputs;
    fn x64_vcvtudq2ps_a_raw(&mut self, arg0: &XmmMem128) -> AssemblerOutputs;
    fn x64_divb_m_raw(&mut self, arg0: Gpr, arg1: &GprMem8, arg2: &TrapCode) -> AssemblerOutputs;
    fn x64_divw_m_raw(&mut self, arg0: Gpr, arg1: Gpr, arg2: &GprMem16, arg3: &TrapCode) -> AssemblerOutputs;
    fn x64_divl_m_raw(&mut self, arg0: Gpr, arg1: Gpr, arg2: &GprMem32, arg3: &TrapCode) -> AssemblerOutputs;
    fn x64_divq_m_raw(&mut self, arg0: Gpr, arg1: Gpr, arg2: &GprMem64, arg3: &TrapCode) -> AssemblerOutputs;
    fn x64_idivb_m_raw(&mut self, arg0: Gpr, arg1: &GprMem8, arg2: &TrapCode) -> AssemblerOutputs;
    fn x64_idivw_m_raw(&mut self, arg0: Gpr, arg1: Gpr, arg2: &GprMem16, arg3: &TrapCode) -> AssemblerOutputs;
    fn x64_idivl_m_raw(&mut self, arg0: Gpr, arg1: Gpr, arg2: &GprMem32, arg3: &TrapCode) -> AssemblerOutputs;
    fn x64_idivq_m_raw(&mut self, arg0: Gpr, arg1: Gpr, arg2: &GprMem64, arg3: &TrapCode) -> AssemblerOutputs;
    fn x64_divss_a_raw(&mut self, arg0: Xmm, arg1: &XmmMem32) -> AssemblerOutputs;
    fn x64_divsd_a_raw(&mut self, arg0: Xmm, arg1: &XmmMem64) -> AssemblerOutputs;
    fn x64_divps_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_divpd_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_vdivss_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem32) -> AssemblerOutputs;
    fn x64_vdivsd_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem64) -> AssemblerOutputs;
    fn x64_vdivps_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_vdivpd_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_vfmadd132ss_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem32) -> AssemblerOutputs;
    fn x64_vfmadd213ss_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem32) -> AssemblerOutputs;
    fn x64_vfmadd231ss_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem32) -> AssemblerOutputs;
    fn x64_vfmadd132sd_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem64) -> AssemblerOutputs;
    fn x64_vfmadd213sd_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem64) -> AssemblerOutputs;
    fn x64_vfmadd231sd_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem64) -> AssemblerOutputs;
    fn x64_vfmadd132ps_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem128) -> AssemblerOutputs;
    fn x64_vfmadd213ps_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem128) -> AssemblerOutputs;
    fn x64_vfmadd231ps_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem128) -> AssemblerOutputs;
    fn x64_vfmadd132pd_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem128) -> AssemblerOutputs;
    fn x64_vfmadd213pd_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem128) -> AssemblerOutputs;
    fn x64_vfmadd231pd_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem128) -> AssemblerOutputs;
    fn x64_vfnmadd132ss_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem32) -> AssemblerOutputs;
    fn x64_vfnmadd213ss_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem32) -> AssemblerOutputs;
    fn x64_vfnmadd231ss_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem32) -> AssemblerOutputs;
    fn x64_vfnmadd132sd_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem64) -> AssemblerOutputs;
    fn x64_vfnmadd213sd_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem64) -> AssemblerOutputs;
    fn x64_vfnmadd231sd_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem64) -> AssemblerOutputs;
    fn x64_vfnmadd132ps_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem128) -> AssemblerOutputs;
    fn x64_vfnmadd213ps_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem128) -> AssemblerOutputs;
    fn x64_vfnmadd231ps_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem128) -> AssemblerOutputs;
    fn x64_vfnmadd132pd_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem128) -> AssemblerOutputs;
    fn x64_vfnmadd213pd_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem128) -> AssemblerOutputs;
    fn x64_vfnmadd231pd_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem128) -> AssemblerOutputs;
    fn x64_vfmsub132ss_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem32) -> AssemblerOutputs;
    fn x64_vfmsub213ss_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem32) -> AssemblerOutputs;
    fn x64_vfmsub231ss_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem32) -> AssemblerOutputs;
    fn x64_vfmsub132sd_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem64) -> AssemblerOutputs;
    fn x64_vfmsub213sd_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem64) -> AssemblerOutputs;
    fn x64_vfmsub231sd_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem64) -> AssemblerOutputs;
    fn x64_vfmsub132ps_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem128) -> AssemblerOutputs;
    fn x64_vfmsub213ps_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem128) -> AssemblerOutputs;
    fn x64_vfmsub231ps_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem128) -> AssemblerOutputs;
    fn x64_vfmsub132pd_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem128) -> AssemblerOutputs;
    fn x64_vfmsub213pd_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem128) -> AssemblerOutputs;
    fn x64_vfmsub231pd_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem128) -> AssemblerOutputs;
    fn x64_vfnmsub132ss_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem32) -> AssemblerOutputs;
    fn x64_vfnmsub213ss_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem32) -> AssemblerOutputs;
    fn x64_vfnmsub231ss_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem32) -> AssemblerOutputs;
    fn x64_vfnmsub132sd_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem64) -> AssemblerOutputs;
    fn x64_vfnmsub213sd_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem64) -> AssemblerOutputs;
    fn x64_vfnmsub231sd_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem64) -> AssemblerOutputs;
    fn x64_vfnmsub132ps_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem128) -> AssemblerOutputs;
    fn x64_vfnmsub213ps_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem128) -> AssemblerOutputs;
    fn x64_vfnmsub231ps_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem128) -> AssemblerOutputs;
    fn x64_vfnmsub132pd_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem128) -> AssemblerOutputs;
    fn x64_vfnmsub213pd_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem128) -> AssemblerOutputs;
    fn x64_vfnmsub231pd_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem128) -> AssemblerOutputs;
    fn x64_jmpq_m_raw(&mut self, arg0: &GprMem64) -> 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: &GprMem32, arg1: Xmm, arg2: u8) -> AssemblerOutputs;
    fn x64_pextrb_a_raw(&mut self, arg0: &GprMem32, 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: &GprMem32, arg1: Xmm, arg2: u8) -> AssemblerOutputs;
    fn x64_pextrd_a_raw(&mut self, arg0: &GprMem32, arg1: Xmm, arg2: u8) -> AssemblerOutputs;
    fn x64_pextrq_a_raw(&mut self, arg0: &GprMem64, arg1: Xmm, arg2: u8) -> AssemblerOutputs;
    fn x64_vextractps_b_raw(&mut self, arg0: &GprMem32, arg1: Xmm, arg2: u8) -> AssemblerOutputs;
    fn x64_vpextrb_a_raw(&mut self, arg0: &GprMem32, 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: &GprMem32, arg1: Xmm, arg2: u8) -> AssemblerOutputs;
    fn x64_vpextrd_a_raw(&mut self, arg0: &GprMem32, arg1: Xmm, arg2: u8) -> AssemblerOutputs;
    fn x64_vpextrq_a_raw(&mut self, arg0: &GprMem64, arg1: Xmm, arg2: u8) -> AssemblerOutputs;
    fn x64_insertps_a_raw(&mut self, arg0: Xmm, arg1: &XmmMem32, arg2: u8) -> AssemblerOutputs;
    fn x64_pinsrb_a_raw(&mut self, arg0: Xmm, arg1: &GprMem32, arg2: u8) -> AssemblerOutputs;
    fn x64_pinsrw_a_raw(&mut self, arg0: Xmm, arg1: &GprMem32, arg2: u8) -> AssemblerOutputs;
    fn x64_pinsrd_a_raw(&mut self, arg0: Xmm, arg1: &GprMem32, arg2: u8) -> AssemblerOutputs;
    fn x64_pinsrq_a_raw(&mut self, arg0: Xmm, arg1: &GprMem64, arg2: u8) -> AssemblerOutputs;
    fn x64_vinsertps_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem32, arg2: u8) -> AssemblerOutputs;
    fn x64_vpinsrb_b_raw(&mut self, arg0: Xmm, arg1: &GprMem32, arg2: u8) -> AssemblerOutputs;
    fn x64_vpinsrw_b_raw(&mut self, arg0: Xmm, arg1: &GprMem32, arg2: u8) -> AssemblerOutputs;
    fn x64_vpinsrd_b_raw(&mut self, arg0: Xmm, arg1: &GprMem32, arg2: u8) -> AssemblerOutputs;
    fn x64_vpinsrq_b_raw(&mut self, arg0: Xmm, arg1: &GprMem64, 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: &XmmMem64) -> AssemblerOutputs;
    fn x64_vmovddup_a_raw(&mut self, arg0: &XmmMem64) -> AssemblerOutputs;
    fn x64_pblendw_rmi_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128, arg2: u8) -> AssemblerOutputs;
    fn x64_pblendvb_rm_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128, arg2: Xmm) -> AssemblerOutputs;
    fn x64_blendvps_rm0_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128, arg2: Xmm) -> AssemblerOutputs;
    fn x64_blendvpd_rm0_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128, arg2: Xmm) -> AssemblerOutputs;
    fn x64_vpblendw_rvmi_raw(&mut self, arg0: Xmm, arg1: &XmmMem128, arg2: u8) -> AssemblerOutputs;
    fn x64_vpblendvb_rvmr_raw(&mut self, arg0: Xmm, arg1: &XmmMem128, arg2: Xmm) -> AssemblerOutputs;
    fn x64_vblendvps_rvmr_raw(&mut self, arg0: Xmm, arg1: &XmmMem128, arg2: Xmm) -> AssemblerOutputs;
    fn x64_vblendvpd_rvmr_raw(&mut self, arg0: Xmm, arg1: &XmmMem128, arg2: Xmm) -> AssemblerOutputs;
    fn x64_shufpd_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128, arg2: u8) -> AssemblerOutputs;
    fn x64_vshufpd_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem128, arg2: u8) -> AssemblerOutputs;
    fn x64_shufps_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128, arg2: u8) -> AssemblerOutputs;
    fn x64_vshufps_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem128, arg2: u8) -> AssemblerOutputs;
    fn x64_pshufb_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_pshufd_a_raw(&mut self, arg0: &XmmMemAligned128, arg1: u8) -> AssemblerOutputs;
    fn x64_pshuflw_a_raw(&mut self, arg0: &XmmMemAligned128, arg1: u8) -> AssemblerOutputs;
    fn x64_pshufhw_a_raw(&mut self, arg0: &XmmMemAligned128, arg1: u8) -> AssemblerOutputs;
    fn x64_vpshufb_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_vpshufd_a_raw(&mut self, arg0: &XmmMem128, arg1: u8) -> AssemblerOutputs;
    fn x64_vpshuflw_a_raw(&mut self, arg0: &XmmMem128, arg1: u8) -> AssemblerOutputs;
    fn x64_vpshufhw_a_raw(&mut self, arg0: &XmmMem128, 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: &XmmMem8) -> AssemblerOutputs;
    fn x64_vpbroadcastw_a_raw(&mut self, arg0: &XmmMem16) -> AssemblerOutputs;
    fn x64_vpbroadcastd_a_raw(&mut self, arg0: &XmmMem32) -> AssemblerOutputs;
    fn x64_vpbroadcastq_a_raw(&mut self, arg0: &XmmMem64) -> AssemblerOutputs;
    fn x64_vpermi2b_a_raw(&mut self, arg0: Xmm, arg1: Xmm, arg2: &XmmMem128) -> AssemblerOutputs;
    fn x64_maxss_a_raw(&mut self, arg0: Xmm, arg1: &XmmMem32) -> AssemblerOutputs;
    fn x64_maxsd_a_raw(&mut self, arg0: Xmm, arg1: &XmmMem64) -> AssemblerOutputs;
    fn x64_maxps_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_maxpd_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_vmaxss_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem32) -> AssemblerOutputs;
    fn x64_vmaxsd_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem64) -> AssemblerOutputs;
    fn x64_vmaxps_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_vmaxpd_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_pmaxsb_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_pmaxsw_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_pmaxsd_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_pmaxub_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_pmaxuw_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_pmaxud_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_vpmaxsb_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_vpmaxsw_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_vpmaxsd_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_vpmaxub_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_vpmaxuw_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_vpmaxud_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_minss_a_raw(&mut self, arg0: Xmm, arg1: &XmmMem32) -> AssemblerOutputs;
    fn x64_minsd_a_raw(&mut self, arg0: Xmm, arg1: &XmmMem64) -> AssemblerOutputs;
    fn x64_minps_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_minpd_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_vminss_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem32) -> AssemblerOutputs;
    fn x64_vminsd_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem64) -> AssemblerOutputs;
    fn x64_vminps_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_vminpd_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_pminsb_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_pminsw_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_pminsd_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_pminub_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_pminuw_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_pminud_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_vpminsb_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_vpminsw_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_vpminsd_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_vpminub_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_vpminuw_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_vpminud_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> 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: &GprMem64) -> AssemblerOutputs;
    fn x64_movb_mr_raw(&mut self, arg0: &GprMem8, arg1: Gpr) -> AssemblerOutputs;
    fn x64_movw_mr_raw(&mut self, arg0: &GprMem16, arg1: Gpr) -> AssemblerOutputs;
    fn x64_movl_mr_raw(&mut self, arg0: &GprMem32, arg1: Gpr) -> AssemblerOutputs;
    fn x64_movq_mr_raw(&mut self, arg0: &GprMem64, arg1: Gpr) -> AssemblerOutputs;
    fn x64_movb_rm_raw(&mut self, arg0: &GprMem8) -> AssemblerOutputs;
    fn x64_movw_rm_raw(&mut self, arg0: &GprMem16) -> AssemblerOutputs;
    fn x64_movl_rm_raw(&mut self, arg0: &GprMem32) -> AssemblerOutputs;
    fn x64_movq_rm_raw(&mut self, arg0: &GprMem64) -> 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: &GprMem8, arg1: u8) -> AssemblerOutputs;
    fn x64_movw_mi_raw(&mut self, arg0: &GprMem16, arg1: u16) -> AssemblerOutputs;
    fn x64_movl_mi_raw(&mut self, arg0: &GprMem32, arg1: u32) -> AssemblerOutputs;
    fn x64_movq_mi_sxl_raw(&mut self, arg0: &GprMem64, arg1: i32) -> AssemblerOutputs;
    fn x64_movsbw_rm_raw(&mut self, arg0: &GprMem8) -> AssemblerOutputs;
    fn x64_movsbl_rm_raw(&mut self, arg0: &GprMem8) -> AssemblerOutputs;
    fn x64_movsbq_rm_raw(&mut self, arg0: &GprMem8) -> AssemblerOutputs;
    fn x64_movsww_rm_raw(&mut self, arg0: &GprMem16) -> AssemblerOutputs;
    fn x64_movswl_rm_raw(&mut self, arg0: &GprMem16) -> AssemblerOutputs;
    fn x64_movswq_rm_raw(&mut self, arg0: &GprMem16) -> AssemblerOutputs;
    fn x64_movslq_rm_raw(&mut self, arg0: &GprMem32) -> AssemblerOutputs;
    fn x64_movzbw_rm_raw(&mut self, arg0: &GprMem8) -> AssemblerOutputs;
    fn x64_movzbl_rm_raw(&mut self, arg0: &GprMem8) -> AssemblerOutputs;
    fn x64_movzbq_rm_raw(&mut self, arg0: &GprMem8) -> AssemblerOutputs;
    fn x64_movzww_rm_raw(&mut self, arg0: &GprMem16) -> AssemblerOutputs;
    fn x64_movzwl_rm_raw(&mut self, arg0: &GprMem16) -> AssemblerOutputs;
    fn x64_movzwq_rm_raw(&mut self, arg0: &GprMem16) -> AssemblerOutputs;
    fn x64_movd_a_raw(&mut self, arg0: &GprMem32) -> AssemblerOutputs;
    fn x64_movq_a_raw(&mut self, arg0: &GprMem64) -> AssemblerOutputs;
    fn x64_movd_b_raw(&mut self, arg0: &GprMem32, arg1: Xmm) -> AssemblerOutputs;
    fn x64_movq_b_raw(&mut self, arg0: &GprMem64, arg1: Xmm) -> AssemblerOutputs;
    fn x64_vmovd_a_raw(&mut self, arg0: &GprMem32) -> AssemblerOutputs;
    fn x64_vmovq_a_raw(&mut self, arg0: &GprMem64) -> AssemblerOutputs;
    fn x64_vmovd_b_raw(&mut self, arg0: &GprMem32, arg1: Xmm) -> AssemblerOutputs;
    fn x64_vmovq_b_raw(&mut self, arg0: &GprMem64, 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: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_movapd_b_raw(&mut self, arg0: &XmmMemAligned128, arg1: Xmm) -> AssemblerOutputs;
    fn x64_movaps_a_raw(&mut self, arg0: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_movaps_b_raw(&mut self, arg0: &XmmMemAligned128, arg1: Xmm) -> AssemblerOutputs;
    fn x64_movdqa_a_raw(&mut self, arg0: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_movdqa_b_raw(&mut self, arg0: &XmmMemAligned128, arg1: Xmm) -> AssemblerOutputs;
    fn x64_vmovapd_a_raw(&mut self, arg0: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_vmovapd_b_raw(&mut self, arg0: &XmmMemAligned128, arg1: Xmm) -> AssemblerOutputs;
    fn x64_vmovaps_a_raw(&mut self, arg0: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_vmovaps_b_raw(&mut self, arg0: &XmmMemAligned128, arg1: Xmm) -> AssemblerOutputs;
    fn x64_vmovdqa_a_raw(&mut self, arg0: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_vmovdqa_b_raw(&mut self, arg0: &XmmMemAligned128, arg1: Xmm) -> AssemblerOutputs;
    fn x64_movupd_a_raw(&mut self, arg0: &XmmMem128) -> AssemblerOutputs;
    fn x64_movupd_b_raw(&mut self, arg0: &XmmMem128, arg1: Xmm) -> AssemblerOutputs;
    fn x64_movups_a_raw(&mut self, arg0: &XmmMem128) -> AssemblerOutputs;
    fn x64_movups_b_raw(&mut self, arg0: &XmmMem128, arg1: Xmm) -> AssemblerOutputs;
    fn x64_movdqu_a_raw(&mut self, arg0: &XmmMem128) -> AssemblerOutputs;
    fn x64_movdqu_b_raw(&mut self, arg0: &XmmMem128, arg1: Xmm) -> AssemblerOutputs;
    fn x64_vmovupd_a_raw(&mut self, arg0: &XmmMem128) -> AssemblerOutputs;
    fn x64_vmovupd_b_raw(&mut self, arg0: &XmmMem128, arg1: Xmm) -> AssemblerOutputs;
    fn x64_vmovups_a_raw(&mut self, arg0: &XmmMem128) -> AssemblerOutputs;
    fn x64_vmovups_b_raw(&mut self, arg0: &XmmMem128, arg1: Xmm) -> AssemblerOutputs;
    fn x64_vmovdqu_a_raw(&mut self, arg0: &XmmMem128) -> AssemblerOutputs;
    fn x64_vmovdqu_b_raw(&mut self, arg0: &XmmMem128, arg1: Xmm) -> AssemblerOutputs;
    fn x64_pmovsxbw_a_raw(&mut self, arg0: &XmmMem64) -> AssemblerOutputs;
    fn x64_pmovsxbd_a_raw(&mut self, arg0: &XmmMem32) -> AssemblerOutputs;
    fn x64_pmovsxbq_a_raw(&mut self, arg0: &XmmMem16) -> AssemblerOutputs;
    fn x64_pmovsxwd_a_raw(&mut self, arg0: &XmmMem64) -> AssemblerOutputs;
    fn x64_pmovsxwq_a_raw(&mut self, arg0: &XmmMem32) -> AssemblerOutputs;
    fn x64_pmovsxdq_a_raw(&mut self, arg0: &XmmMem64) -> AssemblerOutputs;
    fn x64_vpmovsxbw_a_raw(&mut self, arg0: &XmmMem64) -> AssemblerOutputs;
    fn x64_vpmovsxbd_a_raw(&mut self, arg0: &XmmMem32) -> AssemblerOutputs;
    fn x64_vpmovsxbq_a_raw(&mut self, arg0: &XmmMem16) -> AssemblerOutputs;
    fn x64_vpmovsxwd_a_raw(&mut self, arg0: &XmmMem64) -> AssemblerOutputs;
    fn x64_vpmovsxwq_a_raw(&mut self, arg0: &XmmMem32) -> AssemblerOutputs;
    fn x64_vpmovsxdq_a_raw(&mut self, arg0: &XmmMem64) -> AssemblerOutputs;
    fn x64_pmovzxbw_a_raw(&mut self, arg0: &XmmMem64) -> AssemblerOutputs;
    fn x64_pmovzxbd_a_raw(&mut self, arg0: &XmmMem32) -> AssemblerOutputs;
    fn x64_pmovzxbq_a_raw(&mut self, arg0: &XmmMem16) -> AssemblerOutputs;
    fn x64_pmovzxwd_a_raw(&mut self, arg0: &XmmMem64) -> AssemblerOutputs;
    fn x64_pmovzxwq_a_raw(&mut self, arg0: &XmmMem32) -> AssemblerOutputs;
    fn x64_pmovzxdq_a_raw(&mut self, arg0: &XmmMem64) -> AssemblerOutputs;
    fn x64_vpmovzxbw_a_raw(&mut self, arg0: &XmmMem64) -> AssemblerOutputs;
    fn x64_vpmovzxbd_a_raw(&mut self, arg0: &XmmMem32) -> AssemblerOutputs;
    fn x64_vpmovzxbq_a_raw(&mut self, arg0: &XmmMem16) -> AssemblerOutputs;
    fn x64_vpmovzxwd_a_raw(&mut self, arg0: &XmmMem64) -> AssemblerOutputs;
    fn x64_vpmovzxwq_a_raw(&mut self, arg0: &XmmMem32) -> AssemblerOutputs;
    fn x64_vpmovzxdq_a_raw(&mut self, arg0: &XmmMem64) -> AssemblerOutputs;
    fn x64_mulb_m_raw(&mut self, arg0: Gpr, arg1: &GprMem8) -> AssemblerOutputs;
    fn x64_mulw_m_raw(&mut self, arg0: Gpr, arg1: &GprMem16) -> AssemblerOutputs;
    fn x64_mull_m_raw(&mut self, arg0: Gpr, arg1: &GprMem32) -> AssemblerOutputs;
    fn x64_mulq_m_raw(&mut self, arg0: Gpr, arg1: &GprMem64) -> AssemblerOutputs;
    fn x64_imulb_m_raw(&mut self, arg0: Gpr, arg1: &GprMem8) -> AssemblerOutputs;
    fn x64_imulw_m_raw(&mut self, arg0: Gpr, arg1: &GprMem16) -> AssemblerOutputs;
    fn x64_imull_m_raw(&mut self, arg0: Gpr, arg1: &GprMem32) -> AssemblerOutputs;
    fn x64_imulq_m_raw(&mut self, arg0: Gpr, arg1: &GprMem64) -> AssemblerOutputs;
    fn x64_imulw_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem16) -> AssemblerOutputs;
    fn x64_imull_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem32) -> AssemblerOutputs;
    fn x64_imulq_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem64) -> AssemblerOutputs;
    fn x64_imulw_rmi_sxb_raw(&mut self, arg0: &GprMem16, arg1: i8) -> AssemblerOutputs;
    fn x64_imull_rmi_sxb_raw(&mut self, arg0: &GprMem32, arg1: i8) -> AssemblerOutputs;
    fn x64_imulq_rmi_sxb_raw(&mut self, arg0: &GprMem64, arg1: i8) -> AssemblerOutputs;
    fn x64_imulw_rmi_raw(&mut self, arg0: &GprMem16, arg1: u16) -> AssemblerOutputs;
    fn x64_imull_rmi_raw(&mut self, arg0: &GprMem32, arg1: u32) -> AssemblerOutputs;
    fn x64_imulq_rmi_sxl_raw(&mut self, arg0: &GprMem64, arg1: i32) -> AssemblerOutputs;
    fn x64_mulxl_rvm_raw(&mut self, arg0: &GprMem32, arg1: Gpr) -> AssemblerOutputs;
    fn x64_mulxq_rvm_raw(&mut self, arg0: &GprMem64, arg1: Gpr) -> AssemblerOutputs;
    fn x64_mulss_a_raw(&mut self, arg0: Xmm, arg1: &XmmMem32) -> AssemblerOutputs;
    fn x64_mulsd_a_raw(&mut self, arg0: Xmm, arg1: &XmmMem64) -> AssemblerOutputs;
    fn x64_mulps_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_mulpd_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_pmuldq_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_pmulhrsw_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_pmulhuw_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_pmulhw_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_pmulld_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_pmullw_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_pmuludq_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_vmulss_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem32) -> AssemblerOutputs;
    fn x64_vmulsd_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem64) -> AssemblerOutputs;
    fn x64_vmulps_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_vmulpd_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_vpmuldq_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_vpmulhrsw_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_vpmulhuw_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_vpmulhw_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_vpmulld_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_vpmullw_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_vpmuludq_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_vpmulld_c_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_vpmullq_c_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_negb_m_raw(&mut self, arg0: &GprMem8) -> AssemblerOutputs;
    fn x64_negw_m_raw(&mut self, arg0: &GprMem16) -> AssemblerOutputs;
    fn x64_negl_m_raw(&mut self, arg0: &GprMem32) -> AssemblerOutputs;
    fn x64_negq_m_raw(&mut self, arg0: &GprMem64) -> AssemblerOutputs;
    fn x64_notb_m_raw(&mut self, arg0: &GprMem8) -> AssemblerOutputs;
    fn x64_notw_m_raw(&mut self, arg0: &GprMem16) -> AssemblerOutputs;
    fn x64_notl_m_raw(&mut self, arg0: &GprMem32) -> AssemblerOutputs;
    fn x64_notq_m_raw(&mut self, arg0: &GprMem64) -> AssemblerOutputs;
    fn x64_nop_zo_raw(&mut self, ) -> AssemblerOutputs;
    fn x64_nopl_m_raw(&mut self, arg0: &GprMem32) -> 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: &GprMem8, arg1: u8) -> AssemblerOutputs;
    fn x64_orw_mi_raw(&mut self, arg0: &GprMem16, arg1: u16) -> AssemblerOutputs;
    fn x64_orl_mi_raw(&mut self, arg0: &GprMem32, arg1: u32) -> AssemblerOutputs;
    fn x64_orq_mi_sxl_raw(&mut self, arg0: &GprMem64, arg1: i32) -> AssemblerOutputs;
    fn x64_orl_mi_sxb_raw(&mut self, arg0: &GprMem32, arg1: i8) -> AssemblerOutputs;
    fn x64_orq_mi_sxb_raw(&mut self, arg0: &GprMem64, arg1: i8) -> AssemblerOutputs;
    fn x64_orb_mr_raw(&mut self, arg0: &GprMem8, arg1: Gpr) -> AssemblerOutputs;
    fn x64_orw_mr_raw(&mut self, arg0: &GprMem16, arg1: Gpr) -> AssemblerOutputs;
    fn x64_orl_mr_raw(&mut self, arg0: &GprMem32, arg1: Gpr) -> AssemblerOutputs;
    fn x64_orq_mr_raw(&mut self, arg0: &GprMem64, arg1: Gpr) -> AssemblerOutputs;
    fn x64_orb_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem8) -> AssemblerOutputs;
    fn x64_orw_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem16) -> AssemblerOutputs;
    fn x64_orl_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem32) -> AssemblerOutputs;
    fn x64_orq_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem64) -> 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: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_orpd_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_por_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_vorps_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_vorpd_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_vpor_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_packsswb_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_packssdw_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_vpacksswb_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_vpackssdw_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_packuswb_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_packusdw_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_vpackuswb_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_vpackusdw_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_pmaddwd_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_vpmaddwd_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_pmaddubsw_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_vpmaddubsw_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_rcpps_rm_raw(&mut self, arg0: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_rcpss_rm_raw(&mut self, arg0: &XmmMem32) -> AssemblerOutputs;
    fn x64_rsqrtps_rm_raw(&mut self, arg0: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_rsqrtss_rm_raw(&mut self, arg0: &XmmMem32) -> AssemblerOutputs;
    fn x64_vrcpps_rm_raw(&mut self, arg0: &XmmMem128) -> AssemblerOutputs;
    fn x64_vrcpss_rvm_raw(&mut self, arg0: Xmm, arg1: &XmmMem32) -> AssemblerOutputs;
    fn x64_vrsqrtps_rm_raw(&mut self, arg0: &XmmMem128) -> AssemblerOutputs;
    fn x64_vrsqrtss_rvm_raw(&mut self, arg0: Xmm, arg1: &XmmMem32) -> AssemblerOutputs;
    fn x64_roundpd_rmi_raw(&mut self, arg0: &XmmMemAligned128, arg1: u8) -> AssemblerOutputs;
    fn x64_roundps_rmi_raw(&mut self, arg0: &XmmMemAligned128, arg1: u8) -> AssemblerOutputs;
    fn x64_roundsd_rmi_raw(&mut self, arg0: &XmmMem64, arg1: u8) -> AssemblerOutputs;
    fn x64_roundss_rmi_raw(&mut self, arg0: &XmmMem32, arg1: u8) -> AssemblerOutputs;
    fn x64_vroundpd_rmi_raw(&mut self, arg0: &XmmMem128, arg1: u8) -> AssemblerOutputs;
    fn x64_vroundps_rmi_raw(&mut self, arg0: &XmmMem128, arg1: u8) -> AssemblerOutputs;
    fn x64_vroundsd_rvmi_raw(&mut self, arg0: Xmm, arg1: &XmmMem64, arg2: u8) -> AssemblerOutputs;
    fn x64_vroundss_rvmi_raw(&mut self, arg0: Xmm, arg1: &XmmMem32, arg2: u8) -> AssemblerOutputs;
    fn x64_seta_m_raw(&mut self, arg0: &GprMem8) -> AssemblerOutputs;
    fn x64_setae_m_raw(&mut self, arg0: &GprMem8) -> AssemblerOutputs;
    fn x64_setb_m_raw(&mut self, arg0: &GprMem8) -> AssemblerOutputs;
    fn x64_setbe_m_raw(&mut self, arg0: &GprMem8) -> AssemblerOutputs;
    fn x64_sete_m_raw(&mut self, arg0: &GprMem8) -> AssemblerOutputs;
    fn x64_setg_m_raw(&mut self, arg0: &GprMem8) -> AssemblerOutputs;
    fn x64_setge_m_raw(&mut self, arg0: &GprMem8) -> AssemblerOutputs;
    fn x64_setl_m_raw(&mut self, arg0: &GprMem8) -> AssemblerOutputs;
    fn x64_setle_m_raw(&mut self, arg0: &GprMem8) -> AssemblerOutputs;
    fn x64_setne_m_raw(&mut self, arg0: &GprMem8) -> AssemblerOutputs;
    fn x64_setno_m_raw(&mut self, arg0: &GprMem8) -> AssemblerOutputs;
    fn x64_setnp_m_raw(&mut self, arg0: &GprMem8) -> AssemblerOutputs;
    fn x64_setns_m_raw(&mut self, arg0: &GprMem8) -> AssemblerOutputs;
    fn x64_seto_m_raw(&mut self, arg0: &GprMem8) -> AssemblerOutputs;
    fn x64_setp_m_raw(&mut self, arg0: &GprMem8) -> AssemblerOutputs;
    fn x64_sets_m_raw(&mut self, arg0: &GprMem8) -> AssemblerOutputs;
    fn x64_sarb_mc_raw(&mut self, arg0: &GprMem8, arg1: Gpr) -> AssemblerOutputs;
    fn x64_sarb_mi_raw(&mut self, arg0: &GprMem8, arg1: u8) -> AssemblerOutputs;
    fn x64_sarb_m1_raw(&mut self, arg0: &GprMem8) -> AssemblerOutputs;
    fn x64_sarw_mc_raw(&mut self, arg0: &GprMem16, arg1: Gpr) -> AssemblerOutputs;
    fn x64_sarw_mi_raw(&mut self, arg0: &GprMem16, arg1: u8) -> AssemblerOutputs;
    fn x64_sarw_m1_raw(&mut self, arg0: &GprMem16) -> AssemblerOutputs;
    fn x64_sarl_mc_raw(&mut self, arg0: &GprMem32, arg1: Gpr) -> AssemblerOutputs;
    fn x64_sarl_mi_raw(&mut self, arg0: &GprMem32, arg1: u8) -> AssemblerOutputs;
    fn x64_sarl_m1_raw(&mut self, arg0: &GprMem32) -> AssemblerOutputs;
    fn x64_sarq_mc_raw(&mut self, arg0: &GprMem64, arg1: Gpr) -> AssemblerOutputs;
    fn x64_sarq_mi_raw(&mut self, arg0: &GprMem64, arg1: u8) -> AssemblerOutputs;
    fn x64_sarq_m1_raw(&mut self, arg0: &GprMem64) -> AssemblerOutputs;
    fn x64_shlb_mc_raw(&mut self, arg0: &GprMem8, arg1: Gpr) -> AssemblerOutputs;
    fn x64_shlb_mi_raw(&mut self, arg0: &GprMem8, arg1: u8) -> AssemblerOutputs;
    fn x64_shlb_m1_raw(&mut self, arg0: &GprMem8) -> AssemblerOutputs;
    fn x64_shlw_mc_raw(&mut self, arg0: &GprMem16, arg1: Gpr) -> AssemblerOutputs;
    fn x64_shlw_mi_raw(&mut self, arg0: &GprMem16, arg1: u8) -> AssemblerOutputs;
    fn x64_shlw_m1_raw(&mut self, arg0: &GprMem16) -> AssemblerOutputs;
    fn x64_shll_mc_raw(&mut self, arg0: &GprMem32, arg1: Gpr) -> AssemblerOutputs;
    fn x64_shll_mi_raw(&mut self, arg0: &GprMem32, arg1: u8) -> AssemblerOutputs;
    fn x64_shll_m1_raw(&mut self, arg0: &GprMem32) -> AssemblerOutputs;
    fn x64_shlq_mc_raw(&mut self, arg0: &GprMem64, arg1: Gpr) -> AssemblerOutputs;
    fn x64_shlq_mi_raw(&mut self, arg0: &GprMem64, arg1: u8) -> AssemblerOutputs;
    fn x64_shlq_m1_raw(&mut self, arg0: &GprMem64) -> AssemblerOutputs;
    fn x64_shrb_mc_raw(&mut self, arg0: &GprMem8, arg1: Gpr) -> AssemblerOutputs;
    fn x64_shrb_mi_raw(&mut self, arg0: &GprMem8, arg1: u8) -> AssemblerOutputs;
    fn x64_shrb_m1_raw(&mut self, arg0: &GprMem8) -> AssemblerOutputs;
    fn x64_shrw_mc_raw(&mut self, arg0: &GprMem16, arg1: Gpr) -> AssemblerOutputs;
    fn x64_shrw_mi_raw(&mut self, arg0: &GprMem16, arg1: u8) -> AssemblerOutputs;
    fn x64_shrw_m1_raw(&mut self, arg0: &GprMem16) -> AssemblerOutputs;
    fn x64_shrl_mc_raw(&mut self, arg0: &GprMem32, arg1: Gpr) -> AssemblerOutputs;
    fn x64_shrl_mi_raw(&mut self, arg0: &GprMem32, arg1: u8) -> AssemblerOutputs;
    fn x64_shrl_m1_raw(&mut self, arg0: &GprMem32) -> AssemblerOutputs;
    fn x64_shrq_mc_raw(&mut self, arg0: &GprMem64, arg1: Gpr) -> AssemblerOutputs;
    fn x64_shrq_mi_raw(&mut self, arg0: &GprMem64, arg1: u8) -> AssemblerOutputs;
    fn x64_shrq_m1_raw(&mut self, arg0: &GprMem64) -> AssemblerOutputs;
    fn x64_rolb_mc_raw(&mut self, arg0: &GprMem8, arg1: Gpr) -> AssemblerOutputs;
    fn x64_rolb_mi_raw(&mut self, arg0: &GprMem8, arg1: u8) -> AssemblerOutputs;
    fn x64_rolb_m1_raw(&mut self, arg0: &GprMem8) -> AssemblerOutputs;
    fn x64_rolw_mc_raw(&mut self, arg0: &GprMem16, arg1: Gpr) -> AssemblerOutputs;
    fn x64_rolw_mi_raw(&mut self, arg0: &GprMem16, arg1: u8) -> AssemblerOutputs;
    fn x64_rolw_m1_raw(&mut self, arg0: &GprMem16) -> AssemblerOutputs;
    fn x64_roll_mc_raw(&mut self, arg0: &GprMem32, arg1: Gpr) -> AssemblerOutputs;
    fn x64_roll_mi_raw(&mut self, arg0: &GprMem32, arg1: u8) -> AssemblerOutputs;
    fn x64_roll_m1_raw(&mut self, arg0: &GprMem32) -> AssemblerOutputs;
    fn x64_rolq_mc_raw(&mut self, arg0: &GprMem64, arg1: Gpr) -> AssemblerOutputs;
    fn x64_rolq_mi_raw(&mut self, arg0: &GprMem64, arg1: u8) -> AssemblerOutputs;
    fn x64_rolq_m1_raw(&mut self, arg0: &GprMem64) -> AssemblerOutputs;
    fn x64_rorb_mc_raw(&mut self, arg0: &GprMem8, arg1: Gpr) -> AssemblerOutputs;
    fn x64_rorb_mi_raw(&mut self, arg0: &GprMem8, arg1: u8) -> AssemblerOutputs;
    fn x64_rorb_m1_raw(&mut self, arg0: &GprMem8) -> AssemblerOutputs;
    fn x64_rorw_mc_raw(&mut self, arg0: &GprMem16, arg1: Gpr) -> AssemblerOutputs;
    fn x64_rorw_mi_raw(&mut self, arg0: &GprMem16, arg1: u8) -> AssemblerOutputs;
    fn x64_rorw_m1_raw(&mut self, arg0: &GprMem16) -> AssemblerOutputs;
    fn x64_rorl_mc_raw(&mut self, arg0: &GprMem32, arg1: Gpr) -> AssemblerOutputs;
    fn x64_rorl_mi_raw(&mut self, arg0: &GprMem32, arg1: u8) -> AssemblerOutputs;
    fn x64_rorl_m1_raw(&mut self, arg0: &GprMem32) -> AssemblerOutputs;
    fn x64_rorq_mc_raw(&mut self, arg0: &GprMem64, arg1: Gpr) -> AssemblerOutputs;
    fn x64_rorq_mi_raw(&mut self, arg0: &GprMem64, arg1: u8) -> AssemblerOutputs;
    fn x64_rorq_m1_raw(&mut self, arg0: &GprMem64) -> AssemblerOutputs;
    fn x64_shldw_mri_raw(&mut self, arg0: &GprMem16, arg1: Gpr, arg2: u8) -> AssemblerOutputs;
    fn x64_shldw_mrc_raw(&mut self, arg0: &GprMem16, arg1: Gpr, arg2: Gpr) -> AssemblerOutputs;
    fn x64_shldl_mri_raw(&mut self, arg0: &GprMem32, arg1: Gpr, arg2: u8) -> AssemblerOutputs;
    fn x64_shldq_mri_raw(&mut self, arg0: &GprMem64, arg1: Gpr, arg2: u8) -> AssemblerOutputs;
    fn x64_shldl_mrc_raw(&mut self, arg0: &GprMem32, arg1: Gpr, arg2: Gpr) -> AssemblerOutputs;
    fn x64_shldq_mrc_raw(&mut self, arg0: &GprMem64, arg1: Gpr, arg2: Gpr) -> AssemblerOutputs;
    fn x64_sarxl_rmv_raw(&mut self, arg0: &GprMem32, arg1: Gpr) -> AssemblerOutputs;
    fn x64_shlxl_rmv_raw(&mut self, arg0: &GprMem32, arg1: Gpr) -> AssemblerOutputs;
    fn x64_shrxl_rmv_raw(&mut self, arg0: &GprMem32, arg1: Gpr) -> AssemblerOutputs;
    fn x64_sarxq_rmv_raw(&mut self, arg0: &GprMem64, arg1: Gpr) -> AssemblerOutputs;
    fn x64_shlxq_rmv_raw(&mut self, arg0: &GprMem64, arg1: Gpr) -> AssemblerOutputs;
    fn x64_shrxq_rmv_raw(&mut self, arg0: &GprMem64, arg1: Gpr) -> AssemblerOutputs;
    fn x64_rorxl_rmi_raw(&mut self, arg0: &GprMem32, arg1: u8) -> AssemblerOutputs;
    fn x64_rorxq_rmi_raw(&mut self, arg0: &GprMem64, arg1: u8) -> AssemblerOutputs;
    fn x64_psllw_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_psllw_b_raw(&mut self, arg0: Xmm, arg1: u8) -> AssemblerOutputs;
    fn x64_pslld_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_pslld_b_raw(&mut self, arg0: Xmm, arg1: u8) -> AssemblerOutputs;
    fn x64_psllq_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_psllq_b_raw(&mut self, arg0: Xmm, arg1: u8) -> AssemblerOutputs;
    fn x64_vpsllw_c_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_vpsllw_d_raw(&mut self, arg0: Xmm, arg1: u8) -> AssemblerOutputs;
    fn x64_vpslld_c_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_vpslld_d_raw(&mut self, arg0: Xmm, arg1: u8) -> AssemblerOutputs;
    fn x64_vpsllq_c_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_vpsllq_d_raw(&mut self, arg0: Xmm, arg1: u8) -> AssemblerOutputs;
    fn x64_vpslld_g_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_vpslld_f_raw(&mut self, arg0: &XmmMem128, arg1: u8) -> AssemblerOutputs;
    fn x64_vpsllq_g_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_vpsllq_f_raw(&mut self, arg0: &XmmMem128, arg1: u8) -> AssemblerOutputs;
    fn x64_psraw_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_psraw_b_raw(&mut self, arg0: Xmm, arg1: u8) -> AssemblerOutputs;
    fn x64_psrad_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_psrad_b_raw(&mut self, arg0: Xmm, arg1: u8) -> AssemblerOutputs;
    fn x64_psrlw_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_psrlw_b_raw(&mut self, arg0: Xmm, arg1: u8) -> AssemblerOutputs;
    fn x64_psrld_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_psrld_b_raw(&mut self, arg0: Xmm, arg1: u8) -> AssemblerOutputs;
    fn x64_psrlq_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_psrlq_b_raw(&mut self, arg0: Xmm, arg1: u8) -> AssemblerOutputs;
    fn x64_vpsraw_c_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_vpsraw_d_raw(&mut self, arg0: Xmm, arg1: u8) -> AssemblerOutputs;
    fn x64_vpsrad_c_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_vpsrad_d_raw(&mut self, arg0: Xmm, arg1: u8) -> AssemblerOutputs;
    fn x64_vpsrlw_c_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_vpsrlw_d_raw(&mut self, arg0: Xmm, arg1: u8) -> AssemblerOutputs;
    fn x64_vpsrld_c_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_vpsrld_d_raw(&mut self, arg0: Xmm, arg1: u8) -> AssemblerOutputs;
    fn x64_vpsrlq_c_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_vpsrlq_d_raw(&mut self, arg0: Xmm, arg1: u8) -> AssemblerOutputs;
    fn x64_vpsrad_g_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_vpsrad_f_raw(&mut self, arg0: &XmmMem128, arg1: u8) -> AssemblerOutputs;
    fn x64_vpsraq_g_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_vpsraq_f_raw(&mut self, arg0: &XmmMem128, arg1: u8) -> AssemblerOutputs;
    fn x64_vpsrld_g_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_vpsrld_f_raw(&mut self, arg0: &XmmMem128, arg1: u8) -> AssemblerOutputs;
    fn x64_vpsrlq_g_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_vpsrlq_f_raw(&mut self, arg0: &XmmMem128, arg1: u8) -> AssemblerOutputs;
    fn x64_sqrtss_a_raw(&mut self, arg0: Xmm, arg1: &XmmMem32) -> AssemblerOutputs;
    fn x64_sqrtsd_a_raw(&mut self, arg0: Xmm, arg1: &XmmMem64) -> AssemblerOutputs;
    fn x64_sqrtps_a_raw(&mut self, arg0: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_sqrtpd_a_raw(&mut self, arg0: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_vsqrtss_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem32) -> AssemblerOutputs;
    fn x64_vsqrtsd_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem64) -> AssemblerOutputs;
    fn x64_vsqrtps_b_raw(&mut self, arg0: &XmmMem128) -> AssemblerOutputs;
    fn x64_vsqrtpd_b_raw(&mut self, arg0: &XmmMem128) -> AssemblerOutputs;
    fn x64_popw_m_raw(&mut self, arg0: &GprMem16) -> AssemblerOutputs;
    fn x64_popq_m_raw(&mut self, arg0: &GprMem64) -> 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: &GprMem8, arg1: u8) -> AssemblerOutputs;
    fn x64_subw_mi_raw(&mut self, arg0: &GprMem16, arg1: u16) -> AssemblerOutputs;
    fn x64_subl_mi_raw(&mut self, arg0: &GprMem32, arg1: u32) -> AssemblerOutputs;
    fn x64_subq_mi_sxl_raw(&mut self, arg0: &GprMem64, arg1: i32) -> AssemblerOutputs;
    fn x64_subl_mi_sxb_raw(&mut self, arg0: &GprMem32, arg1: i8) -> AssemblerOutputs;
    fn x64_subq_mi_sxb_raw(&mut self, arg0: &GprMem64, arg1: i8) -> AssemblerOutputs;
    fn x64_subb_mr_raw(&mut self, arg0: &GprMem8, arg1: Gpr) -> AssemblerOutputs;
    fn x64_subw_mr_raw(&mut self, arg0: &GprMem16, arg1: Gpr) -> AssemblerOutputs;
    fn x64_subl_mr_raw(&mut self, arg0: &GprMem32, arg1: Gpr) -> AssemblerOutputs;
    fn x64_subq_mr_raw(&mut self, arg0: &GprMem64, arg1: Gpr) -> AssemblerOutputs;
    fn x64_subb_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem8) -> AssemblerOutputs;
    fn x64_subw_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem16) -> AssemblerOutputs;
    fn x64_subl_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem32) -> AssemblerOutputs;
    fn x64_subq_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem64) -> 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: &GprMem8, arg1: u8) -> AssemblerOutputs;
    fn x64_sbbw_mi_raw(&mut self, arg0: &GprMem16, arg1: u16) -> AssemblerOutputs;
    fn x64_sbbl_mi_raw(&mut self, arg0: &GprMem32, arg1: u32) -> AssemblerOutputs;
    fn x64_sbbq_mi_sxl_raw(&mut self, arg0: &GprMem64, arg1: i32) -> AssemblerOutputs;
    fn x64_sbbl_mi_sxb_raw(&mut self, arg0: &GprMem32, arg1: i8) -> AssemblerOutputs;
    fn x64_sbbq_mi_sxb_raw(&mut self, arg0: &GprMem64, arg1: i8) -> AssemblerOutputs;
    fn x64_sbbb_mr_raw(&mut self, arg0: &GprMem8, arg1: Gpr) -> AssemblerOutputs;
    fn x64_sbbw_mr_raw(&mut self, arg0: &GprMem16, arg1: Gpr) -> AssemblerOutputs;
    fn x64_sbbl_mr_raw(&mut self, arg0: &GprMem32, arg1: Gpr) -> AssemblerOutputs;
    fn x64_sbbq_mr_raw(&mut self, arg0: &GprMem64, arg1: Gpr) -> AssemblerOutputs;
    fn x64_sbbb_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem8) -> AssemblerOutputs;
    fn x64_sbbw_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem16) -> AssemblerOutputs;
    fn x64_sbbl_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem32) -> AssemblerOutputs;
    fn x64_sbbq_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem64) -> 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: &XmmMem32) -> AssemblerOutputs;
    fn x64_subsd_a_raw(&mut self, arg0: Xmm, arg1: &XmmMem64) -> AssemblerOutputs;
    fn x64_subps_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_subpd_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_psubb_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_psubw_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_psubd_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_psubq_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_psubsb_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_psubsw_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_psubusb_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_psubusw_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_vsubss_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem32) -> AssemblerOutputs;
    fn x64_vsubsd_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem64) -> AssemblerOutputs;
    fn x64_vsubps_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_vsubpd_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_vpsubb_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_vpsubw_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_vpsubd_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_vpsubq_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_vpsubsb_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_vpsubsw_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_vpsubusb_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_vpsubusw_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_unpcklps_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_unpcklpd_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_unpckhps_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_vunpcklps_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_vunpcklpd_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_vunpckhps_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_punpckhbw_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_punpckhwd_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_punpckhdq_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_punpckhqdq_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_punpcklwd_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_punpcklbw_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_punpckldq_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_punpcklqdq_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_vpunpckhbw_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_vpunpckhwd_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_vpunpckhdq_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_vpunpckhqdq_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_vpunpcklwd_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_vpunpcklbw_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_vpunpckldq_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_vpunpcklqdq_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> 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: &GprMem8, arg1: u8) -> AssemblerOutputs;
    fn x64_xorw_mi_raw(&mut self, arg0: &GprMem16, arg1: u16) -> AssemblerOutputs;
    fn x64_xorl_mi_raw(&mut self, arg0: &GprMem32, arg1: u32) -> AssemblerOutputs;
    fn x64_xorq_mi_sxl_raw(&mut self, arg0: &GprMem64, arg1: i32) -> AssemblerOutputs;
    fn x64_xorl_mi_sxb_raw(&mut self, arg0: &GprMem32, arg1: i8) -> AssemblerOutputs;
    fn x64_xorq_mi_sxb_raw(&mut self, arg0: &GprMem64, arg1: i8) -> AssemblerOutputs;
    fn x64_xorb_mr_raw(&mut self, arg0: &GprMem8, arg1: Gpr) -> AssemblerOutputs;
    fn x64_xorw_mr_raw(&mut self, arg0: &GprMem16, arg1: Gpr) -> AssemblerOutputs;
    fn x64_xorl_mr_raw(&mut self, arg0: &GprMem32, arg1: Gpr) -> AssemblerOutputs;
    fn x64_xorq_mr_raw(&mut self, arg0: &GprMem64, arg1: Gpr) -> AssemblerOutputs;
    fn x64_xorb_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem8) -> AssemblerOutputs;
    fn x64_xorw_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem16) -> AssemblerOutputs;
    fn x64_xorl_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem32) -> AssemblerOutputs;
    fn x64_xorq_rm_raw(&mut self, arg0: Gpr, arg1: &GprMem64) -> 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: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_xorpd_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_pxor_a_raw(&mut self, arg0: Xmm, arg1: &XmmMemAligned128) -> AssemblerOutputs;
    fn x64_vxorps_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_vxorpd_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> AssemblerOutputs;
    fn x64_vpxor_b_raw(&mut self, arg0: Xmm, arg1: &XmmMem128) -> 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 429.
#[derive(Clone, Debug)]
pub enum SideEffectNoResult {
    Inst {
        inst: MInst,
    },
    Inst2 {
        inst1: MInst,
        inst2: MInst,
    },
    Inst3 {
        inst1: MInst,
        inst2: MInst,
        inst3: MInst,
    },
}

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

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

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

/// Internal type MInst: defined at src/isa/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 {
        args: BoxAtomic128RmwSeqArgs,
    },
    Atomic128XchgSeq {
        args: BoxAtomic128XchgSeqArgs,
    },
    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: MemFlagsData,
    },
    ImmRegRegShift {
        simm32: i32,
        base: Gpr,
        index: Gpr,
        shift: u8,
        flags: MemFlagsData,
    },
    RipRelative {
        target: MachLabel,
    },
}

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

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

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

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

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

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

/// Internal type CondResult: defined at src/isa/x64/inst.isle line 3782.
#[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 4125.
#[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 4145.
#[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 355.
    return v5;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// Generated as internal constructor for term 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: MemFlagsData,
    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.1 {
            &InstructionData::Binary {
                opcode: ref v10,
                args: ref v11,
            } => {
                if let &Opcode::Iadd = v10 {
                    let v12 = C::unpack_value_array_2(ctx, v11);
                    let v15 = &constructor_to_amode_add(ctx, arg0, v12.0, v12.1, arg2);
                    let v16 = &C::amode_to_synthetic_amode(ctx, v15);
                    // Rule at src/isa/x64/inst.isle line 511.
                    return v16.clone();
                }
            }
            &InstructionData::StackLoad {
                opcode: ref v17,
                stack_slot: v18,
                offset: v19,
            } => {
                if let &Opcode::StackAddr = v17 {
                    let v20 = &constructor_stackslot_amode(ctx, v18, v19, arg2);
                    // Rule at src/isa/x64/inst.isle line 514.
                    return v20.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: MemFlagsData,
    arg1: Value,
    arg2: Value,
    arg3: Offset32,
) -> Amode {
    let v48 = C::def_inst(ctx, arg2);
    if let Some(v49) = v48 {
        let v50 = C::inst_data_value(ctx, v49);
        if let &InstructionData::Binary {
            opcode: ref v53,
            args: ref v54,
        } = &v50.1 {
            if let &Opcode::Iadd = v53 {
                let v55 = C::unpack_value_array_2(ctx, v54);
                let v66 = C::i64_from_iconst(ctx, v55.0);
                if let Some(v67) = v66 {
                    let v68 = C::i64_from_i32(ctx, v67);
                    if let Some(v69) = v68 {
                        let v9 = C::offset32_to_i32(ctx, arg3);
                        let v70 = C::i32_checked_add(ctx, v9, v69);
                        if let Some(v71) = v70 {
                            let v72 = C::i32_to_offset32(ctx, v71);
                            let v73 = &constructor_amode_imm_reg_reg_shift(ctx, arg0, arg1, v55.1, v72);
                            // Rule at src/isa/x64/inst.isle line 553.
                            return v73.clone();
                        }
                    }
                }
                let v58 = C::i64_from_iconst(ctx, v55.1);
                if let Some(v59) = v58 {
                    let v60 = C::i64_from_i32(ctx, v59);
                    if let Some(v61) = v60 {
                        let v9 = C::offset32_to_i32(ctx, arg3);
                        let v62 = C::i32_checked_add(ctx, v9, v61);
                        if let Some(v63) = v62 {
                            let v64 = C::i32_to_offset32(ctx, v63);
                            let v65 = &constructor_amode_imm_reg_reg_shift(ctx, arg0, arg1, v55.0, v64);
                            // Rule at src/isa/x64/inst.isle line 550.
                            return v65.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 v27,
            args: ref v28,
        } = &v24.1 {
            if let &Opcode::Iadd = v27 {
                let v29 = C::unpack_value_array_2(ctx, v28);
                let v40 = C::i64_from_iconst(ctx, v29.0);
                if let Some(v41) = v40 {
                    let v42 = C::i64_from_i32(ctx, v41);
                    if let Some(v43) = v42 {
                        let v9 = C::offset32_to_i32(ctx, arg3);
                        let v44 = C::i32_checked_add(ctx, v9, v43);
                        if let Some(v45) = v44 {
                            let v46 = C::i32_to_offset32(ctx, v45);
                            let v47 = &constructor_amode_imm_reg_reg_shift(ctx, arg0, v29.1, arg2, v46);
                            // Rule at src/isa/x64/inst.isle line 547.
                            return v47.clone();
                        }
                    }
                }
                let v32 = C::i64_from_iconst(ctx, v29.1);
                if let Some(v33) = v32 {
                    let v34 = C::i64_from_i32(ctx, v33);
                    if let Some(v35) = v34 {
                        let v9 = C::offset32_to_i32(ctx, arg3);
                        let v36 = C::i32_checked_add(ctx, v9, v35);
                        if let Some(v37) = v36 {
                            let v38 = C::i32_to_offset32(ctx, v37);
                            let v39 = &constructor_amode_imm_reg_reg_shift(ctx, arg0, v29.0, arg2, v38);
                            // Rule at src/isa/x64/inst.isle line 544.
                            return v39.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: MemFlagsData,
    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 v11,
            args: ref v12,
        } = &v8.1 {
            if let &Opcode::Iadd = v11 {
                let v13 = C::unpack_value_array_2(ctx, v12);
                let v16 = &constructor_amode_imm_reg_reg_shift(ctx, arg0, v13.0, v13.1, arg2);
                // Rule at src/isa/x64/inst.isle line 567.
                return v16.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: MemFlagsData,
    arg1: Value,
    arg2: Value,
    arg3: Offset32,
) -> Amode {
    let v33 = C::def_inst(ctx, arg1);
    if let Some(v34) = v33 {
        let v35 = C::inst_data_value(ctx, v34);
        if let &InstructionData::Binary {
            opcode: ref v38,
            args: ref v39,
        } = &v35.1 {
            if let &Opcode::Ishl = v38 {
                let v40 = C::unpack_value_array_2(ctx, v39);
                let v43 = C::def_inst(ctx, v40.1);
                if let Some(v44) = v43 {
                    let v45 = C::inst_data_value(ctx, v44);
                    if let &InstructionData::UnaryImm {
                        opcode: ref v48,
                        imm: v49,
                    } = &v45.1 {
                        if let &Opcode::Iconst = v48 {
                            let v50 = C::uimm8(ctx, v49);
                            if let Some(v51) = v50 {
                                let v52 = C::u8_into_u32(ctx, v51);
                                let v53 = C::u32_lt_eq(ctx, v52, 0x3_u32);
                                if v53 == true {
                                    let v54 = constructor_put_in_gpr(ctx, arg2);
                                    let v55 = constructor_put_in_gpr(ctx, v40.0);
                                    let v4 = C::offset32_to_i32(ctx, arg3);
                                    let v56 = Amode::ImmRegRegShift {
                                        simm32: v4,
                                        base: v54,
                                        index: v55,
                                        shift: v51,
                                        flags: arg0,
                                    };
                                    // Rule at src/isa/x64/inst.isle line 584.
                                    return v56;
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    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 v14,
            args: ref v15,
        } = &v11.1 {
            if let &Opcode::Ishl = v14 {
                let v16 = C::unpack_value_array_2(ctx, v15);
                let v19 = C::def_inst(ctx, v16.1);
                if let Some(v20) = v19 {
                    let v21 = C::inst_data_value(ctx, v20);
                    if let &InstructionData::UnaryImm {
                        opcode: ref v24,
                        imm: v25,
                    } = &v21.1 {
                        if let &Opcode::Iconst = v24 {
                            let v26 = C::uimm8(ctx, v25);
                            if let Some(v27) = v26 {
                                let v28 = C::u8_into_u32(ctx, v27);
                                let v30 = C::u32_lt_eq(ctx, v28, 0x3_u32);
                                if v30 == true {
                                    let v5 = constructor_put_in_gpr(ctx, arg1);
                                    let v31 = constructor_put_in_gpr(ctx, v16.0);
                                    let v4 = C::offset32_to_i32(ctx, arg3);
                                    let v32 = Amode::ImmRegRegShift {
                                        simm32: v4,
                                        base: v5,
                                        index: v31,
                                        shift: v27,
                                        flags: arg0,
                                    };
                                    // Rule at src/isa/x64/inst.isle line 581.
                                    return v32;
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    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 amode_offset.
pub fn constructor_amode_offset<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: MemFlagsData,
    arg2: i32,
) -> SyntheticAmode {
    let v3 = &C::amode_try_offset(ctx, arg0, arg2);
    if let Some(v4) = v3 {
        // Rule at src/isa/x64/inst.isle line 595.
        return v4.clone();
    }
    let v6 = constructor_x64_lea(ctx, I64, arg0);
    let v7 = C::gpr_to_reg(ctx, v6);
    let v8 = Amode::ImmReg {
        simm32: arg2,
        base: v7,
        flags: arg1,
    };
    let v9 = &C::amode_to_synthetic_amode(ctx, &v8);
    // Rule at src/isa/x64/inst.isle line 598.
    return v9.clone();
}

// 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 v6,
            imm: v7,
        } = &v3.1 {
            if let &Opcode::Iconst = v6 {
                let v10 = C::shift_mask(ctx, arg1);
                let v8 = C::u64_from_imm64(ctx, v7);
                let v11 = C::u8_into_u64(ctx, v10);
                let v12 = C::u64_and(ctx, v8, v11);
                let v13 = C::u64_truncate_into_u8(ctx, v12);
                let v14 = Imm8Gpr::Imm8 {
                    imm: v13,
                };
                // Rule at src/isa/x64/inst.isle line 632.
                return v14;
            }
        }
    }
    let v15 = C::fits_in_16(ctx, arg1);
    if let Some(v16) = v15 {
        let v18 = C::put_in_regs(ctx, arg0);
        let v20 = constructor_value_regs_get_gpr(ctx, v18, 0x0_usize);
        let v21 = C::shift_mask(ctx, v16);
        let v22 = C::u8_into_u32(ctx, v21);
        let v23 = RegMemImm::Imm {
            simm32: v22,
        };
        let v24 = &C::gpr_mem_imm_new(ctx, &v23);
        let v25 = constructor_x64_and(ctx, I64, v20, v24);
        let v26 = &constructor_gpr_to_imm8_gpr(ctx, v25);
        // Rule at src/isa/x64/inst.isle line 634.
        return v26.clone();
    }
    let v18 = C::put_in_regs(ctx, arg0);
    let v20 = constructor_value_regs_get_gpr(ctx, v18, 0x0_usize);
    let v27 = &constructor_gpr_to_imm8_gpr(ctx, v20);
    // Rule at src/isa/x64/inst.isle line 636.
    return v27.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 867.
    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 878.
                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 885.
                return v9;
            }
            _ => {}
        }
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "put_in_gpr", "src/isa/x64/inst.isle line 875")
}

// 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 894.
    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 901.
    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 1113.
    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 1132.
    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 1137.
    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 1142.
    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 1149.
    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 1154.
    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 1158.
    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 1332.
    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 1336.
    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 1399.
    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 1402.
    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 1407.
    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 1419.
    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 1426.
    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 1433.
    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 1440.
    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 1447.
    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 1456.
    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 1468.
    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 1480.
    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 1528.
        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 v4 = constructor_put_in_gpr(ctx, arg0);
                    // Rule at src/isa/x64/inst.isle line 1536.
                    return v4;
                }
            }
        }
    }
    let v6 = &C::sinkable_load_exact(ctx, arg0);
    if let Some(v7) = v6 {
        let v8 = &constructor_sink_load_to_gpr_mem(ctx, v7);
        let v9 = constructor_extend_to_gpr_types(ctx, v8, v1, arg1, arg2);
        // Rule at src/isa/x64/inst.isle line 1542.
        return v9;
    }
    let v10 = &constructor_put_in_gpr_mem(ctx, arg0);
    let v11 = constructor_extend_to_gpr_types(ctx, v10, v1, arg1, arg2);
    // Rule at src/isa/x64/inst.isle line 1546.
    return v11;
}

// 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 1551.
    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 1570.
            return v5;
        }
        &ExtendKind::Zero => {
            let v4 = constructor_x64_movzx(ctx, arg2, arg3);
            // Rule at src/isa/x64/inst.isle line 1566.
            return v4;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "extend", "src/isa/x64/inst.isle line 1563")
}

// 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.1 {
            &InstructionData::Binary {
                opcode: ref v6,
                args: ref v7,
            } => {
                match v6 {
                    &Opcode::Iadd => {
                        let v11 = true;
                        // Rule at src/isa/x64/inst.isle line 1577.
                        return v11;
                    }
                    &Opcode::Isub => {
                        let v11 = true;
                        // Rule at src/isa/x64/inst.isle line 1578.
                        return v11;
                    }
                    &Opcode::Imul => {
                        let v11 = true;
                        // Rule at src/isa/x64/inst.isle line 1579.
                        return v11;
                    }
                    &Opcode::Band => {
                        let v11 = true;
                        // Rule at src/isa/x64/inst.isle line 1580.
                        return v11;
                    }
                    &Opcode::Bor => {
                        let v11 = true;
                        // Rule at src/isa/x64/inst.isle line 1581.
                        return v11;
                    }
                    &Opcode::Bxor => {
                        let v11 = true;
                        // Rule at src/isa/x64/inst.isle line 1582.
                        return v11;
                    }
                    &Opcode::Ishl => {
                        let v11 = true;
                        // Rule at src/isa/x64/inst.isle line 1583.
                        return v11;
                    }
                    &Opcode::Ushr => {
                        let v11 = true;
                        // Rule at src/isa/x64/inst.isle line 1584.
                        return v11;
                    }
                    _ => {}
                }
            }
            &InstructionData::Load {
                opcode: ref v12,
                arg: v13,
                flags: v14,
                offset: v15,
            } => {
                if let &Opcode::Uload32 = v12 {
                    let v11 = true;
                    // Rule at src/isa/x64/inst.isle line 1585.
                    return v11;
                }
            }
            _ => {}
        }
    }
    let v16 = false;
    // Rule at src/isa/x64/inst.isle line 1586.
    return v16;
}

// 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 1592.
                    return I8X16;
                }
            }
            0x10_u32 => {
                if v2.1 == 0x8_u32 {
                    // Rule at src/isa/x64/inst.isle line 1593.
                    return I16X8;
                }
            }
            0x20_u32 => {
                if v2.1 == 0x4_u32 {
                    // Rule at src/isa/x64/inst.isle line 1594.
                    return I32X4;
                }
            }
            0x40_u32 => {
                if v2.1 == 0x2_u32 {
                    // Rule at src/isa/x64/inst.isle line 1595.
                    return I64X2;
                }
            }
            _ => {}
        }
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "vec_int_type", "src/isa/x64/inst.isle line 1591")
}

// 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: &XmmMem128,
) -> Xmm {
    match arg0 {
        F16 => {
            let v3 = constructor_x64_xorps(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 1599.
            return v3;
        }
        F32 => {
            let v3 = constructor_x64_xorps(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 1600.
            return v3;
        }
        F64 => {
            let v4 = constructor_x64_xorpd(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 1601.
            return v4;
        }
        F128 => {
            let v3 = constructor_x64_xorps(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 1602.
            return v3;
        }
        F32X4 => {
            let v3 = constructor_x64_xorps(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 1603.
            return v3;
        }
        F64X2 => {
            let v4 = constructor_x64_xorpd(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 1604.
            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 1605.
        return v9;
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_xor_vector", "src/isa/x64/inst.isle line 1598")
}

// 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_128(ctx, v0);
    let v2 = constructor_x64_pcmpeqd(ctx, v0, v1);
    // Rule at src/isa/x64/inst.isle line 1617.
    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_32(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 1625.
            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 1623.
            return v2.clone();
        }
        &RegMemImm::Imm {
            simm32: v3,
        } => {
            let v2 = &C::xmm_mem_imm_new(ctx, arg0);
            // Rule at src/isa/x64/inst.isle line 1624.
            return v2.clone();
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "mov_rmi_to_xmm", "src/isa/x64/inst.isle line 1622")
}

// 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 1643.
    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 1648.
    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 1653.
    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 1658.
    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 1664.
    return v6;
}

// Generated as internal constructor for term x64_load_xmm.
pub fn constructor_x64_load_xmm<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: &SyntheticAmode,
) -> Xmm {
    match arg0 {
        F32 => {
            let v2 = constructor_x64_movss_load(ctx, arg1);
            // Rule at src/isa/x64/inst.isle line 1676.
            return v2;
        }
        F64 => {
            let v3 = constructor_x64_movsd_load(ctx, arg1);
            // Rule at src/isa/x64/inst.isle line 1677.
            return v3;
        }
        F128 => {
            let v4 = &C::synthetic_amode_to_xmm_mem_128(ctx, arg1);
            let v5 = constructor_x64_movdqu_load(ctx, v4);
            // Rule at src/isa/x64/inst.isle line 1678.
            return v5;
        }
        F32X4 => {
            let v6 = constructor_x64_movups_load(ctx, arg1);
            // Rule at src/isa/x64/inst.isle line 1679.
            return v6;
        }
        F64X2 => {
            let v7 = constructor_x64_movupd_load(ctx, arg1);
            // Rule at src/isa/x64/inst.isle line 1680.
            return v7;
        }
        _ => {}
    }
    let v8 = C::multi_lane(ctx, arg0);
    if let Some(v9) = v8 {
        let v4 = &C::synthetic_amode_to_xmm_mem_128(ctx, arg1);
        let v5 = constructor_x64_movdqu_load(ctx, v4);
        // Rule at src/isa/x64/inst.isle line 1681.
        return v5;
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_load_xmm", "src/isa/x64/inst.isle line 1675")
}

// Generated as internal constructor for term x64_mov.
pub fn constructor_x64_mov<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
) -> Reg {
    let v1 = &C::synthetic_amode_to_gpr_mem_64(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 1686.
    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 = &C::gpr_mem_as_gpr_mem_8(ctx, arg1);
            let v3 = constructor_x64_movzbl_rm(ctx, v2);
            // Rule at src/isa/x64/inst.isle line 1711.
            return v3;
        }
        &ExtMode::BQ => {
            let v2 = &C::gpr_mem_as_gpr_mem_8(ctx, arg1);
            let v4 = constructor_x64_movzbq_rm(ctx, v2);
            // Rule at src/isa/x64/inst.isle line 1712.
            return v4;
        }
        &ExtMode::WL => {
            let v5 = &C::gpr_mem_as_gpr_mem_16(ctx, arg1);
            let v6 = constructor_x64_movzwl_rm(ctx, v5);
            // Rule at src/isa/x64/inst.isle line 1713.
            return v6;
        }
        &ExtMode::WQ => {
            let v5 = &C::gpr_mem_as_gpr_mem_16(ctx, arg1);
            let v7 = constructor_x64_movzwq_rm(ctx, v5);
            // Rule at src/isa/x64/inst.isle line 1714.
            return v7;
        }
        &ExtMode::LQ => {
            let v8 = &C::gpr_mem_as_gpr_mem_32(ctx, arg1);
            let v9 = constructor_x64_movl_rm(ctx, v8);
            // Rule at src/isa/x64/inst.isle line 1720.
            return v9;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_movzx", "src/isa/x64/inst.isle line 1688")
}

// 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 = &C::gpr_mem_as_gpr_mem_8(ctx, arg1);
            let v3 = constructor_x64_movsbl_rm(ctx, v2);
            // Rule at src/isa/x64/inst.isle line 1723.
            return v3;
        }
        &ExtMode::BQ => {
            let v2 = &C::gpr_mem_as_gpr_mem_8(ctx, arg1);
            let v4 = constructor_x64_movsbq_rm(ctx, v2);
            // Rule at src/isa/x64/inst.isle line 1724.
            return v4;
        }
        &ExtMode::WL => {
            let v5 = &C::gpr_mem_as_gpr_mem_16(ctx, arg1);
            let v6 = constructor_x64_movswl_rm(ctx, v5);
            // Rule at src/isa/x64/inst.isle line 1725.
            return v6;
        }
        &ExtMode::WQ => {
            let v5 = &C::gpr_mem_as_gpr_mem_16(ctx, arg1);
            let v7 = constructor_x64_movswq_rm(ctx, v5);
            // Rule at src/isa/x64/inst.isle line 1726.
            return v7;
        }
        &ExtMode::LQ => {
            let v8 = &C::gpr_mem_as_gpr_mem_32(ctx, arg1);
            let v9 = constructor_x64_movslq_rm(ctx, v8);
            // Rule at src/isa/x64/inst.isle line 1727.
            return v9;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_movsx", "src/isa/x64/inst.isle line 1722")
}

// 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 1730.
    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 1733.
    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 1736.
    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 1739.
    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 = &C::synthetic_amode_to_xmm_mem_128(ctx, arg0);
    let v2 = constructor_x64_movups_a_or_avx(ctx, v1);
    // Rule at src/isa/x64/inst.isle line 1742.
    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 1745.
    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 = &C::synthetic_amode_to_xmm_mem_128(ctx, arg0);
    let v2 = constructor_x64_movupd_a_or_avx(ctx, v1);
    // Rule at src/isa/x64/inst.isle line 1748.
    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 1751.
    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 1756.
        return v3;
    }
    let v1 = constructor_x64_movd_b(ctx, arg0);
    // Rule at src/isa/x64/inst.isle line 1755.
    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: &GprMem32,
) -> 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 1763.
        return v3;
    }
    let v1 = constructor_x64_movd_a(ctx, arg0);
    // Rule at src/isa/x64/inst.isle line 1762.
    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: &GprMem64,
) -> 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 1770.
        return v3;
    }
    let v1 = constructor_x64_movq_a(ctx, arg0);
    // Rule at src/isa/x64/inst.isle line 1769.
    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 1777.
        return v3;
    }
    let v1 = constructor_x64_movq_b(ctx, arg0);
    // Rule at src/isa/x64/inst.isle line 1776.
    return v1;
}

// Generated as internal constructor for term x64_movdqu_load.
pub fn constructor_x64_movdqu_load<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem128,
) -> Xmm {
    let v1 = constructor_x64_movdqu_a_or_avx(ctx, arg0);
    // Rule at src/isa/x64/inst.isle line 1782.
    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 1785.
    return v2.clone();
}

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

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

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

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

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

// Generated as internal constructor for term x64_pmovzxdq.
pub fn constructor_x64_pmovzxdq<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem64,
) -> Xmm {
    let v1 = constructor_x64_pmovzxdq_a_or_avx(ctx, arg0);
    // Rule at src/isa/x64/inst.isle line 1805.
    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 1810.
            return v3.clone();
        }
        I16 => {
            let v4 = &constructor_x64_movw_mr_mem(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 1811.
            return v4.clone();
        }
        I32 => {
            let v5 = &constructor_x64_movl_mr_mem(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 1812.
            return v5.clone();
        }
        I64 => {
            let v6 = &constructor_x64_movq_mr_mem(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 1813.
            return v6.clone();
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_movrm", "src/isa/x64/inst.isle line 1807")
}

// 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 1816.
                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 1817.
                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 1818.
            return v12.clone();
        }
        I64 => {
            let v13 = &constructor_x64_movq_mi_sxl_mem(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 1819.
            return v13.clone();
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_movimm_m", "src/isa/x64/inst.isle line 1815")
}

// 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 v3 = constructor_x64_load_xmm(ctx, arg0, v2);
    // Rule at src/isa/x64/inst.isle line 1823.
    return v3;
}

// 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 1837.
            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 1839.
            return v5.clone();
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_produce_flags", "src/isa/x64/inst.isle line 1836")
}

// 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 1845.
            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 1847.
            return v10;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "asm_produce_flags", "src/isa/x64/inst.isle line 1844")
}

// 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 1854.
            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 1856.
            return v6.clone();
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_chain_flags", "src/isa/x64/inst.isle line 1853")
}

// 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 1860.
        return v4;
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "asm_chain_flags", "src/isa/x64/inst.isle line 1859")
}

// 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 1868.
                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 1870.
                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 1867")
}

// 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 1876.
            return v5;
        }
        &AssemblerOutputs::RetGpr {
            inst: ref v1,
            gpr: v2,
        } => {
            let v3 = ProducesFlags::ProducesFlagsSideEffect {
                inst: v1.clone(),
            };
            // Rule at src/isa/x64/inst.isle line 1874.
            return v3;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "asm_produce_flags_side_effect", "src/isa/x64/inst.isle line 1873")
}

// 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 1882.
        return v4;
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "asm_consume_flags", "src/isa/x64/inst.isle line 1881")
}

// 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 1886.
        return v4;
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "asm_consumes_flags_returns_gpr", "src/isa/x64/inst.isle line 1885")
}

// 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 v9 = C::is_imm8(ctx, arg2);
            if let Some(v10) = v9 {
                let v11 = &C::gpr_to_gpr_mem_8(ctx, arg1);
                let v12 = &C::x64_addb_mi_raw(ctx, v11, v10);
                // Rule at src/isa/x64/inst.isle line 1905.
                return v12.clone();
            }
            let v23 = &C::is_gpr_mem(ctx, arg2);
            if let Some(v24) = v23 {
                let v25 = &C::gpr_mem_8_for_ty(ctx, arg0, v24);
                let v26 = &C::x64_addb_rm_raw(ctx, arg1, v25);
                // Rule at src/isa/x64/inst.isle line 1911.
                return v26.clone();
            }
        }
        I16 => {
            let v13 = C::is_imm16(ctx, arg2);
            if let Some(v14) = v13 {
                let v15 = &C::gpr_to_gpr_mem_16(ctx, arg1);
                let v16 = &C::x64_addw_mi_raw(ctx, v15, v14);
                // Rule at src/isa/x64/inst.isle line 1906.
                return v16.clone();
            }
            let v23 = &C::is_gpr_mem(ctx, arg2);
            if let Some(v24) = v23 {
                let v27 = &C::gpr_mem_16_for_ty(ctx, arg0, v24);
                let v28 = &C::x64_addw_rm_raw(ctx, arg1, v27);
                // Rule at src/isa/x64/inst.isle line 1912.
                return v28.clone();
            }
        }
        I32 => {
            let v3 = C::is_simm8(ctx, arg2);
            if let Some(v4) = v3 {
                let v5 = &C::gpr_to_gpr_mem_32(ctx, arg1);
                let v6 = &C::x64_addl_mi_sxb_raw(ctx, v5, v4);
                // Rule at src/isa/x64/inst.isle line 1901.
                return v6.clone();
            }
            let v17 = C::is_imm32(ctx, arg2);
            if let Some(v18) = v17 {
                let v5 = &C::gpr_to_gpr_mem_32(ctx, arg1);
                let v19 = &C::x64_addl_mi_raw(ctx, v5, v18);
                // Rule at src/isa/x64/inst.isle line 1907.
                return v19.clone();
            }
            let v23 = &C::is_gpr_mem(ctx, arg2);
            if let Some(v24) = v23 {
                let v29 = &C::gpr_mem_32_for_ty(ctx, arg0, v24);
                let v30 = &C::x64_addl_rm_raw(ctx, arg1, v29);
                // Rule at src/isa/x64/inst.isle line 1913.
                return v30.clone();
            }
        }
        I64 => {
            let v3 = C::is_simm8(ctx, arg2);
            if let Some(v4) = v3 {
                let v7 = &C::gpr_to_gpr_mem_64(ctx, arg1);
                let v8 = &C::x64_addq_mi_sxb_raw(ctx, v7, v4);
                // Rule at src/isa/x64/inst.isle line 1902.
                return v8.clone();
            }
            let v20 = C::is_simm32(ctx, arg2);
            if let Some(v21) = v20 {
                let v7 = &C::gpr_to_gpr_mem_64(ctx, arg1);
                let v22 = &C::x64_addq_mi_sxl_raw(ctx, v7, v21);
                // Rule at src/isa/x64/inst.isle line 1908.
                return v22.clone();
            }
            let v23 = &C::is_gpr_mem(ctx, arg2);
            if let Some(v24) = v23 {
                let v31 = &C::gpr_mem_64_for_ty(ctx, arg0, v24);
                let v32 = &C::x64_addq_rm_raw(ctx, arg1, v31);
                // Rule at src/isa/x64/inst.isle line 1914.
                return v32.clone();
            }
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_add_raw", "src/isa/x64/inst.isle line 1898")
}

// 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_32(ctx, v4);
                let v6 = &C::x64_addl_rm_raw(ctx, arg1, v5);
                // Rule at src/isa/x64/inst.isle line 1920.
                return v6.clone();
            }
        }
        I16 => {
            let v3 = C::is_gpr(ctx, arg2);
            if let Some(v4) = v3 {
                let v5 = &C::gpr_to_gpr_mem_32(ctx, v4);
                let v6 = &C::x64_addl_rm_raw(ctx, arg1, v5);
                // Rule at src/isa/x64/inst.isle line 1921.
                return v6.clone();
            }
        }
        _ => {}
    }
    let v7 = &constructor_x64_add_raw(ctx, arg0, arg1, arg2);
    // Rule at src/isa/x64/inst.isle line 1922.
    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 1926.
    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 1933.
    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_64(ctx, arg1);
            let v6 = &C::x64_adcq_mi_sxb_raw(ctx, v5, v4);
            // Rule at src/isa/x64/inst.isle line 1942.
            return v6.clone();
        }
        let v7 = C::is_simm32(ctx, arg2);
        if let Some(v8) = v7 {
            let v5 = &C::gpr_to_gpr_mem_64(ctx, arg1);
            let v9 = &C::x64_adcq_mi_sxl_raw(ctx, v5, v8);
            // Rule at src/isa/x64/inst.isle line 1943.
            return v9.clone();
        }
        let v10 = &C::is_gpr_mem(ctx, arg2);
        if let Some(v11) = v10 {
            let v12 = &C::gpr_mem_64_for_ty(ctx, arg0, v11);
            let v13 = &C::x64_adcq_rm_raw(ctx, arg1, v12);
            // Rule at src/isa/x64/inst.isle line 1944.
            return v13.clone();
        }
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_adc_raw", "src/isa/x64/inst.isle line 1941")
}

// 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 1948.
    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 1953.
    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 v9 = C::is_imm8(ctx, arg2);
            if let Some(v10) = v9 {
                let v11 = &C::gpr_to_gpr_mem_8(ctx, arg1);
                let v12 = &C::x64_subb_mi_raw(ctx, v11, v10);
                // Rule at src/isa/x64/inst.isle line 1966.
                return v12.clone();
            }
            let v23 = &C::is_gpr_mem(ctx, arg2);
            if let Some(v24) = v23 {
                let v25 = &C::gpr_mem_8_for_ty(ctx, arg0, v24);
                let v26 = &C::x64_subb_rm_raw(ctx, arg1, v25);
                // Rule at src/isa/x64/inst.isle line 1972.
                return v26.clone();
            }
        }
        I16 => {
            let v13 = C::is_imm16(ctx, arg2);
            if let Some(v14) = v13 {
                let v15 = &C::gpr_to_gpr_mem_16(ctx, arg1);
                let v16 = &C::x64_subw_mi_raw(ctx, v15, v14);
                // Rule at src/isa/x64/inst.isle line 1967.
                return v16.clone();
            }
            let v23 = &C::is_gpr_mem(ctx, arg2);
            if let Some(v24) = v23 {
                let v27 = &C::gpr_mem_16_for_ty(ctx, arg0, v24);
                let v28 = &C::x64_subw_rm_raw(ctx, arg1, v27);
                // Rule at src/isa/x64/inst.isle line 1973.
                return v28.clone();
            }
        }
        I32 => {
            let v3 = C::is_simm8(ctx, arg2);
            if let Some(v4) = v3 {
                let v5 = &C::gpr_to_gpr_mem_32(ctx, arg1);
                let v6 = &C::x64_subl_mi_sxb_raw(ctx, v5, v4);
                // Rule at src/isa/x64/inst.isle line 1962.
                return v6.clone();
            }
            let v17 = C::is_imm32(ctx, arg2);
            if let Some(v18) = v17 {
                let v5 = &C::gpr_to_gpr_mem_32(ctx, arg1);
                let v19 = &C::x64_subl_mi_raw(ctx, v5, v18);
                // Rule at src/isa/x64/inst.isle line 1968.
                return v19.clone();
            }
            let v23 = &C::is_gpr_mem(ctx, arg2);
            if let Some(v24) = v23 {
                let v29 = &C::gpr_mem_32_for_ty(ctx, arg0, v24);
                let v30 = &C::x64_subl_rm_raw(ctx, arg1, v29);
                // Rule at src/isa/x64/inst.isle line 1974.
                return v30.clone();
            }
        }
        I64 => {
            let v3 = C::is_simm8(ctx, arg2);
            if let Some(v4) = v3 {
                let v7 = &C::gpr_to_gpr_mem_64(ctx, arg1);
                let v8 = &C::x64_subq_mi_sxb_raw(ctx, v7, v4);
                // Rule at src/isa/x64/inst.isle line 1963.
                return v8.clone();
            }
            let v20 = C::is_simm32(ctx, arg2);
            if let Some(v21) = v20 {
                let v7 = &C::gpr_to_gpr_mem_64(ctx, arg1);
                let v22 = &C::x64_subq_mi_sxl_raw(ctx, v7, v21);
                // Rule at src/isa/x64/inst.isle line 1969.
                return v22.clone();
            }
            let v23 = &C::is_gpr_mem(ctx, arg2);
            if let Some(v24) = v23 {
                let v31 = &C::gpr_mem_64_for_ty(ctx, arg0, v24);
                let v32 = &C::x64_subq_rm_raw(ctx, arg1, v31);
                // Rule at src/isa/x64/inst.isle line 1975.
                return v32.clone();
            }
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_sub_raw", "src/isa/x64/inst.isle line 1959")
}

// 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_32(ctx, v4);
                let v6 = &C::x64_subl_rm_raw(ctx, arg1, v5);
                // Rule at src/isa/x64/inst.isle line 1981.
                return v6.clone();
            }
        }
        I16 => {
            let v3 = C::is_gpr(ctx, arg2);
            if let Some(v4) = v3 {
                let v5 = &C::gpr_to_gpr_mem_32(ctx, v4);
                let v6 = &C::x64_subl_rm_raw(ctx, arg1, v5);
                // Rule at src/isa/x64/inst.isle line 1982.
                return v6.clone();
            }
        }
        _ => {}
    }
    let v7 = &constructor_x64_sub_raw(ctx, arg0, arg1, arg2);
    // Rule at src/isa/x64/inst.isle line 1983.
    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 1987.
    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 1993.
    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 v9 = C::is_imm8(ctx, arg2);
            if let Some(v10) = v9 {
                let v11 = &C::gpr_to_gpr_mem_8(ctx, arg1);
                let v12 = &C::x64_sbbb_mi_raw(ctx, v11, v10);
                // Rule at src/isa/x64/inst.isle line 2007.
                return v12.clone();
            }
            let v23 = &C::is_gpr_mem(ctx, arg2);
            if let Some(v24) = v23 {
                let v25 = &C::gpr_mem_8_for_ty(ctx, arg0, v24);
                let v26 = &C::x64_sbbb_rm_raw(ctx, arg1, v25);
                // Rule at src/isa/x64/inst.isle line 2013.
                return v26.clone();
            }
        }
        I16 => {
            let v13 = C::is_imm16(ctx, arg2);
            if let Some(v14) = v13 {
                let v15 = &C::gpr_to_gpr_mem_16(ctx, arg1);
                let v16 = &C::x64_sbbw_mi_raw(ctx, v15, v14);
                // Rule at src/isa/x64/inst.isle line 2008.
                return v16.clone();
            }
            let v23 = &C::is_gpr_mem(ctx, arg2);
            if let Some(v24) = v23 {
                let v27 = &C::gpr_mem_16_for_ty(ctx, arg0, v24);
                let v28 = &C::x64_sbbw_rm_raw(ctx, arg1, v27);
                // Rule at src/isa/x64/inst.isle line 2014.
                return v28.clone();
            }
        }
        I32 => {
            let v3 = C::is_simm8(ctx, arg2);
            if let Some(v4) = v3 {
                let v5 = &C::gpr_to_gpr_mem_32(ctx, arg1);
                let v6 = &C::x64_sbbl_mi_sxb_raw(ctx, v5, v4);
                // Rule at src/isa/x64/inst.isle line 2003.
                return v6.clone();
            }
            let v17 = C::is_imm32(ctx, arg2);
            if let Some(v18) = v17 {
                let v5 = &C::gpr_to_gpr_mem_32(ctx, arg1);
                let v19 = &C::x64_sbbl_mi_raw(ctx, v5, v18);
                // Rule at src/isa/x64/inst.isle line 2009.
                return v19.clone();
            }
            let v23 = &C::is_gpr_mem(ctx, arg2);
            if let Some(v24) = v23 {
                let v29 = &C::gpr_mem_32_for_ty(ctx, arg0, v24);
                let v30 = &C::x64_sbbl_rm_raw(ctx, arg1, v29);
                // Rule at src/isa/x64/inst.isle line 2015.
                return v30.clone();
            }
        }
        I64 => {
            let v3 = C::is_simm8(ctx, arg2);
            if let Some(v4) = v3 {
                let v7 = &C::gpr_to_gpr_mem_64(ctx, arg1);
                let v8 = &C::x64_sbbq_mi_sxb_raw(ctx, v7, v4);
                // Rule at src/isa/x64/inst.isle line 2004.
                return v8.clone();
            }
            let v20 = C::is_simm32(ctx, arg2);
            if let Some(v21) = v20 {
                let v7 = &C::gpr_to_gpr_mem_64(ctx, arg1);
                let v22 = &C::x64_sbbq_mi_sxl_raw(ctx, v7, v21);
                // Rule at src/isa/x64/inst.isle line 2010.
                return v22.clone();
            }
            let v23 = &C::is_gpr_mem(ctx, arg2);
            if let Some(v24) = v23 {
                let v31 = &C::gpr_mem_64_for_ty(ctx, arg0, v24);
                let v32 = &C::x64_sbbq_rm_raw(ctx, arg1, v31);
                // Rule at src/isa/x64/inst.isle line 2016.
                return v32.clone();
            }
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_sbb_raw", "src/isa/x64/inst.isle line 2000")
}

// 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_32(ctx, v4);
                let v6 = &C::x64_sbbl_rm_raw(ctx, arg1, v5);
                // Rule at src/isa/x64/inst.isle line 2022.
                return v6.clone();
            }
        }
        I16 => {
            let v3 = C::is_gpr(ctx, arg2);
            if let Some(v4) = v3 {
                let v5 = &C::gpr_to_gpr_mem_32(ctx, v4);
                let v6 = &C::x64_sbbl_rm_raw(ctx, arg1, v5);
                // Rule at src/isa/x64/inst.isle line 2023.
                return v6.clone();
            }
        }
        _ => {}
    }
    let v7 = &constructor_x64_sbb_raw(ctx, arg0, arg1, arg2);
    // Rule at src/isa/x64/inst.isle line 2024.
    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 2029.
    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 2034.
    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 2039.
    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::gpr_mem_16_for_ty(ctx, arg0, arg3);
                    let v5 = &C::x64_mulw_m_raw(ctx, arg2, v4);
                    // Rule at src/isa/x64/inst.isle line 2047.
                    return v5.clone();
                }
                true => {
                    let v4 = &C::gpr_mem_16_for_ty(ctx, arg0, arg3);
                    let v10 = &C::x64_imulw_m_raw(ctx, arg2, v4);
                    // Rule at src/isa/x64/inst.isle line 2050.
                    return v10.clone();
                }
                _ => {}
            }
        }
        I32 => {
            match arg1 {
                false => {
                    let v6 = &C::gpr_mem_32_for_ty(ctx, arg0, arg3);
                    let v7 = &C::x64_mull_m_raw(ctx, arg2, v6);
                    // Rule at src/isa/x64/inst.isle line 2048.
                    return v7.clone();
                }
                true => {
                    let v6 = &C::gpr_mem_32_for_ty(ctx, arg0, arg3);
                    let v11 = &C::x64_imull_m_raw(ctx, arg2, v6);
                    // Rule at src/isa/x64/inst.isle line 2051.
                    return v11.clone();
                }
                _ => {}
            }
        }
        I64 => {
            match arg1 {
                false => {
                    let v8 = &C::gpr_mem_64_for_ty(ctx, arg0, arg3);
                    let v9 = &C::x64_mulq_m_raw(ctx, arg2, v8);
                    // Rule at src/isa/x64/inst.isle line 2049.
                    return v9.clone();
                }
                true => {
                    let v8 = &C::gpr_mem_64_for_ty(ctx, arg0, arg3);
                    let v12 = &C::x64_imulq_m_raw(ctx, arg2, v8);
                    // Rule at src/isa/x64/inst.isle line 2052.
                    return v12.clone();
                }
                _ => {}
            }
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_mul_raw", "src/isa/x64/inst.isle line 2046")
}

// 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 = &C::gpr_mem_32_for_ty(ctx, arg0, arg3);
                    let v8 = constructor_x64_mulxl_rvm(ctx, v7, arg2);
                    let v10 = C::value_regs_get(ctx, v8, 0x1_usize);
                    let v12 = C::value_regs_get(ctx, v8, 0x0_usize);
                    let v13 = C::value_regs(ctx, v10, v12);
                    // Rule at src/isa/x64/inst.isle line 2063.
                    return v13;
                }
            }
        }
        I64 => {
            if arg1 == false {
                let v6 = C::has_bmi2(ctx);
                if v6 == true {
                    let v14 = &C::gpr_mem_64_for_ty(ctx, arg0, arg3);
                    let v15 = constructor_x64_mulxq_rvm(ctx, v14, arg2);
                    let v16 = C::value_regs_get(ctx, v15, 0x1_usize);
                    let v17 = C::value_regs_get(ctx, v15, 0x0_usize);
                    let v18 = C::value_regs(ctx, v16, v17);
                    // Rule at src/isa/x64/inst.isle line 2067.
                    return v18;
                }
            }
        }
        _ => {}
    }
    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 2055.
    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::gpr_mem_32_for_ty(ctx, arg0, arg2);
            let v4 = &C::gpr_mem_32_to_gpr_mem(ctx, v3);
            let v5 = C::x64_mulxl_rvm_hi(ctx, v4, arg1);
            // Rule at src/isa/x64/inst.isle line 2073.
            return v5;
        }
        I64 => {
            let v6 = &C::gpr_mem_64_for_ty(ctx, arg0, arg2);
            let v7 = &C::gpr_mem_64_to_gpr_mem(ctx, v6);
            let v8 = C::x64_mulxq_rvm_hi(ctx, v7, arg1);
            // Rule at src/isa/x64/inst.isle line 2074.
            return v8;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_mulx_hi", "src/isa/x64/inst.isle line 2072")
}

// 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 2082.
    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 = &C::gpr_mem_16_for_ty(ctx, arg0, arg2);
            let v4 = constructor_x64_imulw_rm(ctx, arg1, v3);
            // Rule at src/isa/x64/inst.isle line 2091.
            return v4;
        }
        I32 => {
            let v5 = &C::gpr_mem_32_for_ty(ctx, arg0, arg2);
            let v6 = constructor_x64_imull_rm(ctx, arg1, v5);
            // Rule at src/isa/x64/inst.isle line 2092.
            return v6;
        }
        I64 => {
            let v7 = &C::gpr_mem_64_for_ty(ctx, arg0, arg2);
            let v8 = constructor_x64_imulq_rm(ctx, arg1, v7);
            // Rule at src/isa/x64/inst.isle line 2093.
            return v8;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_imul", "src/isa/x64/inst.isle line 2090")
}

// 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 = &C::gpr_mem_16_for_ty(ctx, arg0, arg1);
                let v6 = constructor_x64_imulw_rmi_sxb(ctx, v5, v4);
                // Rule at src/isa/x64/inst.isle line 2098.
                return v6;
            }
            let v11 = C::i32_from_i16(ctx, arg2);
            if let Some(v12) = v11 {
                let v5 = &C::gpr_mem_16_for_ty(ctx, arg0, arg1);
                let v13 = C::i16_cast_unsigned(ctx, v12);
                let v14 = constructor_x64_imulw_rmi(ctx, v5, v13);
                // Rule at src/isa/x64/inst.isle line 2101.
                return v14;
            }
        }
        I32 => {
            let v3 = C::i32_from_i8(ctx, arg2);
            if let Some(v4) = v3 {
                let v7 = &C::gpr_mem_32_for_ty(ctx, arg0, arg1);
                let v8 = constructor_x64_imull_rmi_sxb(ctx, v7, v4);
                // Rule at src/isa/x64/inst.isle line 2099.
                return v8;
            }
            let v7 = &C::gpr_mem_32_for_ty(ctx, arg0, arg1);
            let v15 = C::i32_cast_unsigned(ctx, arg2);
            let v16 = constructor_x64_imull_rmi(ctx, v7, v15);
            // Rule at src/isa/x64/inst.isle line 2102.
            return v16;
        }
        I64 => {
            let v3 = C::i32_from_i8(ctx, arg2);
            if let Some(v4) = v3 {
                let v9 = &C::gpr_mem_64_for_ty(ctx, arg0, arg1);
                let v10 = constructor_x64_imulq_rmi_sxb(ctx, v9, v4);
                // Rule at src/isa/x64/inst.isle line 2100.
                return v10;
            }
            let v9 = &C::gpr_mem_64_for_ty(ctx, arg0, arg1);
            let v17 = constructor_x64_imulq_rmi_sxl(ctx, v9, arg2);
            // Rule at src/isa/x64/inst.isle line 2103.
            return v17;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_imul_imm", "src/isa/x64/inst.isle line 2097")
}

// 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::gpr_mem_as_gpr_mem_8(ctx, arg2);
            let v4 = &C::x64_mulb_m_raw(ctx, arg1, v3);
            // Rule at src/isa/x64/inst.isle line 2109.
            return v4.clone();
        }
        true => {
            let v3 = &C::gpr_mem_as_gpr_mem_8(ctx, arg2);
            let v5 = &C::x64_imulb_m_raw(ctx, arg1, v3);
            // Rule at src/isa/x64/inst.isle line 2110.
            return v5.clone();
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_mul8_raw", "src/isa/x64/inst.isle line 2107")
}

// 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 2113.
    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 2117.
    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 2130.
                return v9;
            }
            let v19 = C::is_gpr(ctx, arg2);
            if let Some(v20) = v19 {
                let v21 = &C::gpr_to_gpr_mem_32(ctx, v20);
                let v22 = constructor_x64_andl_rm(ctx, arg1, v21);
                // Rule at src/isa/x64/inst.isle line 2137.
                return v22;
            }
            let v23 = &C::is_gpr_mem(ctx, arg2);
            if let Some(v24) = v23 {
                let v25 = &C::gpr_mem_8_for_ty(ctx, arg0, v24);
                let v26 = constructor_x64_andb_rm(ctx, arg1, v25);
                // Rule at src/isa/x64/inst.isle line 2141.
                return v26;
            }
        }
        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 2131.
                return v12;
            }
            let v19 = C::is_gpr(ctx, arg2);
            if let Some(v20) = v19 {
                let v21 = &C::gpr_to_gpr_mem_32(ctx, v20);
                let v22 = constructor_x64_andl_rm(ctx, arg1, v21);
                // Rule at src/isa/x64/inst.isle line 2138.
                return v22;
            }
            let v23 = &C::is_gpr_mem(ctx, arg2);
            if let Some(v24) = v23 {
                let v27 = &C::gpr_mem_16_for_ty(ctx, arg0, v24);
                let v28 = constructor_x64_andw_rm(ctx, arg1, v27);
                // Rule at src/isa/x64/inst.isle line 2142.
                return v28;
            }
        }
        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 2126.
                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 2132.
                return v15;
            }
            let v23 = &C::is_gpr_mem(ctx, arg2);
            if let Some(v24) = v23 {
                let v29 = &C::gpr_mem_32_for_ty(ctx, arg0, v24);
                let v30 = constructor_x64_andl_rm(ctx, arg1, v29);
                // Rule at src/isa/x64/inst.isle line 2143.
                return v30;
            }
        }
        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 2127.
                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 2133.
                return v18;
            }
            let v23 = &C::is_gpr_mem(ctx, arg2);
            if let Some(v24) = v23 {
                let v31 = &C::gpr_mem_64_for_ty(ctx, arg0, v24);
                let v32 = constructor_x64_andq_rm(ctx, arg1, v31);
                // Rule at src/isa/x64/inst.isle line 2144.
                return v32;
            }
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_and", "src/isa/x64/inst.isle line 2123")
}

// 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 v9 = C::is_imm8(ctx, arg2);
            if let Some(v10) = v9 {
                let v11 = &C::gpr_to_gpr_mem_8(ctx, arg1);
                let v12 = &C::x64_orb_mi_raw(ctx, v11, v10);
                // Rule at src/isa/x64/inst.isle line 2156.
                return v12.clone();
            }
            let v23 = &C::is_gpr_mem(ctx, arg2);
            if let Some(v24) = v23 {
                let v25 = &C::gpr_mem_8_for_ty(ctx, arg0, v24);
                let v26 = &C::x64_orb_rm_raw(ctx, arg1, v25);
                // Rule at src/isa/x64/inst.isle line 2162.
                return v26.clone();
            }
        }
        I16 => {
            let v13 = C::is_imm16(ctx, arg2);
            if let Some(v14) = v13 {
                let v15 = &C::gpr_to_gpr_mem_16(ctx, arg1);
                let v16 = &C::x64_orw_mi_raw(ctx, v15, v14);
                // Rule at src/isa/x64/inst.isle line 2157.
                return v16.clone();
            }
            let v23 = &C::is_gpr_mem(ctx, arg2);
            if let Some(v24) = v23 {
                let v27 = &C::gpr_mem_16_for_ty(ctx, arg0, v24);
                let v28 = &C::x64_orw_rm_raw(ctx, arg1, v27);
                // Rule at src/isa/x64/inst.isle line 2163.
                return v28.clone();
            }
        }
        I32 => {
            let v3 = C::is_simm8(ctx, arg2);
            if let Some(v4) = v3 {
                let v5 = &C::gpr_to_gpr_mem_32(ctx, arg1);
                let v6 = &C::x64_orl_mi_sxb_raw(ctx, v5, v4);
                // Rule at src/isa/x64/inst.isle line 2152.
                return v6.clone();
            }
            let v17 = C::is_imm32(ctx, arg2);
            if let Some(v18) = v17 {
                let v5 = &C::gpr_to_gpr_mem_32(ctx, arg1);
                let v19 = &C::x64_orl_mi_raw(ctx, v5, v18);
                // Rule at src/isa/x64/inst.isle line 2158.
                return v19.clone();
            }
            let v23 = &C::is_gpr_mem(ctx, arg2);
            if let Some(v24) = v23 {
                let v29 = &C::gpr_mem_32_for_ty(ctx, arg0, v24);
                let v30 = &C::x64_orl_rm_raw(ctx, arg1, v29);
                // Rule at src/isa/x64/inst.isle line 2164.
                return v30.clone();
            }
        }
        I64 => {
            let v3 = C::is_simm8(ctx, arg2);
            if let Some(v4) = v3 {
                let v7 = &C::gpr_to_gpr_mem_64(ctx, arg1);
                let v8 = &C::x64_orq_mi_sxb_raw(ctx, v7, v4);
                // Rule at src/isa/x64/inst.isle line 2153.
                return v8.clone();
            }
            let v20 = C::is_simm32(ctx, arg2);
            if let Some(v21) = v20 {
                let v7 = &C::gpr_to_gpr_mem_64(ctx, arg1);
                let v22 = &C::x64_orq_mi_sxl_raw(ctx, v7, v21);
                // Rule at src/isa/x64/inst.isle line 2159.
                return v22.clone();
            }
            let v23 = &C::is_gpr_mem(ctx, arg2);
            if let Some(v24) = v23 {
                let v31 = &C::gpr_mem_64_for_ty(ctx, arg0, v24);
                let v32 = &C::x64_orq_rm_raw(ctx, arg1, v31);
                // Rule at src/isa/x64/inst.isle line 2165.
                return v32.clone();
            }
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_or_raw", "src/isa/x64/inst.isle line 2149")
}

// 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_32(ctx, v4);
                let v6 = &C::x64_orl_rm_raw(ctx, arg1, v5);
                // Rule at src/isa/x64/inst.isle line 2170.
                return v6.clone();
            }
        }
        I16 => {
            let v3 = C::is_gpr(ctx, arg2);
            if let Some(v4) = v3 {
                let v5 = &C::gpr_to_gpr_mem_32(ctx, v4);
                let v6 = &C::x64_orl_rm_raw(ctx, arg1, v5);
                // Rule at src/isa/x64/inst.isle line 2171.
                return v6.clone();
            }
        }
        _ => {}
    }
    let v7 = &constructor_x64_or_raw(ctx, arg0, arg1, arg2);
    // Rule at src/isa/x64/inst.isle line 2172.
    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 2176.
    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 2182.
    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 2195.
                return v9;
            }
            let v19 = C::is_gpr(ctx, arg2);
            if let Some(v20) = v19 {
                let v21 = &C::gpr_to_gpr_mem_32(ctx, v20);
                let v22 = constructor_x64_xorl_rm(ctx, arg1, v21);
                // Rule at src/isa/x64/inst.isle line 2202.
                return v22;
            }
            let v23 = &C::is_gpr_mem(ctx, arg2);
            if let Some(v24) = v23 {
                let v25 = &C::gpr_mem_8_for_ty(ctx, arg0, v24);
                let v26 = constructor_x64_xorb_rm(ctx, arg1, v25);
                // Rule at src/isa/x64/inst.isle line 2206.
                return v26;
            }
        }
        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 2196.
                return v12;
            }
            let v19 = C::is_gpr(ctx, arg2);
            if let Some(v20) = v19 {
                let v21 = &C::gpr_to_gpr_mem_32(ctx, v20);
                let v22 = constructor_x64_xorl_rm(ctx, arg1, v21);
                // Rule at src/isa/x64/inst.isle line 2203.
                return v22;
            }
            let v23 = &C::is_gpr_mem(ctx, arg2);
            if let Some(v24) = v23 {
                let v27 = &C::gpr_mem_16_for_ty(ctx, arg0, v24);
                let v28 = constructor_x64_xorw_rm(ctx, arg1, v27);
                // Rule at src/isa/x64/inst.isle line 2207.
                return v28;
            }
        }
        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 2191.
                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 2197.
                return v15;
            }
            let v23 = &C::is_gpr_mem(ctx, arg2);
            if let Some(v24) = v23 {
                let v29 = &C::gpr_mem_32_for_ty(ctx, arg0, v24);
                let v30 = constructor_x64_xorl_rm(ctx, arg1, v29);
                // Rule at src/isa/x64/inst.isle line 2208.
                return v30;
            }
        }
        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 2192.
                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 2198.
                return v18;
            }
            let v23 = &C::is_gpr_mem(ctx, arg2);
            if let Some(v24) = v23 {
                let v31 = &C::gpr_mem_64_for_ty(ctx, arg0, v24);
                let v32 = constructor_x64_xorq_rm(ctx, arg1, v31);
                // Rule at src/isa/x64/inst.isle line 2209.
                return v32;
            }
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_xor", "src/isa/x64/inst.isle line 2188")
}

// 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 = &C::gpr_mem_as_gpr_mem_32_or_widened_in_reg(ctx, arg0, arg2);
            let v4 = constructor_x64_andnl_rvm(ctx, arg1, v3);
            // Rule at src/isa/x64/inst.isle line 2217.
            return v4;
        }
        I16 => {
            let v3 = &C::gpr_mem_as_gpr_mem_32_or_widened_in_reg(ctx, arg0, arg2);
            let v4 = constructor_x64_andnl_rvm(ctx, arg1, v3);
            // Rule at src/isa/x64/inst.isle line 2218.
            return v4;
        }
        I32 => {
            let v5 = &C::gpr_mem_32_for_ty(ctx, arg0, arg2);
            let v6 = constructor_x64_andnl_rvm(ctx, arg1, v5);
            // Rule at src/isa/x64/inst.isle line 2219.
            return v6;
        }
        I64 => {
            let v7 = &C::gpr_mem_64_for_ty(ctx, arg0, arg2);
            let v8 = constructor_x64_andnq_rvm(ctx, arg1, v7);
            // Rule at src/isa/x64/inst.isle line 2220.
            return v8;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_andn", "src/isa/x64/inst.isle line 2216")
}

// 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 2226.
    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 2272.
                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 2273.
                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 2274.
                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 2271.
            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 2268.
                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 2264.
                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 2256.
                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 2250.
            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 2251.
                    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_32(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 2252.
                    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_64(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 2253.
                    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 2247.
                return v9;
            }
        }
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "imm", "src/isa/x64/inst.isle line 2235")
}

// 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_128(ctx, v1);
    let v3 = constructor_x64_xor_vector(ctx, arg0, v1, v2);
    // Rule at src/isa/x64/inst.isle line 2279.
    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 2297.
                    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 2293.
                        return v13;
                    }
                    let v6 = constructor_x64_rolb_mi(ctx, arg1, v5);
                    // Rule at src/isa/x64/inst.isle line 2286.
                    return v6;
                }
                I16 => {
                    if v5 == 0x1_u8 {
                        let v14 = constructor_x64_rolw_m1(ctx, arg1);
                        // Rule at src/isa/x64/inst.isle line 2294.
                        return v14;
                    }
                    let v8 = constructor_x64_rolw_mi(ctx, arg1, v5);
                    // Rule at src/isa/x64/inst.isle line 2288.
                    return v8;
                }
                I32 => {
                    if v5 == 0x1_u8 {
                        let v15 = constructor_x64_roll_m1(ctx, arg1);
                        // Rule at src/isa/x64/inst.isle line 2295.
                        return v15;
                    }
                    let v10 = constructor_x64_roll_mi(ctx, arg1, v5);
                    // Rule at src/isa/x64/inst.isle line 2290.
                    return v10;
                }
                I64 => {
                    if v5 == 0x1_u8 {
                        let v16 = constructor_x64_rolq_m1(ctx, arg1);
                        // Rule at src/isa/x64/inst.isle line 2296.
                        return v16;
                    }
                    let v12 = constructor_x64_rolq_mi(ctx, arg1, v5);
                    // Rule at src/isa/x64/inst.isle line 2292.
                    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 2285.
                    return v4;
                }
                I16 => {
                    let v7 = constructor_x64_rolw_mc(ctx, arg1, v3);
                    // Rule at src/isa/x64/inst.isle line 2287.
                    return v7;
                }
                I32 => {
                    let v9 = constructor_x64_roll_mc(ctx, arg1, v3);
                    // Rule at src/isa/x64/inst.isle line 2289.
                    return v9;
                }
                I64 => {
                    let v11 = constructor_x64_rolq_mc(ctx, arg1, v3);
                    // Rule at src/isa/x64/inst.isle line 2291.
                    return v11;
                }
                _ => {}
            }
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_rotl", "src/isa/x64/inst.isle line 2284")
}

// 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 2315.
                    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 2311.
                        return v13;
                    }
                    let v6 = constructor_x64_rorb_mi(ctx, arg1, v5);
                    // Rule at src/isa/x64/inst.isle line 2304.
                    return v6;
                }
                I16 => {
                    if v5 == 0x1_u8 {
                        let v14 = constructor_x64_rorw_m1(ctx, arg1);
                        // Rule at src/isa/x64/inst.isle line 2312.
                        return v14;
                    }
                    let v8 = constructor_x64_rorw_mi(ctx, arg1, v5);
                    // Rule at src/isa/x64/inst.isle line 2306.
                    return v8;
                }
                I32 => {
                    if v5 == 0x1_u8 {
                        let v15 = constructor_x64_rorl_m1(ctx, arg1);
                        // Rule at src/isa/x64/inst.isle line 2313.
                        return v15;
                    }
                    let v10 = constructor_x64_rorl_mi(ctx, arg1, v5);
                    // Rule at src/isa/x64/inst.isle line 2308.
                    return v10;
                }
                I64 => {
                    if v5 == 0x1_u8 {
                        let v16 = constructor_x64_rorq_m1(ctx, arg1);
                        // Rule at src/isa/x64/inst.isle line 2314.
                        return v16;
                    }
                    let v12 = constructor_x64_rorq_mi(ctx, arg1, v5);
                    // Rule at src/isa/x64/inst.isle line 2310.
                    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 2303.
                    return v4;
                }
                I16 => {
                    let v7 = constructor_x64_rorw_mc(ctx, arg1, v3);
                    // Rule at src/isa/x64/inst.isle line 2305.
                    return v7;
                }
                I32 => {
                    let v9 = constructor_x64_rorl_mc(ctx, arg1, v3);
                    // Rule at src/isa/x64/inst.isle line 2307.
                    return v9;
                }
                I64 => {
                    let v11 = constructor_x64_rorq_mc(ctx, arg1, v3);
                    // Rule at src/isa/x64/inst.isle line 2309.
                    return v11;
                }
                _ => {}
            }
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_rotr", "src/isa/x64/inst.isle line 2302")
}

// 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 2329.
                        return v13;
                    }
                    let v6 = constructor_x64_shlb_mi(ctx, arg1, v5);
                    // Rule at src/isa/x64/inst.isle line 2322.
                    return v6;
                }
                I16 => {
                    if v5 == 0x1_u8 {
                        let v14 = constructor_x64_shlw_m1(ctx, arg1);
                        // Rule at src/isa/x64/inst.isle line 2330.
                        return v14;
                    }
                    let v8 = constructor_x64_shlw_mi(ctx, arg1, v5);
                    // Rule at src/isa/x64/inst.isle line 2324.
                    return v8;
                }
                I32 => {
                    if v5 == 0x1_u8 {
                        let v15 = constructor_x64_shll_m1(ctx, arg1);
                        // Rule at src/isa/x64/inst.isle line 2331.
                        return v15;
                    }
                    let v10 = constructor_x64_shll_mi(ctx, arg1, v5);
                    // Rule at src/isa/x64/inst.isle line 2326.
                    return v10;
                }
                I64 => {
                    if v5 == 0x1_u8 {
                        let v16 = constructor_x64_shlq_m1(ctx, arg1);
                        // Rule at src/isa/x64/inst.isle line 2332.
                        return v16;
                    }
                    let v12 = constructor_x64_shlq_mi(ctx, arg1, v5);
                    // Rule at src/isa/x64/inst.isle line 2328.
                    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 2337.
                    return v21;
                }
            }
            match arg0 {
                I8 => {
                    let v4 = constructor_x64_shlb_mc(ctx, arg1, v3);
                    // Rule at src/isa/x64/inst.isle line 2321.
                    return v4;
                }
                I16 => {
                    let v7 = constructor_x64_shlw_mc(ctx, arg1, v3);
                    // Rule at src/isa/x64/inst.isle line 2323.
                    return v7;
                }
                I32 => {
                    let v9 = constructor_x64_shll_mc(ctx, arg1, v3);
                    // Rule at src/isa/x64/inst.isle line 2325.
                    return v9;
                }
                I64 => {
                    let v11 = constructor_x64_shlq_mc(ctx, arg1, v3);
                    // Rule at src/isa/x64/inst.isle line 2327.
                    return v11;
                }
                _ => {}
            }
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_shl", "src/isa/x64/inst.isle line 2320")
}

// 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 2351.
                        return v13;
                    }
                    let v6 = constructor_x64_shrb_mi(ctx, arg1, v5);
                    // Rule at src/isa/x64/inst.isle line 2344.
                    return v6;
                }
                I16 => {
                    if v5 == 0x1_u8 {
                        let v14 = constructor_x64_shrw_m1(ctx, arg1);
                        // Rule at src/isa/x64/inst.isle line 2352.
                        return v14;
                    }
                    let v8 = constructor_x64_shrw_mi(ctx, arg1, v5);
                    // Rule at src/isa/x64/inst.isle line 2346.
                    return v8;
                }
                I32 => {
                    if v5 == 0x1_u8 {
                        let v15 = constructor_x64_shrl_m1(ctx, arg1);
                        // Rule at src/isa/x64/inst.isle line 2353.
                        return v15;
                    }
                    let v10 = constructor_x64_shrl_mi(ctx, arg1, v5);
                    // Rule at src/isa/x64/inst.isle line 2348.
                    return v10;
                }
                I64 => {
                    if v5 == 0x1_u8 {
                        let v16 = constructor_x64_shrq_m1(ctx, arg1);
                        // Rule at src/isa/x64/inst.isle line 2354.
                        return v16;
                    }
                    let v12 = constructor_x64_shrq_mi(ctx, arg1, v5);
                    // Rule at src/isa/x64/inst.isle line 2350.
                    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 2356.
                    return v21;
                }
            }
            match arg0 {
                I8 => {
                    let v4 = constructor_x64_shrb_mc(ctx, arg1, v3);
                    // Rule at src/isa/x64/inst.isle line 2343.
                    return v4;
                }
                I16 => {
                    let v7 = constructor_x64_shrw_mc(ctx, arg1, v3);
                    // Rule at src/isa/x64/inst.isle line 2345.
                    return v7;
                }
                I32 => {
                    let v9 = constructor_x64_shrl_mc(ctx, arg1, v3);
                    // Rule at src/isa/x64/inst.isle line 2347.
                    return v9;
                }
                I64 => {
                    let v11 = constructor_x64_shrq_mc(ctx, arg1, v3);
                    // Rule at src/isa/x64/inst.isle line 2349.
                    return v11;
                }
                _ => {}
            }
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_shr", "src/isa/x64/inst.isle line 2342")
}

// 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 2370.
                        return v13;
                    }
                    let v6 = constructor_x64_sarb_mi(ctx, arg1, v5);
                    // Rule at src/isa/x64/inst.isle line 2363.
                    return v6;
                }
                I16 => {
                    if v5 == 0x1_u8 {
                        let v14 = constructor_x64_sarw_m1(ctx, arg1);
                        // Rule at src/isa/x64/inst.isle line 2371.
                        return v14;
                    }
                    let v8 = constructor_x64_sarw_mi(ctx, arg1, v5);
                    // Rule at src/isa/x64/inst.isle line 2365.
                    return v8;
                }
                I32 => {
                    if v5 == 0x1_u8 {
                        let v15 = constructor_x64_sarl_m1(ctx, arg1);
                        // Rule at src/isa/x64/inst.isle line 2372.
                        return v15;
                    }
                    let v10 = constructor_x64_sarl_mi(ctx, arg1, v5);
                    // Rule at src/isa/x64/inst.isle line 2367.
                    return v10;
                }
                I64 => {
                    if v5 == 0x1_u8 {
                        let v16 = constructor_x64_sarq_m1(ctx, arg1);
                        // Rule at src/isa/x64/inst.isle line 2373.
                        return v16;
                    }
                    let v12 = constructor_x64_sarq_mi(ctx, arg1, v5);
                    // Rule at src/isa/x64/inst.isle line 2369.
                    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 2375.
                    return v21;
                }
            }
            match arg0 {
                I8 => {
                    let v4 = constructor_x64_sarb_mc(ctx, arg1, v3);
                    // Rule at src/isa/x64/inst.isle line 2362.
                    return v4;
                }
                I16 => {
                    let v7 = constructor_x64_sarw_mc(ctx, arg1, v3);
                    // Rule at src/isa/x64/inst.isle line 2364.
                    return v7;
                }
                I32 => {
                    let v9 = constructor_x64_sarl_mc(ctx, arg1, v3);
                    // Rule at src/isa/x64/inst.isle line 2366.
                    return v9;
                }
                I64 => {
                    let v11 = constructor_x64_sarq_mc(ctx, arg1, v3);
                    // Rule at src/isa/x64/inst.isle line 2368.
                    return v11;
                }
                _ => {}
            }
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_sar", "src/isa/x64/inst.isle line 2361")
}

// 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 2382.
            return v4;
        }
        I32 => {
            let v5 = constructor_x64_shldl_mri(ctx, arg1, arg2, arg3);
            // Rule at src/isa/x64/inst.isle line 2383.
            return v5;
        }
        I64 => {
            let v6 = constructor_x64_shldq_mri(ctx, arg1, arg2, arg3);
            // Rule at src/isa/x64/inst.isle line 2384.
            return v6;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_shld", "src/isa/x64/inst.isle line 2380")
}

// 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 = &C::gpr_mem_32_for_ty(ctx, arg0, arg1);
            let v4 = constructor_x64_bzhil_rmv(ctx, v3, arg2);
            // Rule at src/isa/x64/inst.isle line 2388.
            return v4;
        }
        I64 => {
            let v5 = &C::gpr_mem_64_for_ty(ctx, arg0, arg1);
            let v6 = constructor_x64_bzhiq_rmv(ctx, v5, arg2);
            // Rule at src/isa/x64/inst.isle line 2389.
            return v6;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_bzhi", "src/isa/x64/inst.isle line 2387")
}

// 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 2395.
            return v2;
        }
        I64 => {
            let v3 = constructor_x64_bswapq_o(ctx, arg1);
            // Rule at src/isa/x64/inst.isle line 2396.
            return v3;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_bswap", "src/isa/x64/inst.isle line 2394")
}

// 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 v11 = C::is_imm8(ctx, arg2);
            if let Some(v12) = v11 {
                let v13 = &C::gpr_to_gpr_mem_8(ctx, arg1);
                let v14 = &constructor_x64_cmpb_mi(ctx, v13, v12);
                // Rule at src/isa/x64/inst.isle line 2407.
                return v14.clone();
            }
            let v24 = &C::is_gpr_mem(ctx, arg2);
            if let Some(v25) = v24 {
                let v26 = &C::gpr_mem_8_for_ty(ctx, arg0, v25);
                let v27 = &constructor_x64_cmpb_rm(ctx, arg1, v26);
                // Rule at src/isa/x64/inst.isle line 2413.
                return v27.clone();
            }
        }
        I16 => {
            let v3 = C::is_simm8(ctx, arg2);
            if let Some(v4) = v3 {
                let v5 = &C::gpr_to_gpr_mem_16(ctx, arg1);
                let v6 = &constructor_x64_cmpw_mi_sxb(ctx, v5, v4);
                // Rule at src/isa/x64/inst.isle line 2402.
                return v6.clone();
            }
            let v15 = C::is_imm16(ctx, arg2);
            if let Some(v16) = v15 {
                let v5 = &C::gpr_to_gpr_mem_16(ctx, arg1);
                let v17 = &constructor_x64_cmpw_mi(ctx, v5, v16);
                // Rule at src/isa/x64/inst.isle line 2408.
                return v17.clone();
            }
            let v24 = &C::is_gpr_mem(ctx, arg2);
            if let Some(v25) = v24 {
                let v28 = &C::gpr_mem_16_for_ty(ctx, arg0, v25);
                let v29 = &constructor_x64_cmpw_rm(ctx, arg1, v28);
                // Rule at src/isa/x64/inst.isle line 2414.
                return v29.clone();
            }
        }
        I32 => {
            let v3 = C::is_simm8(ctx, arg2);
            if let Some(v4) = v3 {
                let v7 = &C::gpr_to_gpr_mem_32(ctx, arg1);
                let v8 = &constructor_x64_cmpl_mi_sxb(ctx, v7, v4);
                // Rule at src/isa/x64/inst.isle line 2403.
                return v8.clone();
            }
            let v18 = C::is_imm32(ctx, arg2);
            if let Some(v19) = v18 {
                let v7 = &C::gpr_to_gpr_mem_32(ctx, arg1);
                let v20 = &constructor_x64_cmpl_mi(ctx, v7, v19);
                // Rule at src/isa/x64/inst.isle line 2409.
                return v20.clone();
            }
            let v24 = &C::is_gpr_mem(ctx, arg2);
            if let Some(v25) = v24 {
                let v30 = &C::gpr_mem_32_for_ty(ctx, arg0, v25);
                let v31 = &constructor_x64_cmpl_rm(ctx, arg1, v30);
                // Rule at src/isa/x64/inst.isle line 2415.
                return v31.clone();
            }
        }
        I64 => {
            let v3 = C::is_simm8(ctx, arg2);
            if let Some(v4) = v3 {
                let v9 = &C::gpr_to_gpr_mem_64(ctx, arg1);
                let v10 = &constructor_x64_cmpq_mi_sxb(ctx, v9, v4);
                // Rule at src/isa/x64/inst.isle line 2404.
                return v10.clone();
            }
            let v21 = C::is_simm32(ctx, arg2);
            if let Some(v22) = v21 {
                let v9 = &C::gpr_to_gpr_mem_64(ctx, arg1);
                let v23 = &constructor_x64_cmpq_mi(ctx, v9, v22);
                // Rule at src/isa/x64/inst.isle line 2410.
                return v23.clone();
            }
            let v24 = &C::is_gpr_mem(ctx, arg2);
            if let Some(v25) = v24 {
                let v32 = &C::gpr_mem_64_for_ty(ctx, arg0, v25);
                let v33 = &constructor_x64_cmpq_rm(ctx, arg1, v32);
                // Rule at src/isa/x64/inst.isle line 2416.
                return v33.clone();
            }
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_cmp", "src/isa/x64/inst.isle line 2399")
}

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

// 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_8(ctx, arg1);
                let v6 = &constructor_x64_testb_mi(ctx, v5, v4);
                // Rule at src/isa/x64/inst.isle line 2431.
                return v6.clone();
            }
            let v19 = &C::is_gpr_mem(ctx, arg2);
            if let Some(v20) = v19 {
                let v21 = &C::gpr_mem_8_for_ty(ctx, arg0, v20);
                let v22 = &constructor_x64_testb_mr(ctx, v21, arg1);
                // Rule at src/isa/x64/inst.isle line 2436.
                return v22.clone();
            }
        }
        I16 => {
            let v7 = C::is_imm16(ctx, arg2);
            if let Some(v8) = v7 {
                let v9 = &C::gpr_to_gpr_mem_16(ctx, arg1);
                let v10 = &constructor_x64_testw_mi(ctx, v9, v8);
                // Rule at src/isa/x64/inst.isle line 2432.
                return v10.clone();
            }
            let v19 = &C::is_gpr_mem(ctx, arg2);
            if let Some(v20) = v19 {
                let v23 = &C::gpr_mem_16_for_ty(ctx, arg0, v20);
                let v24 = &constructor_x64_testw_mr(ctx, v23, arg1);
                // Rule at src/isa/x64/inst.isle line 2437.
                return v24.clone();
            }
        }
        I32 => {
            let v11 = C::is_imm32(ctx, arg2);
            if let Some(v12) = v11 {
                let v13 = &C::gpr_to_gpr_mem_32(ctx, arg1);
                let v14 = &constructor_x64_testl_mi(ctx, v13, v12);
                // Rule at src/isa/x64/inst.isle line 2433.
                return v14.clone();
            }
            let v19 = &C::is_gpr_mem(ctx, arg2);
            if let Some(v20) = v19 {
                let v25 = &C::gpr_mem_32_for_ty(ctx, arg0, v20);
                let v26 = &constructor_x64_testl_mr(ctx, v25, arg1);
                // Rule at src/isa/x64/inst.isle line 2438.
                return v26.clone();
            }
        }
        I64 => {
            let v15 = C::is_simm32(ctx, arg2);
            if let Some(v16) = v15 {
                let v17 = &C::gpr_to_gpr_mem_64(ctx, arg1);
                let v18 = &constructor_x64_testq_mi(ctx, v17, v16);
                // Rule at src/isa/x64/inst.isle line 2434.
                return v18.clone();
            }
            let v19 = &C::is_gpr_mem(ctx, arg2);
            if let Some(v20) = v19 {
                let v27 = &C::gpr_mem_64_for_ty(ctx, arg0, v20);
                let v28 = &constructor_x64_testq_mr(ctx, v27, arg1);
                // Rule at src/isa/x64/inst.isle line 2439.
                return v28.clone();
            }
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_test", "src/isa/x64/inst.isle line 2429")
}

// Generated as internal constructor for term x64_ptest.
pub fn constructor_x64_ptest<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem128,
) -> ProducesFlags {
    let v2 = &constructor_x64_ptest_rm_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2443.
    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 v23 = &C::gpr_mem_64_for_ty(ctx, arg0, arg2);
                let v24 = &constructor_x64_cmovoq_rm(ctx, arg3, v23);
                // Rule at src/isa/x64/inst.isle line 2475.
                return v24.clone();
            }
            let v1 = C::fits_in_32(ctx, arg0);
            if let Some(v2) = v1 {
                let v6 = &C::gpr_mem_as_gpr_mem_32_or_widened_in_reg(ctx, arg0, arg2);
                let v7 = &constructor_x64_cmovol_rm(ctx, arg3, v6);
                // Rule at src/isa/x64/inst.isle line 2459.
                return v7.clone();
            }
        }
        &CC::NO => {
            if arg0 == I64 {
                let v23 = &C::gpr_mem_64_for_ty(ctx, arg0, arg2);
                let v25 = &constructor_x64_cmovnoq_rm(ctx, arg3, v23);
                // Rule at src/isa/x64/inst.isle line 2476.
                return v25.clone();
            }
            let v1 = C::fits_in_32(ctx, arg0);
            if let Some(v2) = v1 {
                let v6 = &C::gpr_mem_as_gpr_mem_32_or_widened_in_reg(ctx, arg0, arg2);
                let v8 = &constructor_x64_cmovnol_rm(ctx, arg3, v6);
                // Rule at src/isa/x64/inst.isle line 2460.
                return v8.clone();
            }
        }
        &CC::B => {
            if arg0 == I64 {
                let v23 = &C::gpr_mem_64_for_ty(ctx, arg0, arg2);
                let v26 = &constructor_x64_cmovbq_rm(ctx, arg3, v23);
                // Rule at src/isa/x64/inst.isle line 2477.
                return v26.clone();
            }
            let v1 = C::fits_in_32(ctx, arg0);
            if let Some(v2) = v1 {
                let v6 = &C::gpr_mem_as_gpr_mem_32_or_widened_in_reg(ctx, arg0, arg2);
                let v9 = &constructor_x64_cmovbl_rm(ctx, arg3, v6);
                // Rule at src/isa/x64/inst.isle line 2461.
                return v9.clone();
            }
        }
        &CC::NB => {
            if arg0 == I64 {
                let v23 = &C::gpr_mem_64_for_ty(ctx, arg0, arg2);
                let v27 = &constructor_x64_cmovaeq_rm(ctx, arg3, v23);
                // Rule at src/isa/x64/inst.isle line 2478.
                return v27.clone();
            }
            let v1 = C::fits_in_32(ctx, arg0);
            if let Some(v2) = v1 {
                let v6 = &C::gpr_mem_as_gpr_mem_32_or_widened_in_reg(ctx, arg0, arg2);
                let v10 = &constructor_x64_cmovael_rm(ctx, arg3, v6);
                // Rule at src/isa/x64/inst.isle line 2462.
                return v10.clone();
            }
        }
        &CC::Z => {
            if arg0 == I64 {
                let v23 = &C::gpr_mem_64_for_ty(ctx, arg0, arg2);
                let v28 = &constructor_x64_cmoveq_rm(ctx, arg3, v23);
                // Rule at src/isa/x64/inst.isle line 2479.
                return v28.clone();
            }
            let v1 = C::fits_in_32(ctx, arg0);
            if let Some(v2) = v1 {
                let v6 = &C::gpr_mem_as_gpr_mem_32_or_widened_in_reg(ctx, arg0, arg2);
                let v11 = &constructor_x64_cmovel_rm(ctx, arg3, v6);
                // Rule at src/isa/x64/inst.isle line 2463.
                return v11.clone();
            }
        }
        &CC::NZ => {
            if arg0 == I64 {
                let v23 = &C::gpr_mem_64_for_ty(ctx, arg0, arg2);
                let v29 = &constructor_x64_cmovneq_rm(ctx, arg3, v23);
                // Rule at src/isa/x64/inst.isle line 2480.
                return v29.clone();
            }
            let v1 = C::fits_in_32(ctx, arg0);
            if let Some(v2) = v1 {
                let v6 = &C::gpr_mem_as_gpr_mem_32_or_widened_in_reg(ctx, arg0, arg2);
                let v12 = &constructor_x64_cmovnel_rm(ctx, arg3, v6);
                // Rule at src/isa/x64/inst.isle line 2464.
                return v12.clone();
            }
        }
        &CC::BE => {
            if arg0 == I64 {
                let v23 = &C::gpr_mem_64_for_ty(ctx, arg0, arg2);
                let v30 = &constructor_x64_cmovbeq_rm(ctx, arg3, v23);
                // Rule at src/isa/x64/inst.isle line 2481.
                return v30.clone();
            }
            let v1 = C::fits_in_32(ctx, arg0);
            if let Some(v2) = v1 {
                let v6 = &C::gpr_mem_as_gpr_mem_32_or_widened_in_reg(ctx, arg0, arg2);
                let v13 = &constructor_x64_cmovbel_rm(ctx, arg3, v6);
                // Rule at src/isa/x64/inst.isle line 2465.
                return v13.clone();
            }
        }
        &CC::NBE => {
            if arg0 == I64 {
                let v23 = &C::gpr_mem_64_for_ty(ctx, arg0, arg2);
                let v31 = &constructor_x64_cmovaq_rm(ctx, arg3, v23);
                // Rule at src/isa/x64/inst.isle line 2482.
                return v31.clone();
            }
            let v1 = C::fits_in_32(ctx, arg0);
            if let Some(v2) = v1 {
                let v6 = &C::gpr_mem_as_gpr_mem_32_or_widened_in_reg(ctx, arg0, arg2);
                let v14 = &constructor_x64_cmoval_rm(ctx, arg3, v6);
                // Rule at src/isa/x64/inst.isle line 2466.
                return v14.clone();
            }
        }
        &CC::S => {
            if arg0 == I64 {
                let v23 = &C::gpr_mem_64_for_ty(ctx, arg0, arg2);
                let v32 = &constructor_x64_cmovsq_rm(ctx, arg3, v23);
                // Rule at src/isa/x64/inst.isle line 2483.
                return v32.clone();
            }
            let v1 = C::fits_in_32(ctx, arg0);
            if let Some(v2) = v1 {
                let v6 = &C::gpr_mem_as_gpr_mem_32_or_widened_in_reg(ctx, arg0, arg2);
                let v15 = &constructor_x64_cmovsl_rm(ctx, arg3, v6);
                // Rule at src/isa/x64/inst.isle line 2467.
                return v15.clone();
            }
        }
        &CC::NS => {
            if arg0 == I64 {
                let v23 = &C::gpr_mem_64_for_ty(ctx, arg0, arg2);
                let v33 = &constructor_x64_cmovnsq_rm(ctx, arg3, v23);
                // Rule at src/isa/x64/inst.isle line 2484.
                return v33.clone();
            }
            let v1 = C::fits_in_32(ctx, arg0);
            if let Some(v2) = v1 {
                let v6 = &C::gpr_mem_as_gpr_mem_32_or_widened_in_reg(ctx, arg0, arg2);
                let v16 = &constructor_x64_cmovnsl_rm(ctx, arg3, v6);
                // Rule at src/isa/x64/inst.isle line 2468.
                return v16.clone();
            }
        }
        &CC::L => {
            if arg0 == I64 {
                let v23 = &C::gpr_mem_64_for_ty(ctx, arg0, arg2);
                let v34 = &constructor_x64_cmovlq_rm(ctx, arg3, v23);
                // Rule at src/isa/x64/inst.isle line 2485.
                return v34.clone();
            }
            let v1 = C::fits_in_32(ctx, arg0);
            if let Some(v2) = v1 {
                let v6 = &C::gpr_mem_as_gpr_mem_32_or_widened_in_reg(ctx, arg0, arg2);
                let v17 = &constructor_x64_cmovll_rm(ctx, arg3, v6);
                // Rule at src/isa/x64/inst.isle line 2469.
                return v17.clone();
            }
        }
        &CC::NL => {
            if arg0 == I64 {
                let v23 = &C::gpr_mem_64_for_ty(ctx, arg0, arg2);
                let v35 = &constructor_x64_cmovgeq_rm(ctx, arg3, v23);
                // Rule at src/isa/x64/inst.isle line 2486.
                return v35.clone();
            }
            let v1 = C::fits_in_32(ctx, arg0);
            if let Some(v2) = v1 {
                let v6 = &C::gpr_mem_as_gpr_mem_32_or_widened_in_reg(ctx, arg0, arg2);
                let v18 = &constructor_x64_cmovgel_rm(ctx, arg3, v6);
                // Rule at src/isa/x64/inst.isle line 2470.
                return v18.clone();
            }
        }
        &CC::LE => {
            if arg0 == I64 {
                let v23 = &C::gpr_mem_64_for_ty(ctx, arg0, arg2);
                let v36 = &constructor_x64_cmovleq_rm(ctx, arg3, v23);
                // Rule at src/isa/x64/inst.isle line 2487.
                return v36.clone();
            }
            let v1 = C::fits_in_32(ctx, arg0);
            if let Some(v2) = v1 {
                let v6 = &C::gpr_mem_as_gpr_mem_32_or_widened_in_reg(ctx, arg0, arg2);
                let v19 = &constructor_x64_cmovlel_rm(ctx, arg3, v6);
                // Rule at src/isa/x64/inst.isle line 2471.
                return v19.clone();
            }
        }
        &CC::NLE => {
            if arg0 == I64 {
                let v23 = &C::gpr_mem_64_for_ty(ctx, arg0, arg2);
                let v37 = &constructor_x64_cmovgq_rm(ctx, arg3, v23);
                // Rule at src/isa/x64/inst.isle line 2488.
                return v37.clone();
            }
            let v1 = C::fits_in_32(ctx, arg0);
            if let Some(v2) = v1 {
                let v6 = &C::gpr_mem_as_gpr_mem_32_or_widened_in_reg(ctx, arg0, arg2);
                let v20 = &constructor_x64_cmovgl_rm(ctx, arg3, v6);
                // Rule at src/isa/x64/inst.isle line 2472.
                return v20.clone();
            }
        }
        &CC::P => {
            if arg0 == I64 {
                let v23 = &C::gpr_mem_64_for_ty(ctx, arg0, arg2);
                let v38 = &constructor_x64_cmovpq_rm(ctx, arg3, v23);
                // Rule at src/isa/x64/inst.isle line 2489.
                return v38.clone();
            }
            let v1 = C::fits_in_32(ctx, arg0);
            if let Some(v2) = v1 {
                let v6 = &C::gpr_mem_as_gpr_mem_32_or_widened_in_reg(ctx, arg0, arg2);
                let v21 = &constructor_x64_cmovpl_rm(ctx, arg3, v6);
                // Rule at src/isa/x64/inst.isle line 2473.
                return v21.clone();
            }
        }
        &CC::NP => {
            if arg0 == I64 {
                let v23 = &C::gpr_mem_64_for_ty(ctx, arg0, arg2);
                let v39 = &constructor_x64_cmovnpq_rm(ctx, arg3, v23);
                // Rule at src/isa/x64/inst.isle line 2490.
                return v39.clone();
            }
            let v1 = C::fits_in_32(ctx, arg0);
            if let Some(v2) = v1 {
                let v6 = &C::gpr_mem_as_gpr_mem_32_or_widened_in_reg(ctx, arg0, arg2);
                let v22 = &constructor_x64_cmovnpl_rm(ctx, arg3, v6);
                // Rule at src/isa/x64/inst.isle line 2474.
                return v22.clone();
            }
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "cmove", "src/isa/x64/inst.isle line 2458")
}

// 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 2493.
    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 2506.
            return v1.clone();
        }
        &CC::NO => {
            let v2 = &constructor_x64_setno_m(ctx);
            // Rule at src/isa/x64/inst.isle line 2507.
            return v2.clone();
        }
        &CC::B => {
            let v3 = &constructor_x64_setb_m(ctx);
            // Rule at src/isa/x64/inst.isle line 2508.
            return v3.clone();
        }
        &CC::NB => {
            let v4 = &constructor_x64_setae_m(ctx);
            // Rule at src/isa/x64/inst.isle line 2509.
            return v4.clone();
        }
        &CC::Z => {
            let v5 = &constructor_x64_sete_m(ctx);
            // Rule at src/isa/x64/inst.isle line 2510.
            return v5.clone();
        }
        &CC::NZ => {
            let v6 = &constructor_x64_setne_m(ctx);
            // Rule at src/isa/x64/inst.isle line 2511.
            return v6.clone();
        }
        &CC::BE => {
            let v7 = &constructor_x64_setbe_m(ctx);
            // Rule at src/isa/x64/inst.isle line 2512.
            return v7.clone();
        }
        &CC::NBE => {
            let v8 = &constructor_x64_seta_m(ctx);
            // Rule at src/isa/x64/inst.isle line 2513.
            return v8.clone();
        }
        &CC::S => {
            let v9 = &constructor_x64_sets_m(ctx);
            // Rule at src/isa/x64/inst.isle line 2514.
            return v9.clone();
        }
        &CC::NS => {
            let v10 = &constructor_x64_setns_m(ctx);
            // Rule at src/isa/x64/inst.isle line 2515.
            return v10.clone();
        }
        &CC::L => {
            let v11 = &constructor_x64_setl_m(ctx);
            // Rule at src/isa/x64/inst.isle line 2516.
            return v11.clone();
        }
        &CC::NL => {
            let v12 = &constructor_x64_setge_m(ctx);
            // Rule at src/isa/x64/inst.isle line 2517.
            return v12.clone();
        }
        &CC::LE => {
            let v13 = &constructor_x64_setle_m(ctx);
            // Rule at src/isa/x64/inst.isle line 2518.
            return v13.clone();
        }
        &CC::NLE => {
            let v14 = &constructor_x64_setg_m(ctx);
            // Rule at src/isa/x64/inst.isle line 2519.
            return v14.clone();
        }
        &CC::P => {
            let v15 = &constructor_x64_setp_m(ctx);
            // Rule at src/isa/x64/inst.isle line 2520.
            return v15.clone();
        }
        &CC::NP => {
            let v16 = &constructor_x64_setnp_m(ctx);
            // Rule at src/isa/x64/inst.isle line 2521.
            return v16.clone();
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_setcc", "src/isa/x64/inst.isle line 2505")
}

// 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 2526.
    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 2529.
        return v3;
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "consumes_flags_with_producer", "src/isa/x64/inst.isle line 2528")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// Generated as internal constructor for term x64_blendvpd.
pub fn constructor_x64_blendvpd<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem128,
    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 2744.
        return v6;
    }
    let v3 = &C::xmm_mem_128_to_xmm_mem_aligned_128(ctx, arg1);
    let v4 = constructor_x64_blendvpd_rm0(ctx, arg0, v3, arg2);
    // Rule at src/isa/x64/inst.isle line 2743.
    return v4;
}

// Generated as internal constructor for term x64_blendvps.
pub fn constructor_x64_blendvps<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem128,
    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 2751.
        return v6;
    }
    let v3 = &C::xmm_mem_128_to_xmm_mem_aligned_128(ctx, arg1);
    let v4 = constructor_x64_blendvps_rm0(ctx, arg0, v3, arg2);
    // Rule at src/isa/x64/inst.isle line 2750.
    return v4;
}

// Generated as internal constructor for term x64_pblendvb.
pub fn constructor_x64_pblendvb<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem128,
    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 2758.
        return v6;
    }
    let v3 = &C::xmm_mem_128_to_xmm_mem_aligned_128(ctx, arg1);
    let v4 = constructor_x64_pblendvb_rm(ctx, arg0, v3, arg2);
    // Rule at src/isa/x64/inst.isle line 2757.
    return v4;
}

// Generated as internal constructor for term x64_pblendw.
pub fn constructor_x64_pblendw<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem128,
    arg2: u8,
) -> Xmm {
    let v3 = constructor_x64_pblendw_rmi_or_avx(ctx, arg0, arg1, arg2);
    // Rule at src/isa/x64/inst.isle line 2764.
    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 2775.
    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 2778.
    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 2782.
    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: &XmmMem128,
) -> Xmm {
    match arg0 {
        I8X16 => {
            let v3 = constructor_x64_pmaxsb_a_or_avx(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 2786.
            return v3;
        }
        I16X8 => {
            let v4 = constructor_x64_pmaxsw_a_or_avx(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 2787.
            return v4;
        }
        I32X4 => {
            let v5 = constructor_x64_pmaxsd_a_or_avx(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 2788.
            return v5;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_pmaxs", "src/isa/x64/inst.isle line 2785")
}

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

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

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

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

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

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

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

// Generated as internal constructor for term x64_palignr.
pub fn constructor_x64_palignr<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem128,
    arg2: u8,
) -> Xmm {
    let v3 = constructor_x64_palignr_a_or_avx(ctx, arg0, arg1, arg2);
    // Rule at src/isa/x64/inst.isle line 2830.
    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: &XmmMem128,
    arg3: &FcmpImm,
) -> Xmm {
    match arg0 {
        F32X4 => {
            let v4 = constructor_x64_cmpps(ctx, arg1, arg2, arg3);
            // Rule at src/isa/x64/inst.isle line 2834.
            return v4;
        }
        F64X2 => {
            let v5 = constructor_x64_cmppd(ctx, arg1, arg2, arg3);
            // Rule at src/isa/x64/inst.isle line 2835.
            return v5;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_cmpp", "src/isa/x64/inst.isle line 2833")
}

// Generated as internal constructor for term x64_cmpps.
pub fn constructor_x64_cmpps<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem128,
    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 2838.
        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 2841.
    return v6;
}

// Generated as internal constructor for term x64_cmppd.
pub fn constructor_x64_cmppd<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem128,
    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 2847.
        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 2850.
    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 = &C::gpr_mem_as_gpr_mem_32(ctx, arg1);
        let v5 = constructor_x64_vpinsrb_b(ctx, arg0, v4, arg2);
        // Rule at src/isa/x64/inst.isle line 2854.
        return v5;
    }
    let v4 = &C::gpr_mem_as_gpr_mem_32(ctx, arg1);
    let v6 = constructor_x64_pinsrb_a(ctx, arg0, v4, arg2);
    // Rule at src/isa/x64/inst.isle line 2857.
    return v6;
}

// 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 = &C::gpr_mem_as_gpr_mem_32(ctx, arg1);
        let v5 = constructor_x64_vpinsrw_b(ctx, arg0, v4, arg2);
        // Rule at src/isa/x64/inst.isle line 2860.
        return v5;
    }
    let v4 = &C::gpr_mem_as_gpr_mem_32(ctx, arg1);
    let v6 = constructor_x64_pinsrw_a(ctx, arg0, v4, arg2);
    // Rule at src/isa/x64/inst.isle line 2863.
    return v6;
}

// 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 = &C::gpr_mem_as_gpr_mem_32(ctx, arg1);
        let v5 = constructor_x64_vpinsrd_b(ctx, arg0, v4, arg2);
        // Rule at src/isa/x64/inst.isle line 2866.
        return v5;
    }
    let v4 = &C::gpr_mem_as_gpr_mem_32(ctx, arg1);
    let v6 = constructor_x64_pinsrd_a(ctx, arg0, v4, arg2);
    // Rule at src/isa/x64/inst.isle line 2869.
    return v6;
}

// 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 = &C::gpr_mem_as_gpr_mem_64(ctx, arg1);
        let v5 = constructor_x64_vpinsrq_b(ctx, arg0, v4, arg2);
        // Rule at src/isa/x64/inst.isle line 2872.
        return v5;
    }
    let v4 = &C::gpr_mem_as_gpr_mem_64(ctx, arg1);
    let v6 = constructor_x64_pinsrq_a(ctx, arg0, v4, arg2);
    // Rule at src/isa/x64/inst.isle line 2875.
    return v6;
}

// Generated as internal constructor for term x64_roundss.
pub fn constructor_x64_roundss<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem32,
    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 2879.
        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 2882.
    return v8;
}

// Generated as internal constructor for term x64_roundsd.
pub fn constructor_x64_roundsd<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem64,
    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 2887.
        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 2890.
    return v8;
}

// Generated as internal constructor for term x64_roundps.
pub fn constructor_x64_roundps<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem128,
    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 2895.
        return v4;
    }
    let v5 = &C::xmm_mem_128_to_xmm_mem_aligned_128(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 2898.
    return v7;
}

// Generated as internal constructor for term x64_roundpd.
pub fn constructor_x64_roundpd<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem128,
    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 2903.
        return v4;
    }
    let v5 = &C::xmm_mem_128_to_xmm_mem_aligned_128(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 2906.
    return v7;
}

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

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

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

// Generated as internal constructor for term x64_pshufd.
pub fn constructor_x64_pshufd<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem128,
    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 2923.
        return v5;
    }
    let v2 = &C::xmm_mem_128_to_xmm_mem_aligned_128(ctx, arg0);
    let v3 = constructor_x64_pshufd_a(ctx, v2, arg1);
    // Rule at src/isa/x64/inst.isle line 2922.
    return v3;
}

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

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

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

// Generated as internal constructor for term x64_pshuflw.
pub fn constructor_x64_pshuflw<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem128,
    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 2942.
        return v5;
    }
    let v2 = &C::xmm_mem_128_to_xmm_mem_aligned_128(ctx, arg0);
    let v3 = constructor_x64_pshuflw_a(ctx, v2, arg1);
    // Rule at src/isa/x64/inst.isle line 2941.
    return v3;
}

// Generated as internal constructor for term x64_pshufhw.
pub fn constructor_x64_pshufhw<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem128,
    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 2949.
        return v5;
    }
    let v2 = &C::xmm_mem_128_to_xmm_mem_aligned_128(ctx, arg0);
    let v3 = constructor_x64_pshufhw_a(ctx, v2, arg1);
    // Rule at src/isa/x64/inst.isle line 2948.
    return v3;
}

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

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

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

// Generated as internal constructor for term x64_vpmullq.
pub fn constructor_x64_vpmullq<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem128,
) -> Xmm {
    let v2 = constructor_x64_vpmullq_c(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2969.
    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: &XmmMem128,
) -> Xmm {
    let v3 = constructor_x64_vpermi2b_a(ctx, arg0, arg1, arg2);
    // Rule at src/isa/x64/inst.isle line 2973.
    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 = &C::xmm_mem_as_xmm_mem_128(ctx, v3);
        let v5 = constructor_x64_psllw_a_or_avx(ctx, arg0, v4);
        // Rule at src/isa/x64/inst.isle line 2977.
        return v5;
    }
    let v6 = C::is_imm8_xmm(ctx, arg1);
    if let Some(v7) = v6 {
        let v8 = constructor_x64_psllw_b_or_avx(ctx, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 2978.
        return v8;
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_psllw", "src/isa/x64/inst.isle line 2976")
}

// 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 = &C::xmm_mem_as_xmm_mem_128(ctx, v3);
        let v5 = constructor_x64_pslld_a_or_avx(ctx, arg0, v4);
        // Rule at src/isa/x64/inst.isle line 2981.
        return v5;
    }
    let v6 = C::is_imm8_xmm(ctx, arg1);
    if let Some(v7) = v6 {
        let v8 = constructor_x64_pslld_b_or_avx(ctx, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 2982.
        return v8;
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_pslld", "src/isa/x64/inst.isle line 2980")
}

// 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 = &C::xmm_mem_as_xmm_mem_128(ctx, v3);
        let v5 = constructor_x64_psllq_a_or_avx(ctx, arg0, v4);
        // Rule at src/isa/x64/inst.isle line 2985.
        return v5;
    }
    let v6 = C::is_imm8_xmm(ctx, arg1);
    if let Some(v7) = v6 {
        let v8 = constructor_x64_psllq_b_or_avx(ctx, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 2986.
        return v8;
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_psllq", "src/isa/x64/inst.isle line 2984")
}

// 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 = &C::xmm_mem_as_xmm_mem_128(ctx, v3);
        let v5 = constructor_x64_psrlw_a_or_avx(ctx, arg0, v4);
        // Rule at src/isa/x64/inst.isle line 2989.
        return v5;
    }
    let v6 = C::is_imm8_xmm(ctx, arg1);
    if let Some(v7) = v6 {
        let v8 = constructor_x64_psrlw_b_or_avx(ctx, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 2990.
        return v8;
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_psrlw", "src/isa/x64/inst.isle line 2988")
}

// 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 = &C::xmm_mem_as_xmm_mem_128(ctx, v3);
        let v5 = constructor_x64_psrld_a_or_avx(ctx, arg0, v4);
        // Rule at src/isa/x64/inst.isle line 2993.
        return v5;
    }
    let v6 = C::is_imm8_xmm(ctx, arg1);
    if let Some(v7) = v6 {
        let v8 = constructor_x64_psrld_b_or_avx(ctx, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 2994.
        return v8;
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_psrld", "src/isa/x64/inst.isle line 2992")
}

// 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 = &C::xmm_mem_as_xmm_mem_128(ctx, v3);
        let v5 = constructor_x64_psrlq_a_or_avx(ctx, arg0, v4);
        // Rule at src/isa/x64/inst.isle line 2997.
        return v5;
    }
    let v6 = C::is_imm8_xmm(ctx, arg1);
    if let Some(v7) = v6 {
        let v8 = constructor_x64_psrlq_b_or_avx(ctx, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 2998.
        return v8;
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_psrlq", "src/isa/x64/inst.isle line 2996")
}

// 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 = &C::xmm_mem_as_xmm_mem_128(ctx, v3);
        let v5 = constructor_x64_psraw_a_or_avx(ctx, arg0, v4);
        // Rule at src/isa/x64/inst.isle line 3001.
        return v5;
    }
    let v6 = C::is_imm8_xmm(ctx, arg1);
    if let Some(v7) = v6 {
        let v8 = constructor_x64_psraw_b_or_avx(ctx, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 3002.
        return v8;
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_psraw", "src/isa/x64/inst.isle line 3000")
}

// 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 = &C::xmm_mem_as_xmm_mem_128(ctx, v3);
        let v5 = constructor_x64_psrad_a_or_avx(ctx, arg0, v4);
        // Rule at src/isa/x64/inst.isle line 3005.
        return v5;
    }
    let v6 = C::is_imm8_xmm(ctx, arg1);
    if let Some(v7) = v6 {
        let v8 = constructor_x64_psrad_b_or_avx(ctx, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 3006.
        return v8;
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_psrad", "src/isa/x64/inst.isle line 3004")
}

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

// Generated as internal constructor for term x64_vpsraq_imm.
pub fn constructor_x64_vpsraq_imm<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem128,
    arg1: u8,
) -> Xmm {
    let v2 = constructor_x64_vpsraq_f(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 3014.
    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 3018.
    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 3021.
    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 3024.
    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 3027.
    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 3030.
    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 3033.
    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 3036.
    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 3039.
    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 3044.
        return v3;
    }
    let v1 = constructor_x64_pmovmskb_rm(ctx, arg0);
    // Rule at src/isa/x64/inst.isle line 3043.
    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 3051.
        return v3;
    }
    let v1 = constructor_x64_movmskps_rm(ctx, arg0);
    // Rule at src/isa/x64/inst.isle line 3050.
    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 3058.
        return v3;
    }
    let v1 = constructor_x64_movmskpd_rm(ctx, arg0);
    // Rule at src/isa/x64/inst.isle line 3057.
    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 3064.
            return v2;
        }
        I16 => {
            let v3 = constructor_x64_notw_m(ctx, arg1);
            // Rule at src/isa/x64/inst.isle line 3065.
            return v3;
        }
        I32 => {
            let v4 = constructor_x64_notl_m(ctx, arg1);
            // Rule at src/isa/x64/inst.isle line 3066.
            return v4;
        }
        I64 => {
            let v5 = constructor_x64_notq_m(ctx, arg1);
            // Rule at src/isa/x64/inst.isle line 3067.
            return v5;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_not", "src/isa/x64/inst.isle line 3063")
}

// 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_8(ctx, arg1);
            let v3 = &C::x64_negb_m_raw(ctx, v2);
            // Rule at src/isa/x64/inst.isle line 3071.
            return v3.clone();
        }
        I16 => {
            let v4 = &C::gpr_to_gpr_mem_16(ctx, arg1);
            let v5 = &C::x64_negw_m_raw(ctx, v4);
            // Rule at src/isa/x64/inst.isle line 3072.
            return v5.clone();
        }
        I32 => {
            let v6 = &C::gpr_to_gpr_mem_32(ctx, arg1);
            let v7 = &C::x64_negl_m_raw(ctx, v6);
            // Rule at src/isa/x64/inst.isle line 3073.
            return v7.clone();
        }
        I64 => {
            let v8 = &C::gpr_to_gpr_mem_64(ctx, arg1);
            let v9 = &C::x64_negq_m_raw(ctx, v8);
            // Rule at src/isa/x64/inst.isle line 3074.
            return v9.clone();
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_neg_raw", "src/isa/x64/inst.isle line 3070")
}

// 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 3077.
    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 3081.
    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 3088.
            return v2;
        }
        I32 => {
            let v3 = constructor_x64_leal_rm(ctx, arg1);
            // Rule at src/isa/x64/inst.isle line 3089.
            return v3;
        }
        I64 => {
            let v4 = constructor_x64_leaq_rm(ctx, arg1);
            // Rule at src/isa/x64/inst.isle line 3090.
            return v4;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_lea", "src/isa/x64/inst.isle line 3087")
}

// 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 = &C::gpr_mem_16_for_ty(ctx, arg0, arg1);
            let v3 = constructor_x64_lzcntw_rm(ctx, v2);
            // Rule at src/isa/x64/inst.isle line 3094.
            return v3;
        }
        I32 => {
            let v4 = &C::gpr_mem_32_for_ty(ctx, arg0, arg1);
            let v5 = constructor_x64_lzcntl_rm(ctx, v4);
            // Rule at src/isa/x64/inst.isle line 3095.
            return v5;
        }
        I64 => {
            let v6 = &C::gpr_mem_64_for_ty(ctx, arg0, arg1);
            let v7 = constructor_x64_lzcntq_rm(ctx, v6);
            // Rule at src/isa/x64/inst.isle line 3096.
            return v7;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_lzcnt", "src/isa/x64/inst.isle line 3093")
}

// 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 = &C::gpr_mem_16_for_ty(ctx, arg0, arg1);
            let v3 = constructor_x64_tzcntw_a(ctx, v2);
            // Rule at src/isa/x64/inst.isle line 3100.
            return v3;
        }
        I32 => {
            let v4 = &C::gpr_mem_32_for_ty(ctx, arg0, arg1);
            let v5 = constructor_x64_tzcntl_a(ctx, v4);
            // Rule at src/isa/x64/inst.isle line 3101.
            return v5;
        }
        I64 => {
            let v6 = &C::gpr_mem_64_for_ty(ctx, arg0, arg1);
            let v7 = constructor_x64_tzcntq_a(ctx, v6);
            // Rule at src/isa/x64/inst.isle line 3102.
            return v7;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_tzcnt", "src/isa/x64/inst.isle line 3099")
}

// 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::gpr_mem_16_for_ty(ctx, arg0, arg1);
            let v3 = &C::x64_bsrw_rm_raw(ctx, v2);
            let v4 = &constructor_asm_produce_flags(ctx, v3);
            // Rule at src/isa/x64/inst.isle line 3106.
            return v4.clone();
        }
        I32 => {
            let v5 = &C::gpr_mem_32_for_ty(ctx, arg0, arg1);
            let v6 = &C::x64_bsrl_rm_raw(ctx, v5);
            let v7 = &constructor_asm_produce_flags(ctx, v6);
            // Rule at src/isa/x64/inst.isle line 3107.
            return v7.clone();
        }
        I64 => {
            let v8 = &C::gpr_mem_64_for_ty(ctx, arg0, arg1);
            let v9 = &C::x64_bsrq_rm_raw(ctx, v8);
            let v10 = &constructor_asm_produce_flags(ctx, v9);
            // Rule at src/isa/x64/inst.isle line 3108.
            return v10.clone();
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_bsr", "src/isa/x64/inst.isle line 3105")
}

// 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 3113.
    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::gpr_mem_16_for_ty(ctx, arg0, arg1);
            let v3 = &C::x64_bsfw_rm_raw(ctx, v2);
            let v4 = &constructor_asm_produce_flags(ctx, v3);
            // Rule at src/isa/x64/inst.isle line 3124.
            return v4.clone();
        }
        I32 => {
            let v5 = &C::gpr_mem_32_for_ty(ctx, arg0, arg1);
            let v6 = &C::x64_bsfl_rm_raw(ctx, v5);
            let v7 = &constructor_asm_produce_flags(ctx, v6);
            // Rule at src/isa/x64/inst.isle line 3125.
            return v7.clone();
        }
        I64 => {
            let v8 = &C::gpr_mem_64_for_ty(ctx, arg0, arg1);
            let v9 = &C::x64_bsfq_rm_raw(ctx, v8);
            let v10 = &constructor_asm_produce_flags(ctx, v9);
            // Rule at src/isa/x64/inst.isle line 3126.
            return v10.clone();
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_bsf", "src/isa/x64/inst.isle line 3123")
}

// 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 3131.
    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 = &C::gpr_mem_32_for_ty(ctx, arg0, arg1);
            let v3 = constructor_x64_blsil_vm(ctx, v2);
            // Rule at src/isa/x64/inst.isle line 3142.
            return v3;
        }
        I64 => {
            let v4 = &C::gpr_mem_64_for_ty(ctx, arg0, arg1);
            let v5 = constructor_x64_blsiq_vm(ctx, v4);
            // Rule at src/isa/x64/inst.isle line 3143.
            return v5;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_blsi", "src/isa/x64/inst.isle line 3141")
}

// 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 = &C::gpr_mem_32_for_ty(ctx, arg0, arg1);
            let v3 = constructor_x64_blsmskl_vm(ctx, v2);
            // Rule at src/isa/x64/inst.isle line 3147.
            return v3;
        }
        I64 => {
            let v4 = &C::gpr_mem_64_for_ty(ctx, arg0, arg1);
            let v5 = constructor_x64_blsmskq_vm(ctx, v4);
            // Rule at src/isa/x64/inst.isle line 3148.
            return v5;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_blsmsk", "src/isa/x64/inst.isle line 3146")
}

// 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 = &C::gpr_mem_32_for_ty(ctx, arg0, arg1);
            let v3 = constructor_x64_blsrl_vm(ctx, v2);
            // Rule at src/isa/x64/inst.isle line 3152.
            return v3;
        }
        I64 => {
            let v4 = &C::gpr_mem_64_for_ty(ctx, arg0, arg1);
            let v5 = constructor_x64_blsrq_vm(ctx, v4);
            // Rule at src/isa/x64/inst.isle line 3153.
            return v5;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_blsr", "src/isa/x64/inst.isle line 3151")
}

// 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 = &C::gpr_mem_16_for_ty(ctx, arg0, arg1);
            let v4 = &constructor_x64_btw_mr(ctx, v3, arg2);
            // Rule at src/isa/x64/inst.isle line 3157.
            return v4.clone();
        }
        I32 => {
            let v5 = &C::gpr_mem_32_for_ty(ctx, arg0, arg1);
            let v6 = &constructor_x64_btl_mr(ctx, v5, arg2);
            // Rule at src/isa/x64/inst.isle line 3158.
            return v6.clone();
        }
        I64 => {
            let v7 = &C::gpr_mem_64_for_ty(ctx, arg0, arg1);
            let v8 = &constructor_x64_btq_mr(ctx, v7, arg2);
            // Rule at src/isa/x64/inst.isle line 3159.
            return v8.clone();
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_bt", "src/isa/x64/inst.isle line 3156")
}

// 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 = &C::gpr_mem_16_for_ty(ctx, arg0, arg1);
            let v4 = &constructor_x64_btw_mi(ctx, v3, arg2);
            // Rule at src/isa/x64/inst.isle line 3163.
            return v4.clone();
        }
        I32 => {
            let v5 = &C::gpr_mem_32_for_ty(ctx, arg0, arg1);
            let v6 = &constructor_x64_btl_mi(ctx, v5, arg2);
            // Rule at src/isa/x64/inst.isle line 3164.
            return v6.clone();
        }
        I64 => {
            let v7 = &C::gpr_mem_64_for_ty(ctx, arg0, arg1);
            let v8 = &constructor_x64_btq_mi(ctx, v7, arg2);
            // Rule at src/isa/x64/inst.isle line 3165.
            return v8.clone();
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_bt_imm", "src/isa/x64/inst.isle line 3162")
}

// 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 = &C::gpr_mem_32_for_ty(ctx, arg0, arg1);
            let v4 = constructor_x64_sarxl_rmv(ctx, v3, arg2);
            // Rule at src/isa/x64/inst.isle line 3169.
            return v4;
        }
        I64 => {
            let v5 = &C::gpr_mem_64_for_ty(ctx, arg0, arg1);
            let v6 = constructor_x64_sarxq_rmv(ctx, v5, arg2);
            // Rule at src/isa/x64/inst.isle line 3170.
            return v6;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_sarx", "src/isa/x64/inst.isle line 3168")
}

// 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 = &C::gpr_mem_32_for_ty(ctx, arg0, arg1);
            let v4 = constructor_x64_shrxl_rmv(ctx, v3, arg2);
            // Rule at src/isa/x64/inst.isle line 3174.
            return v4;
        }
        I64 => {
            let v5 = &C::gpr_mem_64_for_ty(ctx, arg0, arg1);
            let v6 = constructor_x64_shrxq_rmv(ctx, v5, arg2);
            // Rule at src/isa/x64/inst.isle line 3175.
            return v6;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_shrx", "src/isa/x64/inst.isle line 3173")
}

// 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 = &C::gpr_mem_32_for_ty(ctx, arg0, arg1);
            let v4 = constructor_x64_shlxl_rmv(ctx, v3, arg2);
            // Rule at src/isa/x64/inst.isle line 3179.
            return v4;
        }
        I64 => {
            let v5 = &C::gpr_mem_64_for_ty(ctx, arg0, arg1);
            let v6 = constructor_x64_shlxq_rmv(ctx, v5, arg2);
            // Rule at src/isa/x64/inst.isle line 3180.
            return v6;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_shlx", "src/isa/x64/inst.isle line 3178")
}

// 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 = &C::gpr_mem_32_for_ty(ctx, arg0, arg1);
            let v4 = constructor_x64_rorxl_rmi(ctx, v3, arg2);
            // Rule at src/isa/x64/inst.isle line 3184.
            return v4;
        }
        I64 => {
            let v5 = &C::gpr_mem_64_for_ty(ctx, arg0, arg1);
            let v6 = constructor_x64_rorxq_rmi(ctx, v5, arg2);
            // Rule at src/isa/x64/inst.isle line 3185.
            return v6;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_rorx", "src/isa/x64/inst.isle line 3183")
}

// 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 = &C::gpr_mem_16_for_ty(ctx, arg0, arg1);
            let v3 = constructor_x64_popcntw_rm(ctx, v2);
            // Rule at src/isa/x64/inst.isle line 3189.
            return v3;
        }
        I32 => {
            let v4 = &C::gpr_mem_32_for_ty(ctx, arg0, arg1);
            let v5 = constructor_x64_popcntl_rm(ctx, v4);
            // Rule at src/isa/x64/inst.isle line 3190.
            return v5;
        }
        I64 => {
            let v6 = &C::gpr_mem_64_for_ty(ctx, arg0, arg1);
            let v7 = constructor_x64_popcntq_rm(ctx, v6);
            // Rule at src/isa/x64/inst.isle line 3191.
            return v7;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_popcnt", "src/isa/x64/inst.isle line 3188")
}

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

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

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

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

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

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

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

// Generated as internal constructor for term x64_maxpd.
pub fn constructor_x64_maxpd<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem128,
) -> Xmm {
    let v2 = constructor_x64_maxpd_a_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 3217.
    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: Value,
) -> Xmm {
    match arg0 {
        F32 => {
            let v4 = &C::put_in_xmm_mem_32(ctx, arg3);
            let v5 = constructor_x64_vfmadd213_f32(ctx, arg1, arg2, v4);
            // Rule at src/isa/x64/inst.isle line 3223.
            return v5;
        }
        F64 => {
            let v6 = &C::put_in_xmm_mem_64(ctx, arg3);
            let v7 = constructor_x64_vfmadd213_f64(ctx, arg1, arg2, v6);
            // Rule at src/isa/x64/inst.isle line 3224.
            return v7;
        }
        F32X4 => {
            let v8 = &C::put_in_xmm_mem_128(ctx, arg3);
            let v9 = constructor_x64_vfmadd213_f32x4(ctx, arg1, arg2, v8);
            // Rule at src/isa/x64/inst.isle line 3225.
            return v9;
        }
        F64X2 => {
            let v8 = &C::put_in_xmm_mem_128(ctx, arg3);
            let v10 = constructor_x64_vfmadd213_f64x2(ctx, arg1, arg2, v8);
            // Rule at src/isa/x64/inst.isle line 3226.
            return v10;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_vfmadd213", "src/isa/x64/inst.isle line 3222")
}

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

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

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

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

// 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: Value,
) -> Xmm {
    match arg0 {
        F32 => {
            let v4 = &C::put_in_xmm_mem_32(ctx, arg3);
            let v5 = constructor_x64_vfmadd132_f32(ctx, arg1, arg2, v4);
            // Rule at src/isa/x64/inst.isle line 3239.
            return v5;
        }
        F64 => {
            let v6 = &C::put_in_xmm_mem_64(ctx, arg3);
            let v7 = constructor_x64_vfmadd132_f64(ctx, arg1, arg2, v6);
            // Rule at src/isa/x64/inst.isle line 3240.
            return v7;
        }
        F32X4 => {
            let v8 = &C::put_in_xmm_mem_128(ctx, arg3);
            let v9 = constructor_x64_vfmadd132_f32x4(ctx, arg1, arg2, v8);
            // Rule at src/isa/x64/inst.isle line 3241.
            return v9;
        }
        F64X2 => {
            let v8 = &C::put_in_xmm_mem_128(ctx, arg3);
            let v10 = constructor_x64_vfmadd132_f64x2(ctx, arg1, arg2, v8);
            // Rule at src/isa/x64/inst.isle line 3242.
            return v10;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_vfmadd132", "src/isa/x64/inst.isle line 3238")
}

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

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

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

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

// 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: Value,
) -> Xmm {
    match arg0 {
        F32 => {
            let v4 = &C::put_in_xmm_mem_32(ctx, arg3);
            let v5 = constructor_x64_vfnmadd213_f32(ctx, arg1, arg2, v4);
            // Rule at src/isa/x64/inst.isle line 3255.
            return v5;
        }
        F64 => {
            let v6 = &C::put_in_xmm_mem_64(ctx, arg3);
            let v7 = constructor_x64_vfnmadd213_f64(ctx, arg1, arg2, v6);
            // Rule at src/isa/x64/inst.isle line 3256.
            return v7;
        }
        F32X4 => {
            let v8 = &C::put_in_xmm_mem_128(ctx, arg3);
            let v9 = constructor_x64_vfnmadd213_f32x4(ctx, arg1, arg2, v8);
            // Rule at src/isa/x64/inst.isle line 3257.
            return v9;
        }
        F64X2 => {
            let v8 = &C::put_in_xmm_mem_128(ctx, arg3);
            let v10 = constructor_x64_vfnmadd213_f64x2(ctx, arg1, arg2, v8);
            // Rule at src/isa/x64/inst.isle line 3258.
            return v10;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_vfnmadd213", "src/isa/x64/inst.isle line 3254")
}

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

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

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

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

// 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: Value,
) -> Xmm {
    match arg0 {
        F32 => {
            let v4 = &C::put_in_xmm_mem_32(ctx, arg3);
            let v5 = constructor_x64_vfnmadd132_f32(ctx, arg1, arg2, v4);
            // Rule at src/isa/x64/inst.isle line 3271.
            return v5;
        }
        F64 => {
            let v6 = &C::put_in_xmm_mem_64(ctx, arg3);
            let v7 = constructor_x64_vfnmadd132_f64(ctx, arg1, arg2, v6);
            // Rule at src/isa/x64/inst.isle line 3272.
            return v7;
        }
        F32X4 => {
            let v8 = &C::put_in_xmm_mem_128(ctx, arg3);
            let v9 = constructor_x64_vfnmadd132_f32x4(ctx, arg1, arg2, v8);
            // Rule at src/isa/x64/inst.isle line 3273.
            return v9;
        }
        F64X2 => {
            let v8 = &C::put_in_xmm_mem_128(ctx, arg3);
            let v10 = constructor_x64_vfnmadd132_f64x2(ctx, arg1, arg2, v8);
            // Rule at src/isa/x64/inst.isle line 3274.
            return v10;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_vfnmadd132", "src/isa/x64/inst.isle line 3270")
}

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

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

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

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

// 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: Value,
) -> Xmm {
    match arg0 {
        F32 => {
            let v4 = &C::put_in_xmm_mem_32(ctx, arg3);
            let v5 = constructor_x64_vfmsub213_f32(ctx, arg1, arg2, v4);
            // Rule at src/isa/x64/inst.isle line 3287.
            return v5;
        }
        F64 => {
            let v6 = &C::put_in_xmm_mem_64(ctx, arg3);
            let v7 = constructor_x64_vfmsub213_f64(ctx, arg1, arg2, v6);
            // Rule at src/isa/x64/inst.isle line 3288.
            return v7;
        }
        F32X4 => {
            let v8 = &C::put_in_xmm_mem_128(ctx, arg3);
            let v9 = constructor_x64_vfmsub213_f32x4(ctx, arg1, arg2, v8);
            // Rule at src/isa/x64/inst.isle line 3289.
            return v9;
        }
        F64X2 => {
            let v8 = &C::put_in_xmm_mem_128(ctx, arg3);
            let v10 = constructor_x64_vfmsub213_f64x2(ctx, arg1, arg2, v8);
            // Rule at src/isa/x64/inst.isle line 3290.
            return v10;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_vfmsub213", "src/isa/x64/inst.isle line 3286")
}

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

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

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

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

// 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: Value,
) -> Xmm {
    match arg0 {
        F32 => {
            let v4 = &C::put_in_xmm_mem_32(ctx, arg3);
            let v5 = constructor_x64_vfmsub132_f32(ctx, arg1, arg2, v4);
            // Rule at src/isa/x64/inst.isle line 3303.
            return v5;
        }
        F64 => {
            let v6 = &C::put_in_xmm_mem_64(ctx, arg3);
            let v7 = constructor_x64_vfmsub132_f64(ctx, arg1, arg2, v6);
            // Rule at src/isa/x64/inst.isle line 3304.
            return v7;
        }
        F32X4 => {
            let v8 = &C::put_in_xmm_mem_128(ctx, arg3);
            let v9 = constructor_x64_vfmsub132_f32x4(ctx, arg1, arg2, v8);
            // Rule at src/isa/x64/inst.isle line 3305.
            return v9;
        }
        F64X2 => {
            let v8 = &C::put_in_xmm_mem_128(ctx, arg3);
            let v10 = constructor_x64_vfmsub132_f64x2(ctx, arg1, arg2, v8);
            // Rule at src/isa/x64/inst.isle line 3306.
            return v10;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_vfmsub132", "src/isa/x64/inst.isle line 3302")
}

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

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

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

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

// 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: Value,
) -> Xmm {
    match arg0 {
        F32 => {
            let v4 = &C::put_in_xmm_mem_32(ctx, arg3);
            let v5 = constructor_x64_vfnmsub213_f32(ctx, arg1, arg2, v4);
            // Rule at src/isa/x64/inst.isle line 3319.
            return v5;
        }
        F64 => {
            let v6 = &C::put_in_xmm_mem_64(ctx, arg3);
            let v7 = constructor_x64_vfnmsub213_f64(ctx, arg1, arg2, v6);
            // Rule at src/isa/x64/inst.isle line 3320.
            return v7;
        }
        F32X4 => {
            let v8 = &C::put_in_xmm_mem_128(ctx, arg3);
            let v9 = constructor_x64_vfnmsub213_f32x4(ctx, arg1, arg2, v8);
            // Rule at src/isa/x64/inst.isle line 3321.
            return v9;
        }
        F64X2 => {
            let v8 = &C::put_in_xmm_mem_128(ctx, arg3);
            let v10 = constructor_x64_vfnmsub213_f64x2(ctx, arg1, arg2, v8);
            // Rule at src/isa/x64/inst.isle line 3322.
            return v10;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_vfnmsub213", "src/isa/x64/inst.isle line 3318")
}

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

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

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

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

// 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: Value,
) -> Xmm {
    match arg0 {
        F32 => {
            let v4 = &C::put_in_xmm_mem_32(ctx, arg3);
            let v5 = constructor_x64_vfnmsub132_f32(ctx, arg1, arg2, v4);
            // Rule at src/isa/x64/inst.isle line 3335.
            return v5;
        }
        F64 => {
            let v6 = &C::put_in_xmm_mem_64(ctx, arg3);
            let v7 = constructor_x64_vfnmsub132_f64(ctx, arg1, arg2, v6);
            // Rule at src/isa/x64/inst.isle line 3336.
            return v7;
        }
        F32X4 => {
            let v8 = &C::put_in_xmm_mem_128(ctx, arg3);
            let v9 = constructor_x64_vfnmsub132_f32x4(ctx, arg1, arg2, v8);
            // Rule at src/isa/x64/inst.isle line 3337.
            return v9;
        }
        F64X2 => {
            let v8 = &C::put_in_xmm_mem_128(ctx, arg3);
            let v10 = constructor_x64_vfnmsub132_f64x2(ctx, arg1, arg2, v8);
            // Rule at src/isa/x64/inst.isle line 3338.
            return v10;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_vfnmsub132", "src/isa/x64/inst.isle line 3334")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// Generated as internal constructor for term x64_cvtss2sd.
pub fn constructor_x64_cvtss2sd<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem32,
) -> 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 3409.
        return v3;
    }
    let v4 = constructor_x64_cvtss2sd_a(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 3412.
    return v4;
}

// Generated as internal constructor for term x64_cvtsd2ss.
pub fn constructor_x64_cvtsd2ss<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem64,
) -> 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 3418.
        return v3;
    }
    let v4 = constructor_x64_cvtsd2ss_a(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 3421.
    return v4;
}

// Generated as internal constructor for term x64_cvtdq2ps.
pub fn constructor_x64_cvtdq2ps<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem128,
) -> 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 3425.
        return v2;
    }
    let v3 = &C::xmm_mem_128_to_xmm_mem_aligned_128(ctx, arg0);
    let v4 = constructor_x64_cvtdq2ps_a(ctx, v3);
    // Rule at src/isa/x64/inst.isle line 3428.
    return v4;
}

// Generated as internal constructor for term x64_cvtps2pd.
pub fn constructor_x64_cvtps2pd<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem64,
) -> 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 3432.
        return v2;
    }
    let v3 = constructor_x64_cvtps2pd_a(ctx, arg0);
    // Rule at src/isa/x64/inst.isle line 3435.
    return v3;
}

// Generated as internal constructor for term x64_cvtpd2ps.
pub fn constructor_x64_cvtpd2ps<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem128,
) -> 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 3439.
        return v2;
    }
    let v3 = &C::xmm_mem_128_to_xmm_mem_aligned_128(ctx, arg0);
    let v4 = constructor_x64_cvtpd2ps_a(ctx, v3);
    // Rule at src/isa/x64/inst.isle line 3442.
    return v4;
}

// Generated as internal constructor for term x64_cvtdq2pd.
pub fn constructor_x64_cvtdq2pd<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem64,
) -> 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 3446.
        return v2;
    }
    let v3 = constructor_x64_cvtdq2pd_a(ctx, arg0);
    // Rule at src/isa/x64/inst.isle line 3449.
    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 = &C::gpr_mem_32_for_ty(ctx, arg0, arg2);
                let v5 = constructor_x64_vcvtsi2ssl_b(ctx, arg1, v4);
                // Rule at src/isa/x64/inst.isle line 3453.
                return v5;
            }
            let v4 = &C::gpr_mem_32_for_ty(ctx, arg0, arg2);
            let v8 = constructor_x64_cvtsi2ssl_a(ctx, arg1, v4);
            // Rule at src/isa/x64/inst.isle line 3459.
            return v8;
        }
        I64 => {
            let v3 = C::has_avx(ctx);
            if v3 == true {
                let v6 = &C::gpr_mem_64_for_ty(ctx, arg0, arg2);
                let v7 = constructor_x64_vcvtsi2ssq_b(ctx, arg1, v6);
                // Rule at src/isa/x64/inst.isle line 3456.
                return v7;
            }
            let v6 = &C::gpr_mem_64_for_ty(ctx, arg0, arg2);
            let v9 = constructor_x64_cvtsi2ssq_a(ctx, arg1, v6);
            // Rule at src/isa/x64/inst.isle line 3460.
            return v9;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_cvtsi2ss", "src/isa/x64/inst.isle line 3452")
}

// 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 = &C::gpr_mem_32_for_ty(ctx, arg0, arg2);
                let v5 = constructor_x64_vcvtsi2sdl_b(ctx, arg1, v4);
                // Rule at src/isa/x64/inst.isle line 3464.
                return v5;
            }
            let v4 = &C::gpr_mem_32_for_ty(ctx, arg0, arg2);
            let v8 = constructor_x64_cvtsi2sdl_a(ctx, arg1, v4);
            // Rule at src/isa/x64/inst.isle line 3470.
            return v8;
        }
        I64 => {
            let v3 = C::has_avx(ctx);
            if v3 == true {
                let v6 = &C::gpr_mem_64_for_ty(ctx, arg0, arg2);
                let v7 = constructor_x64_vcvtsi2sdq_b(ctx, arg1, v6);
                // Rule at src/isa/x64/inst.isle line 3467.
                return v7;
            }
            let v6 = &C::gpr_mem_64_for_ty(ctx, arg0, arg2);
            let v9 = constructor_x64_cvtsi2sdq_a(ctx, arg1, v6);
            // Rule at src/isa/x64/inst.isle line 3471.
            return v9;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_cvtsi2sd", "src/isa/x64/inst.isle line 3463")
}

// Generated as internal constructor for term x64_cvttps2dq.
pub fn constructor_x64_cvttps2dq<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem128,
) -> 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 3475.
        return v2;
    }
    let v3 = &C::xmm_mem_128_to_xmm_mem_aligned_128(ctx, arg0);
    let v4 = constructor_x64_cvttps2dq_a(ctx, v3);
    // Rule at src/isa/x64/inst.isle line 3478.
    return v4;
}

// Generated as internal constructor for term x64_cvttpd2dq.
pub fn constructor_x64_cvttpd2dq<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem128,
) -> 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 3482.
        return v2;
    }
    let v3 = &C::xmm_mem_128_to_xmm_mem_aligned_128(ctx, arg0);
    let v4 = constructor_x64_cvttpd2dq_a(ctx, v3);
    // Rule at src/isa/x64/inst.isle line 3485.
    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: &XmmMem128,
) -> Xmm {
    match arg0 {
        I8X16 => {
            let v3 = constructor_x64_pcmpeqb(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 3490.
            return v3;
        }
        I16X8 => {
            let v4 = constructor_x64_pcmpeqw(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 3491.
            return v4;
        }
        I32X4 => {
            let v5 = constructor_x64_pcmpeqd(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 3492.
            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 3493.
                return v7;
            }
            let v5 = constructor_x64_pcmpeqd(ctx, arg1, arg2);
            let v8 = &C::xmm_to_xmm_mem_128(ctx, v5);
            let v10 = constructor_x64_pshufd(ctx, v8, 0xb1_u8);
            let v11 = &C::xmm_to_xmm_mem_128(ctx, v10);
            let v12 = constructor_x64_pand(ctx, v5, v11);
            // Rule at src/isa/x64/inst.isle line 3502.
            return v12;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_pcmpeq", "src/isa/x64/inst.isle line 3489")
}

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

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

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

// Generated as internal constructor for term x64_pcmpeqq.
pub fn constructor_x64_pcmpeqq<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem128,
) -> Xmm {
    let v2 = constructor_x64_pcmpeqq_a_or_avx(ctx, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 3518.
    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: &XmmMem128,
) -> Xmm {
    match arg0 {
        I8X16 => {
            let v3 = constructor_x64_pcmpgtb_a_or_avx(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 3523.
            return v3;
        }
        I16X8 => {
            let v4 = constructor_x64_pcmpgtw_a_or_avx(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 3524.
            return v4;
        }
        I32X4 => {
            let v5 = constructor_x64_pcmpgtd_a_or_avx(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 3525.
            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 3529.
                return v7;
            }
            let v8 = C::use_sse42(ctx);
            if v8 == true {
                let v9 = &C::xmm_mem_128_to_xmm_mem_aligned_128(ctx, arg2);
                let v10 = constructor_x64_pcmpgtq_a(ctx, arg1, v9);
                // Rule at src/isa/x64/inst.isle line 3534.
                return v10;
            }
            let v12 = &constructor_emit_xmm_mem_128_le_const(ctx, 0x800000000000000080000000_u128);
            let v13 = constructor_x64_movdqu_load(ctx, v12);
            let v14 = &C::xmm_to_xmm_mem_128(ctx, arg1);
            let v15 = constructor_x64_pxor(ctx, v13, v14);
            let v16 = constructor_x64_pxor(ctx, v13, arg2);
            let v17 = &C::xmm_to_xmm_mem_aligned_128(ctx, v16);
            let v18 = constructor_x64_pcmpgtd_a(ctx, v15, v17);
            let v19 = &C::xmm_to_xmm_mem_128(ctx, v18);
            let v21 = constructor_x64_pshufd(ctx, v19, 0xa0_u8);
            let v22 = &C::xmm_to_xmm_mem_128(ctx, v18);
            let v24 = constructor_x64_pshufd(ctx, v22, 0xf5_u8);
            let v25 = &C::xmm_to_xmm_mem_128(ctx, v16);
            let v26 = constructor_x64_pcmpeqd(ctx, v15, v25);
            let v27 = &C::xmm_to_xmm_mem_128(ctx, v26);
            let v28 = constructor_x64_pshufd(ctx, v27, 0xf5_u8);
            let v29 = &C::xmm_to_xmm_mem_128(ctx, v28);
            let v30 = constructor_x64_pand(ctx, v21, v29);
            let v31 = &C::xmm_to_xmm_mem_128(ctx, v24);
            let v32 = constructor_x64_por(ctx, v30, v31);
            // Rule at src/isa/x64/inst.isle line 3563.
            return v32;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_pcmpgt", "src/isa/x64/inst.isle line 3522")
}

// 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 v13,
                    imm: v14,
                } = &v10.1 {
                    if let &Opcode::Iconst = v13 {
                        let v15 = C::u64_from_imm64(ctx, v14);
                        let v16 = C::u64_from_u8(ctx, v15);
                        if let Some(v17) = v16 {
                            let v18 = &constructor_x64_addb_mi_mem(ctx, arg1, v17);
                            // Rule at src/isa/x64/inst.isle line 3596.
                            return v18.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 3590.
            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 v13,
                    imm: v14,
                } = &v10.1 {
                    if let &Opcode::Iconst = v13 {
                        let v15 = C::u64_from_imm64(ctx, v14);
                        let v19 = C::u64_from_u16(ctx, v15);
                        if let Some(v20) = v19 {
                            let v21 = &constructor_x64_addw_mi_mem(ctx, arg1, v20);
                            // Rule at src/isa/x64/inst.isle line 3597.
                            return v21.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 3591.
            return v5.clone();
        }
        I32 => {
            let v25 = C::i64_from_iconst(ctx, arg2);
            if let Some(v26) = v25 {
                let v30 = C::i64_from_i8(ctx, v26);
                if let Some(v31) = v30 {
                    let v32 = &constructor_x64_addl_mi_sxb_mem(ctx, arg1, v31);
                    // Rule at src/isa/x64/inst.isle line 3600.
                    return v32.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 v13,
                    imm: v14,
                } = &v10.1 {
                    if let &Opcode::Iconst = v13 {
                        let v15 = C::u64_from_imm64(ctx, v14);
                        let v22 = C::u64_from_u32(ctx, v15);
                        if let Some(v23) = v22 {
                            let v24 = &constructor_x64_addl_mi_mem(ctx, arg1, v23);
                            // Rule at src/isa/x64/inst.isle line 3598.
                            return v24.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 3592.
            return v6.clone();
        }
        I64 => {
            let v25 = C::i64_from_iconst(ctx, arg2);
            if let Some(v26) = v25 {
                let v30 = C::i64_from_i8(ctx, v26);
                if let Some(v31) = v30 {
                    let v33 = &constructor_x64_addq_mi_sxb_mem(ctx, arg1, v31);
                    // Rule at src/isa/x64/inst.isle line 3601.
                    return v33.clone();
                }
                let v27 = C::i64_from_i32(ctx, v26);
                if let Some(v28) = v27 {
                    let v29 = &constructor_x64_addq_mi_sxl_mem(ctx, arg1, v28);
                    // Rule at src/isa/x64/inst.isle line 3599.
                    return v29.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 3593.
            return v7.clone();
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_add_mem", "src/isa/x64/inst.isle line 3577")
}

// 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 v13,
                    imm: v14,
                } = &v10.1 {
                    if let &Opcode::Iconst = v13 {
                        let v15 = C::u64_from_imm64(ctx, v14);
                        let v16 = C::u64_from_u8(ctx, v15);
                        if let Some(v17) = v16 {
                            let v18 = &constructor_x64_subb_mi_mem(ctx, arg1, v17);
                            // Rule at src/isa/x64/inst.isle line 3612.
                            return v18.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 3606.
            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 v13,
                    imm: v14,
                } = &v10.1 {
                    if let &Opcode::Iconst = v13 {
                        let v15 = C::u64_from_imm64(ctx, v14);
                        let v19 = C::u64_from_u16(ctx, v15);
                        if let Some(v20) = v19 {
                            let v21 = &constructor_x64_subw_mi_mem(ctx, arg1, v20);
                            // Rule at src/isa/x64/inst.isle line 3613.
                            return v21.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 3607.
            return v5.clone();
        }
        I32 => {
            let v25 = C::i64_from_iconst(ctx, arg2);
            if let Some(v26) = v25 {
                let v30 = C::i64_from_i8(ctx, v26);
                if let Some(v31) = v30 {
                    let v32 = &constructor_x64_subl_mi_sxb_mem(ctx, arg1, v31);
                    // Rule at src/isa/x64/inst.isle line 3616.
                    return v32.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 v13,
                    imm: v14,
                } = &v10.1 {
                    if let &Opcode::Iconst = v13 {
                        let v15 = C::u64_from_imm64(ctx, v14);
                        let v22 = C::u64_from_u32(ctx, v15);
                        if let Some(v23) = v22 {
                            let v24 = &constructor_x64_subl_mi_mem(ctx, arg1, v23);
                            // Rule at src/isa/x64/inst.isle line 3614.
                            return v24.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 3608.
            return v6.clone();
        }
        I64 => {
            let v25 = C::i64_from_iconst(ctx, arg2);
            if let Some(v26) = v25 {
                let v30 = C::i64_from_i8(ctx, v26);
                if let Some(v31) = v30 {
                    let v33 = &constructor_x64_subq_mi_sxb_mem(ctx, arg1, v31);
                    // Rule at src/isa/x64/inst.isle line 3617.
                    return v33.clone();
                }
                let v27 = C::i64_from_i32(ctx, v26);
                if let Some(v28) = v27 {
                    let v29 = &constructor_x64_subq_mi_sxl_mem(ctx, arg1, v28);
                    // Rule at src/isa/x64/inst.isle line 3615.
                    return v29.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 3609.
            return v7.clone();
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_sub_mem", "src/isa/x64/inst.isle line 3603")
}

// 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 v13,
                    imm: v14,
                } = &v10.1 {
                    if let &Opcode::Iconst = v13 {
                        let v15 = C::u64_from_imm64(ctx, v14);
                        let v16 = C::u64_from_u8(ctx, v15);
                        if let Some(v17) = v16 {
                            let v18 = &constructor_x64_andb_mi_mem(ctx, arg1, v17);
                            // Rule at src/isa/x64/inst.isle line 3630.
                            return v18.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 3622.
            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 v13,
                    imm: v14,
                } = &v10.1 {
                    if let &Opcode::Iconst = v13 {
                        let v15 = C::u64_from_imm64(ctx, v14);
                        let v19 = C::u64_from_u16(ctx, v15);
                        if let Some(v20) = v19 {
                            let v21 = &constructor_x64_andw_mi_mem(ctx, arg1, v20);
                            // Rule at src/isa/x64/inst.isle line 3631.
                            return v21.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 3623.
            return v5.clone();
        }
        I32 => {
            let v25 = C::i64_from_iconst(ctx, arg2);
            if let Some(v26) = v25 {
                let v30 = C::i64_from_i8(ctx, v26);
                if let Some(v31) = v30 {
                    let v32 = &constructor_x64_andl_mi_sxb_mem(ctx, arg1, v31);
                    // Rule at src/isa/x64/inst.isle line 3634.
                    return v32.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 v13,
                    imm: v14,
                } = &v10.1 {
                    if let &Opcode::Iconst = v13 {
                        let v15 = C::u64_from_imm64(ctx, v14);
                        let v22 = C::u64_from_u32(ctx, v15);
                        if let Some(v23) = v22 {
                            let v24 = &constructor_x64_andl_mi_mem(ctx, arg1, v23);
                            // Rule at src/isa/x64/inst.isle line 3632.
                            return v24.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 3624.
            return v6.clone();
        }
        I64 => {
            let v25 = C::i64_from_iconst(ctx, arg2);
            if let Some(v26) = v25 {
                let v30 = C::i64_from_i8(ctx, v26);
                if let Some(v31) = v30 {
                    let v33 = &constructor_x64_andq_mi_sxb_mem(ctx, arg1, v31);
                    // Rule at src/isa/x64/inst.isle line 3635.
                    return v33.clone();
                }
                let v27 = C::i64_from_i32(ctx, v26);
                if let Some(v28) = v27 {
                    let v29 = &constructor_x64_andq_mi_sxl_mem(ctx, arg1, v28);
                    // Rule at src/isa/x64/inst.isle line 3633.
                    return v29.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 3626.
            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 3625.
            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 3627.
            return v7.clone();
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_and_mem", "src/isa/x64/inst.isle line 3619")
}

// 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 v13,
                    imm: v14,
                } = &v10.1 {
                    if let &Opcode::Iconst = v13 {
                        let v15 = C::u64_from_imm64(ctx, v14);
                        let v16 = C::u64_from_u8(ctx, v15);
                        if let Some(v17) = v16 {
                            let v18 = &constructor_x64_orb_mi_mem(ctx, arg1, v17);
                            // Rule at src/isa/x64/inst.isle line 3648.
                            return v18.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 3640.
            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 v13,
                    imm: v14,
                } = &v10.1 {
                    if let &Opcode::Iconst = v13 {
                        let v15 = C::u64_from_imm64(ctx, v14);
                        let v19 = C::u64_from_u16(ctx, v15);
                        if let Some(v20) = v19 {
                            let v21 = &constructor_x64_orw_mi_mem(ctx, arg1, v20);
                            // Rule at src/isa/x64/inst.isle line 3649.
                            return v21.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 3641.
            return v5.clone();
        }
        I32 => {
            let v25 = C::i64_from_iconst(ctx, arg2);
            if let Some(v26) = v25 {
                let v30 = C::i64_from_i8(ctx, v26);
                if let Some(v31) = v30 {
                    let v32 = &constructor_x64_orl_mi_sxb_mem(ctx, arg1, v31);
                    // Rule at src/isa/x64/inst.isle line 3652.
                    return v32.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 v13,
                    imm: v14,
                } = &v10.1 {
                    if let &Opcode::Iconst = v13 {
                        let v15 = C::u64_from_imm64(ctx, v14);
                        let v22 = C::u64_from_u32(ctx, v15);
                        if let Some(v23) = v22 {
                            let v24 = &constructor_x64_orl_mi_mem(ctx, arg1, v23);
                            // Rule at src/isa/x64/inst.isle line 3650.
                            return v24.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 3642.
            return v6.clone();
        }
        I64 => {
            let v25 = C::i64_from_iconst(ctx, arg2);
            if let Some(v26) = v25 {
                let v30 = C::i64_from_i8(ctx, v26);
                if let Some(v31) = v30 {
                    let v33 = &constructor_x64_orq_mi_sxb_mem(ctx, arg1, v31);
                    // Rule at src/isa/x64/inst.isle line 3653.
                    return v33.clone();
                }
                let v27 = C::i64_from_i32(ctx, v26);
                if let Some(v28) = v27 {
                    let v29 = &constructor_x64_orq_mi_sxl_mem(ctx, arg1, v28);
                    // Rule at src/isa/x64/inst.isle line 3651.
                    return v29.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 3644.
            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 3643.
            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 3645.
            return v7.clone();
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_or_mem", "src/isa/x64/inst.isle line 3637")
}

// 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 v13,
                    imm: v14,
                } = &v10.1 {
                    if let &Opcode::Iconst = v13 {
                        let v15 = C::u64_from_imm64(ctx, v14);
                        let v16 = C::u64_from_u8(ctx, v15);
                        if let Some(v17) = v16 {
                            let v18 = &constructor_x64_xorb_mi_mem(ctx, arg1, v17);
                            // Rule at src/isa/x64/inst.isle line 3666.
                            return v18.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 3658.
            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 v13,
                    imm: v14,
                } = &v10.1 {
                    if let &Opcode::Iconst = v13 {
                        let v15 = C::u64_from_imm64(ctx, v14);
                        let v19 = C::u64_from_u16(ctx, v15);
                        if let Some(v20) = v19 {
                            let v21 = &constructor_x64_xorw_mi_mem(ctx, arg1, v20);
                            // Rule at src/isa/x64/inst.isle line 3667.
                            return v21.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 3659.
            return v5.clone();
        }
        I32 => {
            let v25 = C::i64_from_iconst(ctx, arg2);
            if let Some(v26) = v25 {
                let v30 = C::i64_from_i8(ctx, v26);
                if let Some(v31) = v30 {
                    let v32 = &constructor_x64_xorl_mi_sxb_mem(ctx, arg1, v31);
                    // Rule at src/isa/x64/inst.isle line 3670.
                    return v32.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 v13,
                    imm: v14,
                } = &v10.1 {
                    if let &Opcode::Iconst = v13 {
                        let v15 = C::u64_from_imm64(ctx, v14);
                        let v22 = C::u64_from_u32(ctx, v15);
                        if let Some(v23) = v22 {
                            let v24 = &constructor_x64_xorl_mi_mem(ctx, arg1, v23);
                            // Rule at src/isa/x64/inst.isle line 3668.
                            return v24.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 3660.
            return v6.clone();
        }
        I64 => {
            let v25 = C::i64_from_iconst(ctx, arg2);
            if let Some(v26) = v25 {
                let v30 = C::i64_from_i8(ctx, v26);
                if let Some(v31) = v30 {
                    let v33 = &constructor_x64_xorq_mi_sxb_mem(ctx, arg1, v31);
                    // Rule at src/isa/x64/inst.isle line 3671.
                    return v33.clone();
                }
                let v27 = C::i64_from_i32(ctx, v26);
                if let Some(v28) = v27 {
                    let v29 = &constructor_x64_xorq_mi_sxl_mem(ctx, arg1, v28);
                    // Rule at src/isa/x64/inst.isle line 3669.
                    return v29.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 3662.
            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 3661.
            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 3663.
            return v7.clone();
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_xor_mem", "src/isa/x64/inst.isle line 3655")
}

// 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 3675.
    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 3680.
    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 3685.
    return v4;
}

// Generated as internal constructor for term x64_movddup.
pub fn constructor_x64_movddup<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem64,
) -> 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 3691.
        return v3;
    }
    let v1 = constructor_x64_movddup_a(ctx, arg0);
    // Rule at src/isa/x64/inst.isle line 3690.
    return v1;
}

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

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

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

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

// 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 3713.
    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 3718.
    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 3723.
    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 3730.
            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 3732.
            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 3734.
            return v16.clone();
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "jmp_cond_result", "src/isa/x64/inst.isle line 3729")
}

// 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 3752.
    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 3795.
            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 3797.
            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 3796.
            return v10;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "cond_invert", "src/isa/x64/inst.isle line 3794")
}

// 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.1 {
            &InstructionData::Binary {
                opcode: ref v39,
                args: ref v40,
            } => {
                if let &Opcode::Band = v39 {
                    let v41 = C::unpack_value_array_2(ctx, v40);
                    let v44 = C::value_type(ctx, v41.0);
                    let v45 = C::ty_int(ctx, v44);
                    if let Some(v46) = v45 {
                        let v47 = C::fits_in_64(ctx, v46);
                        if let Some(v48) = v47 {
                            let v49 = &constructor_is_nonzero_band(ctx, v48, v41.0, v41.1);
                            // Rule at src/isa/x64/inst.isle line 3825.
                            return v49.clone();
                        }
                    }
                }
            }
            &InstructionData::Unary {
                opcode: ref v26,
                arg: v27,
            } => {
                match v26 {
                    &Opcode::VanyTrue => {
                        let v29 = &constructor_is_vany_true(ctx, v27);
                        // Rule at src/isa/x64/inst.isle line 3822.
                        return v29.clone();
                    }
                    &Opcode::VallTrue => {
                        let v28 = &constructor_is_vall_true(ctx, v27);
                        // Rule at src/isa/x64/inst.isle line 3821.
                        return v28.clone();
                    }
                    &Opcode::Uextend => {
                        let v30 = C::def_inst(ctx, v27);
                        if let Some(v31) = v30 {
                            let v32 = C::inst_data_value(ctx, v31);
                            if let &InstructionData::Unary {
                                opcode: ref v35,
                                arg: v36,
                            } = &v32.1 {
                                match v35 {
                                    &Opcode::VanyTrue => {
                                        let v38 = &constructor_is_vany_true(ctx, v36);
                                        // Rule at src/isa/x64/inst.isle line 3824.
                                        return v38.clone();
                                    }
                                    &Opcode::VallTrue => {
                                        let v37 = &constructor_is_vall_true(ctx, v36);
                                        // Rule at src/isa/x64/inst.isle line 3823.
                                        return v37.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 3812.
        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 3808.
                return v9;
            }
        }
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "is_nonzero", "src/isa/x64/inst.isle line 3805")
}

// 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.1 {
            &InstructionData::FloatCompare {
                opcode: ref v6,
                args: ref v7,
                cond: ref v8,
            } => {
                if let &Opcode::Fcmp = v6 {
                    let v9 = C::unpack_value_array_2(ctx, v7);
                    let v12 = &constructor_emit_fcmp(ctx, v8, v9.0, v9.1);
                    // Rule at src/isa/x64/inst.isle line 3834.
                    return v12.clone();
                }
            }
            &InstructionData::IntCompare {
                opcode: ref v13,
                args: ref v14,
                cond: ref v15,
            } => {
                if let &Opcode::Icmp = v13 {
                    let v16 = C::unpack_value_array_2(ctx, v14);
                    let v19 = &constructor_emit_cmp(ctx, v15, v16.0, v16.1);
                    // Rule at src/isa/x64/inst.isle line 3835.
                    return v19.clone();
                }
            }
            &InstructionData::Unary {
                opcode: ref v20,
                arg: v21,
            } => {
                if let &Opcode::Uextend = v20 {
                    let v22 = C::def_inst(ctx, v21);
                    if let Some(v23) = v22 {
                        let v24 = C::inst_data_value(ctx, v23);
                        match &v24.1 {
                            &InstructionData::FloatCompare {
                                opcode: ref v27,
                                args: ref v28,
                                cond: ref v29,
                            } => {
                                if let &Opcode::Fcmp = v27 {
                                    let v30 = C::unpack_value_array_2(ctx, v28);
                                    let v33 = &constructor_emit_fcmp(ctx, v29, v30.0, v30.1);
                                    // Rule at src/isa/x64/inst.isle line 3836.
                                    return v33.clone();
                                }
                            }
                            &InstructionData::IntCompare {
                                opcode: ref v34,
                                args: ref v35,
                                cond: ref v36,
                            } => {
                                if let &Opcode::Icmp = v34 {
                                    let v37 = C::unpack_value_array_2(ctx, v35);
                                    let v40 = &constructor_emit_cmp(ctx, v36, v37.0, v37.1);
                                    // Rule at src/isa/x64/inst.isle line 3837.
                                    return v40.clone();
                                }
                            }
                            _ => {}
                        }
                    }
                }
            }
            _ => {}
        }
    }
    let v41 = &constructor_is_nonzero(ctx, arg0);
    // Rule at src/isa/x64/inst.isle line 3838.
    return v41.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 v42 = C::i64_from_iconst(ctx, arg2);
    if let Some(v43) = v42 {
        let v44 = C::i64_from_i32(ctx, v43);
        if let Some(v45) = v44 {
            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 3864.
            return v7;
        }
    }
    let v10 = C::def_inst(ctx, arg2);
    if let Some(v11) = v10 {
        let v12 = C::inst_data_value(ctx, v11);
        match &v12.1 {
            &InstructionData::Binary {
                opcode: ref v15,
                args: ref v16,
            } => {
                if let &Opcode::Ishl = v15 {
                    let v8 = C::ty_32_or_64(ctx, arg0);
                    if let Some(v9) = v8 {
                        let v17 = C::unpack_value_array_2(ctx, v16);
                        let v20 = C::def_inst(ctx, v17.0);
                        if let Some(v21) = v20 {
                            let v22 = C::inst_data_value(ctx, v21);
                            if let &InstructionData::UnaryImm {
                                opcode: ref v25,
                                imm: v26,
                            } = &v22.1 {
                                if let &Opcode::Iconst = v25 {
                                    let v27 = C::u64_from_imm64(ctx, v26);
                                    if v27 == 0x1_u64 {
                                        let v3 = constructor_put_in_gpr(ctx, arg1);
                                        let v28 = &C::gpr_to_gpr_mem(ctx, v3);
                                        let v29 = constructor_put_in_gpr(ctx, v17.1);
                                        let v30 = &constructor_x64_bt(ctx, v9, v28, v29);
                                        let v32 = CondResult::CC {
                                            producer: v30.clone(),
                                            cc: CC::B,
                                        };
                                        // Rule at src/isa/x64/inst.isle line 3848.
                                        return v32;
                                    }
                                }
                            }
                        }
                    }
                }
            }
            &InstructionData::UnaryImm {
                opcode: ref v33,
                imm: v34,
            } => {
                if let &Opcode::Iconst = v33 {
                    if arg0 == I64 {
                        let v35 = C::u64_from_imm64(ctx, v34);
                        let v36 = C::bt_imm(ctx, v35);
                        if let Some(v37) = v36 {
                            let v39 = &constructor_put_in_gpr_mem(ctx, arg1);
                            let v40 = &constructor_x64_bt_imm(ctx, I64, v39, v37);
                            let v41 = CondResult::CC {
                                producer: v40.clone(),
                                cc: CC::B,
                            };
                            // Rule at src/isa/x64/inst.isle line 3853.
                            return v41;
                        }
                    }
                }
            }
            _ => {}
        }
    }
    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 3841.
    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 3875.
            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 3877.
            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 3885.
            return v30;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "lower_cond_bool", "src/isa/x64/inst.isle line 3874")
}

// 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 v30 = C::def_inst(ctx, arg1);
            if let Some(v31) = v30 {
                let v32 = C::inst_data_value(ctx, v31);
                if let &InstructionData::UnaryImm {
                    opcode: ref v35,
                    imm: v36,
                } = &v32.1 {
                    if let &Opcode::Iconst = v35 {
                        let v37 = C::u64_from_imm64(ctx, v36);
                        if v37 == 0x0_u64 {
                            let v60 = &constructor_is_nonzero(ctx, arg2);
                            let v61 = &constructor_cond_invert(ctx, v60);
                            // Rule at src/isa/x64/inst.isle line 3928.
                            return v61.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 v21,
                    imm: v22,
                } = &v18.1 {
                    if let &Opcode::Iconst = v21 {
                        let v23 = C::u64_from_imm64(ctx, v22);
                        if v23 == 0x0_u64 {
                            let v58 = &constructor_is_nonzero(ctx, arg1);
                            let v59 = &constructor_cond_invert(ctx, v58);
                            // Rule at src/isa/x64/inst.isle line 3927.
                            return v59.clone();
                        }
                    }
                }
            }
        }
        &IntCC::NotEqual => {
            let v30 = C::def_inst(ctx, arg1);
            if let Some(v31) = v30 {
                let v32 = C::inst_data_value(ctx, v31);
                if let &InstructionData::UnaryImm {
                    opcode: ref v35,
                    imm: v36,
                } = &v32.1 {
                    if let &Opcode::Iconst = v35 {
                        let v37 = C::u64_from_imm64(ctx, v36);
                        if v37 == 0x0_u64 {
                            let v60 = &constructor_is_nonzero(ctx, arg2);
                            // Rule at src/isa/x64/inst.isle line 3930.
                            return v60.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 v21,
                    imm: v22,
                } = &v18.1 {
                    if let &Opcode::Iconst = v21 {
                        let v23 = C::u64_from_imm64(ctx, v22);
                        if v23 == 0x0_u64 {
                            let v58 = &constructor_is_nonzero(ctx, arg1);
                            // Rule at src/isa/x64/inst.isle line 3929.
                            return v58.clone();
                        }
                    }
                }
            }
        }
        _ => {}
    }
    let v2 = C::value_type(ctx, arg1);
    if v2 == I128 {
        let v46 = C::put_in_regs(ctx, arg1);
        let v48 = constructor_value_regs_get_gpr(ctx, v46, 0x0_usize);
        let v49 = C::put_in_regs(ctx, arg1);
        let v51 = constructor_value_regs_get_gpr(ctx, v49, 0x1_usize);
        let v52 = C::put_in_regs(ctx, arg2);
        let v53 = constructor_value_regs_get_gpr(ctx, v52, 0x0_usize);
        let v54 = C::put_in_regs(ctx, arg2);
        let v55 = constructor_value_regs_get_gpr(ctx, v54, 0x1_usize);
        let v56 = &C::intcc_to_cc(ctx, arg0);
        let v57 = &constructor_emit_cmp_i128(ctx, v56, v51, v48, v55, v53);
        // Rule at src/isa/x64/inst.isle line 3918.
        return v57.clone();
    }
    let v30 = C::def_inst(ctx, arg1);
    if let Some(v31) = v30 {
        let v32 = C::inst_data_value(ctx, v31);
        if let &InstructionData::UnaryImm {
            opcode: ref v35,
            imm: v36,
        } = &v32.1 {
            if let &Opcode::Iconst = v35 {
                let v37 = C::u64_from_imm64(ctx, v36);
                if v37 == 0x0_u64 {
                    let v39 = C::put_in_reg(ctx, arg2);
                    let v40 = C::gpr_new(ctx, v39);
                    let v41 = &C::gpr_to_gpr_mem_imm(ctx, v40);
                    let v38 = C::value_type(ctx, arg2);
                    let v42 = &constructor_x64_test(ctx, v38, v40, v41);
                    let v43 = &C::intcc_swap_args(ctx, arg0);
                    let v44 = &C::intcc_to_cc(ctx, v43);
                    let v45 = CondResult::CC {
                        producer: v42.clone(),
                        cc: v44.clone(),
                    };
                    // Rule at src/isa/x64/inst.isle line 3912.
                    return v45;
                }
            }
        }
    }
    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 v21,
            imm: v22,
        } = &v18.1 {
            if let &Opcode::Iconst = v21 {
                let v23 = C::u64_from_imm64(ctx, v22);
                if v23 == 0x0_u64 {
                    let v24 = C::put_in_reg(ctx, arg1);
                    let v25 = C::gpr_new(ctx, v24);
                    let v26 = &C::gpr_to_gpr_mem_imm(ctx, v25);
                    let v27 = &constructor_x64_test(ctx, v2, v25, v26);
                    let v28 = &C::intcc_to_cc(ctx, arg0);
                    let v29 = CondResult::CC {
                        producer: v27.clone(),
                        cc: v28.clone(),
                    };
                    // Rule at src/isa/x64/inst.isle line 3909.
                    return v29;
                }
            }
        }
    }
    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 3905.
        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 3900.
    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 3941.
            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 3939.
            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 3937.
            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 3935.
            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 3946.
        return v26;
    }
    let v27 = &C::gpr_to_gpr_mem_64(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 3956.
    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 = &constructor_x64_ucomis(ctx, v4, v6, arg2);
                let v10 = CondResult::And {
                    producer: v7.clone(),
                    cc1: CC::NP,
                    cc2: CC::Z,
                };
                // Rule at src/isa/x64/inst.isle line 3979.
                return v10;
            }
        }
        &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 = &constructor_x64_ucomis(ctx, v4, v6, arg2);
                let v19 = CondResult::CC {
                    producer: v7.clone(),
                    cc: CC::NBE,
                };
                // Rule at src/isa/x64/inst.isle line 3995.
                return v19;
            }
        }
        &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 = &constructor_x64_ucomis(ctx, v4, v6, arg2);
                let v21 = CondResult::CC {
                    producer: v7.clone(),
                    cc: CC::NB,
                };
                // Rule at src/isa/x64/inst.isle line 3997.
                return v21;
            }
        }
        &FloatCC::LessThan => {
            let v2 = C::value_type(ctx, arg1);
            let v3 = C::ty_scalar_float(ctx, v2);
            if let Some(v4) = v3 {
                let v26 = constructor_put_in_xmm(ctx, arg2);
                let v27 = &constructor_x64_ucomis(ctx, v4, v26, arg1);
                let v28 = CondResult::CC {
                    producer: v27.clone(),
                    cc: CC::NBE,
                };
                // Rule at src/isa/x64/inst.isle line 4007.
                return v28;
            }
        }
        &FloatCC::LessThanOrEqual => {
            let v2 = C::value_type(ctx, arg1);
            let v3 = C::ty_scalar_float(ctx, v2);
            if let Some(v4) = v3 {
                let v26 = constructor_put_in_xmm(ctx, arg2);
                let v27 = &constructor_x64_ucomis(ctx, v4, v26, arg1);
                let v29 = CondResult::CC {
                    producer: v27.clone(),
                    cc: CC::NB,
                };
                // Rule at src/isa/x64/inst.isle line 4010.
                return v29;
            }
        }
        &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 = &constructor_x64_ucomis(ctx, v4, v6, arg2);
                let v13 = CondResult::Or {
                    producer: v7.clone(),
                    cc1: CC::P,
                    cc2: CC::NZ,
                };
                // Rule at src/isa/x64/inst.isle line 3982.
                return v13;
            }
        }
        &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 = &constructor_x64_ucomis(ctx, v4, v6, arg2);
                let v14 = CondResult::CC {
                    producer: v7.clone(),
                    cc: CC::NP,
                };
                // Rule at src/isa/x64/inst.isle line 3987.
                return v14;
            }
        }
        &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 = &constructor_x64_ucomis(ctx, v4, v6, arg2);
                let v16 = CondResult::CC {
                    producer: v7.clone(),
                    cc: CC::NZ,
                };
                // Rule at src/isa/x64/inst.isle line 3991.
                return v16;
            }
        }
        &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 = &constructor_x64_ucomis(ctx, v4, v6, arg2);
                let v15 = CondResult::CC {
                    producer: v7.clone(),
                    cc: CC::P,
                };
                // Rule at src/isa/x64/inst.isle line 3989.
                return v15;
            }
        }
        &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 = &constructor_x64_ucomis(ctx, v4, v6, arg2);
                let v17 = CondResult::CC {
                    producer: v7.clone(),
                    cc: CC::Z,
                };
                // Rule at src/isa/x64/inst.isle line 3993.
                return v17;
            }
        }
        &FloatCC::UnorderedOrGreaterThan => {
            let v2 = C::value_type(ctx, arg1);
            let v3 = C::ty_scalar_float(ctx, v2);
            if let Some(v4) = v3 {
                let v26 = constructor_put_in_xmm(ctx, arg2);
                let v27 = &constructor_x64_ucomis(ctx, v4, v26, arg1);
                let v30 = CondResult::CC {
                    producer: v27.clone(),
                    cc: CC::B,
                };
                // Rule at src/isa/x64/inst.isle line 4013.
                return v30;
            }
        }
        &FloatCC::UnorderedOrGreaterThanOrEqual => {
            let v2 = C::value_type(ctx, arg1);
            let v3 = C::ty_scalar_float(ctx, v2);
            if let Some(v4) = v3 {
                let v26 = constructor_put_in_xmm(ctx, arg2);
                let v27 = &constructor_x64_ucomis(ctx, v4, v26, arg1);
                let v31 = CondResult::CC {
                    producer: v27.clone(),
                    cc: CC::BE,
                };
                // Rule at src/isa/x64/inst.isle line 4016.
                return v31;
            }
        }
        &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 = &constructor_x64_ucomis(ctx, v4, v6, arg2);
                let v23 = CondResult::CC {
                    producer: v7.clone(),
                    cc: CC::B,
                };
                // Rule at src/isa/x64/inst.isle line 3999.
                return v23;
            }
        }
        &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 = &constructor_x64_ucomis(ctx, v4, v6, arg2);
                let v25 = CondResult::CC {
                    producer: v7.clone(),
                    cc: CC::BE,
                };
                // Rule at src/isa/x64/inst.isle line 4001.
                return v25;
            }
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "emit_fcmp", "src/isa/x64/inst.isle line 3977")
}

// 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 4029.
            return v4;
        }
        I16 => {
            let v5 = constructor_x64_lock_cmpxchgw_mr(ctx, arg3, arg2, arg1);
            // Rule at src/isa/x64/inst.isle line 4030.
            return v5;
        }
        I32 => {
            let v6 = constructor_x64_lock_cmpxchgl_mr(ctx, arg3, arg2, arg1);
            // Rule at src/isa/x64/inst.isle line 4031.
            return v6;
        }
        I64 => {
            let v7 = constructor_x64_lock_cmpxchgq_mr(ctx, arg3, arg2, arg1);
            // Rule at src/isa/x64/inst.isle line 4032.
            return v7;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_cmpxchg", "src/isa/x64/inst.isle line 4028")
}

// 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 4035.
    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 4043.
            return v3;
        }
        I16 => {
            let v4 = constructor_x64_lock_xaddw_mr(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 4044.
            return v4;
        }
        I32 => {
            let v5 = constructor_x64_lock_xaddl_mr(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 4045.
            return v5;
        }
        I64 => {
            let v6 = constructor_x64_lock_xaddq_mr(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 4046.
            return v6;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_xadd", "src/isa/x64/inst.isle line 4042")
}

// 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 4049.
            return v3;
        }
        I16 => {
            let v4 = constructor_x64_xchgw_rm(ctx, arg2, arg1);
            // Rule at src/isa/x64/inst.isle line 4050.
            return v4;
        }
        I32 => {
            let v5 = constructor_x64_xchgl_rm(ctx, arg2, arg1);
            // Rule at src/isa/x64/inst.isle line 4051.
            return v5;
        }
        I64 => {
            let v6 = constructor_x64_xchgq_rm(ctx, arg2, arg1);
            // Rule at src/isa/x64/inst.isle line 4052.
            return v6;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_xchg", "src/isa/x64/inst.isle line 4048")
}

// 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 4055.
            return v3.clone();
        }
        &OperandSize::Size16 => {
            let v4 = &constructor_x64_lock_addw_mr_mem(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 4056.
            return v4.clone();
        }
        &OperandSize::Size32 => {
            let v5 = &constructor_x64_lock_addl_mr_mem(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 4057.
            return v5.clone();
        }
        &OperandSize::Size64 => {
            let v6 = &constructor_x64_lock_addq_mr_mem(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 4058.
            return v6.clone();
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_lock_add", "src/isa/x64/inst.isle line 4054")
}

// 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 4061.
            return v3.clone();
        }
        &OperandSize::Size16 => {
            let v4 = &constructor_x64_lock_subw_mr_mem(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 4062.
            return v4.clone();
        }
        &OperandSize::Size32 => {
            let v5 = &constructor_x64_lock_subl_mr_mem(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 4063.
            return v5.clone();
        }
        &OperandSize::Size64 => {
            let v6 = &constructor_x64_lock_subq_mr_mem(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 4064.
            return v6.clone();
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_lock_sub", "src/isa/x64/inst.isle line 4060")
}

// 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 4067.
            return v3.clone();
        }
        &OperandSize::Size16 => {
            let v4 = &constructor_x64_lock_andw_mr_mem(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 4068.
            return v4.clone();
        }
        &OperandSize::Size32 => {
            let v5 = &constructor_x64_lock_andl_mr_mem(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 4069.
            return v5.clone();
        }
        &OperandSize::Size64 => {
            let v6 = &constructor_x64_lock_andq_mr_mem(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 4070.
            return v6.clone();
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_lock_and", "src/isa/x64/inst.isle line 4066")
}

// 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 4073.
            return v3.clone();
        }
        &OperandSize::Size16 => {
            let v4 = &constructor_x64_lock_orw_mr_mem(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 4074.
            return v4.clone();
        }
        &OperandSize::Size32 => {
            let v5 = &constructor_x64_lock_orl_mr_mem(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 4075.
            return v5.clone();
        }
        &OperandSize::Size64 => {
            let v6 = &constructor_x64_lock_orq_mr_mem(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 4076.
            return v6.clone();
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_lock_or", "src/isa/x64/inst.isle line 4072")
}

// 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 4079.
            return v3.clone();
        }
        &OperandSize::Size16 => {
            let v4 = &constructor_x64_lock_xorw_mr_mem(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 4080.
            return v4.clone();
        }
        &OperandSize::Size32 => {
            let v5 = &constructor_x64_lock_xorl_mr_mem(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 4081.
            return v5.clone();
        }
        &OperandSize::Size64 => {
            let v6 = &constructor_x64_lock_xorq_mr_mem(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 4082.
            return v6.clone();
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_lock_xor", "src/isa/x64/inst.isle line 4078")
}

// 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 4085.
    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: MemFlagsData,
    arg3: ValueRegs,
) -> ValueRegs {
    if let &AtomicRmwOp::Xchg = arg0 {
        let v4 = C::temp_writable_gpr(ctx);
        let v5 = C::temp_writable_gpr(ctx);
        let v21 = constructor_value_regs_get_gpr(ctx, arg3, 0x0_usize);
        let v22 = constructor_value_regs_get_gpr(ctx, arg3, 0x1_usize);
        let v23 = &constructor_amode_offset(ctx, arg1, arg2, 8_i32);
        let v24 = &C::atomic128_xchg_seq_args(ctx, arg1, v23, v21, v22, v4, v5);
        let v25 = MInst::Atomic128XchgSeq {
            args: v24.clone(),
        };
        let v26 = C::emit(ctx, &v25);
        let v27 = constructor_writable_gpr_to_r_reg(ctx, v4);
        let v28 = constructor_writable_gpr_to_r_reg(ctx, v5);
        let v29 = C::value_regs(ctx, v27, v28);
        // Rule at src/isa/x64/inst.isle line 4104.
        return v29;
    }
    let v4 = C::temp_writable_gpr(ctx);
    let v5 = C::temp_writable_gpr(ctx);
    let v6 = C::temp_writable_gpr(ctx);
    let v7 = C::temp_writable_gpr(ctx);
    let v9 = constructor_value_regs_get_gpr(ctx, arg3, 0x0_usize);
    let v11 = constructor_value_regs_get_gpr(ctx, arg3, 0x1_usize);
    let v13 = &constructor_amode_offset(ctx, arg1, arg2, 8_i32);
    let v14 = &constructor_atomic_128_rmw_seq_op(ctx, arg0);
    let v15 = &C::atomic128_rmw_seq_args(ctx, v14, arg1, v13, v9, v11, v6, v7, v4, v5);
    let v16 = MInst::Atomic128RmwSeq {
        args: v15.clone(),
    };
    let v17 = C::emit(ctx, &v16);
    let v18 = constructor_writable_gpr_to_r_reg(ctx, v4);
    let v19 = constructor_writable_gpr_to_r_reg(ctx, v5);
    let v20 = C::value_regs(ctx, v18, v19);
    // Rule at src/isa/x64/inst.isle line 4092.
    return v20;
}

// 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: MemFlagsData,
    arg2: ValueRegs,
) -> SideEffectNoResult {
    let v3 = C::temp_writable_gpr(ctx);
    let v4 = C::temp_writable_gpr(ctx);
    let v6 = constructor_value_regs_get_gpr(ctx, arg2, 0x0_usize);
    let v8 = constructor_value_regs_get_gpr(ctx, arg2, 0x1_usize);
    let v10 = &constructor_amode_offset(ctx, arg0, arg1, 8_i32);
    let v11 = &C::atomic128_xchg_seq_args(ctx, arg0, v10, v6, v8, v3, v4);
    let v12 = MInst::Atomic128XchgSeq {
        args: v11.clone(),
    };
    let v13 = SideEffectNoResult::Inst {
        inst: v12,
    };
    // Rule at src/isa/x64/inst.isle line 4115.
    return v13;
}

// 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 4136.
            return AtomicRmwSeqOp::And;
        }
        &AtomicRmwOp::Nand => {
            // Rule at src/isa/x64/inst.isle line 4137.
            return AtomicRmwSeqOp::Nand;
        }
        &AtomicRmwOp::Or => {
            // Rule at src/isa/x64/inst.isle line 4138.
            return AtomicRmwSeqOp::Or;
        }
        &AtomicRmwOp::Smax => {
            // Rule at src/isa/x64/inst.isle line 4143.
            return AtomicRmwSeqOp::Smax;
        }
        &AtomicRmwOp::Smin => {
            // Rule at src/isa/x64/inst.isle line 4142.
            return AtomicRmwSeqOp::Smin;
        }
        &AtomicRmwOp::Umax => {
            // Rule at src/isa/x64/inst.isle line 4141.
            return AtomicRmwSeqOp::Umax;
        }
        &AtomicRmwOp::Umin => {
            // Rule at src/isa/x64/inst.isle line 4140.
            return AtomicRmwSeqOp::Umin;
        }
        &AtomicRmwOp::Xor => {
            // Rule at src/isa/x64/inst.isle line 4139.
            return AtomicRmwSeqOp::Xor;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "atomic_rmw_seq_op", "src/isa/x64/inst.isle line 4135")
}

// 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 4158.
            return Atomic128RmwSeqOp::Add;
        }
        &AtomicRmwOp::And => {
            // Rule at src/isa/x64/inst.isle line 4160.
            return Atomic128RmwSeqOp::And;
        }
        &AtomicRmwOp::Nand => {
            // Rule at src/isa/x64/inst.isle line 4161.
            return Atomic128RmwSeqOp::Nand;
        }
        &AtomicRmwOp::Or => {
            // Rule at src/isa/x64/inst.isle line 4162.
            return Atomic128RmwSeqOp::Or;
        }
        &AtomicRmwOp::Smax => {
            // Rule at src/isa/x64/inst.isle line 4167.
            return Atomic128RmwSeqOp::Smax;
        }
        &AtomicRmwOp::Smin => {
            // Rule at src/isa/x64/inst.isle line 4166.
            return Atomic128RmwSeqOp::Smin;
        }
        &AtomicRmwOp::Sub => {
            // Rule at src/isa/x64/inst.isle line 4159.
            return Atomic128RmwSeqOp::Sub;
        }
        &AtomicRmwOp::Umax => {
            // Rule at src/isa/x64/inst.isle line 4165.
            return Atomic128RmwSeqOp::Umax;
        }
        &AtomicRmwOp::Umin => {
            // Rule at src/isa/x64/inst.isle line 4164.
            return Atomic128RmwSeqOp::Umin;
        }
        &AtomicRmwOp::Xor => {
            // Rule at src/isa/x64/inst.isle line 4163.
            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 4157")
}

// 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 4172.
            return v3;
        }
        0x20_u8 => {
            let v4 = constructor_x64_movd_to_gpr(ctx, arg1);
            // Rule at src/isa/x64/inst.isle line 4174.
            return v4;
        }
        0x40_u8 => {
            let v5 = constructor_x64_movq_to_gpr(ctx, arg1);
            // Rule at src/isa/x64/inst.isle line 4176.
            return v5;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "bitcast_xmm_to_gpr", "src/isa/x64/inst.isle line 4171")
}

// 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_128(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 4180.
    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 4186.
            return v6;
        }
        0x20_u8 => {
            let v7 = &C::gpr_to_gpr_mem_32(ctx, arg1);
            let v8 = constructor_x64_movd_to_xmm(ctx, v7);
            // Rule at src/isa/x64/inst.isle line 4188.
            return v8;
        }
        0x40_u8 => {
            let v9 = &C::gpr_to_gpr_mem_64(ctx, arg1);
            let v10 = constructor_x64_movq_to_xmm(ctx, v9);
            // Rule at src/isa/x64/inst.isle line 4190.
            return v10;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "bitcast_gpr_to_xmm", "src/isa/x64/inst.isle line 4185")
}

// 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_64(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_64(ctx, v6);
    let v8 = constructor_x64_movq_to_xmm(ctx, v7);
    let v9 = &C::xmm_to_xmm_mem_128(ctx, v8);
    let v10 = constructor_x64_punpcklqdq(ctx, v4, v9);
    // Rule at src/isa/x64/inst.isle line 4194.
    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 4200.
    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 4209.
    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 4216.
    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 = &C::gpr_mem_16_for_ty(ctx, arg0, arg3);
            let v6 = constructor_x64_divw_m(ctx, arg1, arg2, v5, arg4);
            // Rule at src/isa/x64/inst.isle line 4226.
            return v6;
        }
        I32 => {
            let v7 = &C::gpr_mem_32_for_ty(ctx, arg0, arg3);
            let v8 = constructor_x64_divl_m(ctx, arg1, arg2, v7, arg4);
            // Rule at src/isa/x64/inst.isle line 4227.
            return v8;
        }
        I64 => {
            let v9 = &C::gpr_mem_64_for_ty(ctx, arg0, arg3);
            let v10 = constructor_x64_divq_m(ctx, arg1, arg2, v9, arg4);
            // Rule at src/isa/x64/inst.isle line 4228.
            return v10;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_div", "src/isa/x64/inst.isle line 4225")
}

// 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 = &C::gpr_mem_16_for_ty(ctx, arg0, arg3);
            let v6 = constructor_x64_idivw_m(ctx, arg1, arg2, v5, arg4);
            // Rule at src/isa/x64/inst.isle line 4231.
            return v6;
        }
        I32 => {
            let v7 = &C::gpr_mem_32_for_ty(ctx, arg0, arg3);
            let v8 = constructor_x64_idivl_m(ctx, arg1, arg2, v7, arg4);
            // Rule at src/isa/x64/inst.isle line 4232.
            return v8;
        }
        I64 => {
            let v9 = &C::gpr_mem_64_for_ty(ctx, arg0, arg3);
            let v10 = constructor_x64_idivq_m(ctx, arg1, arg2, v9, arg4);
            // Rule at src/isa/x64/inst.isle line 4233.
            return v10;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_idiv", "src/isa/x64/inst.isle line 4230")
}

// 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 4238.
    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 4242.
    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 4284.
    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 4291.
    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 4298.
    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 4307.
    return v4;
}

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

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

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

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

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

// 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 4620.
    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 4623.
    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 4627.
    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 4630.
    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 4633.
    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 4636.
    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 4639.
    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 4642.
    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 4645.
    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 4648.
    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 4658.
    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 4656.
    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 4661.
    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 4664.
    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 4669.
    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 4671.
    return v2;
}

// Generated as internal constructor for term synthetic_amode_to_xmm_mem_aligned_128.
pub fn constructor_synthetic_amode_to_xmm_mem_aligned_128<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
) -> XmmMemAligned128 {
    let v1 = &C::synthetic_amode_to_xmm_mem_128(ctx, arg0);
    let v2 = &C::xmm_mem_128_to_xmm_mem_aligned_128(ctx, v1);
    // Rule at src/isa/x64/inst.isle line 4696.
    return v2.clone();
}

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

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

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

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

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

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

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

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

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

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

// Generated as internal constructor for term emit_xmm_mem_128_le_const.
pub fn constructor_emit_xmm_mem_128_le_const<C: Context>(
    ctx: &mut C,
    arg0: u128,
) -> XmmMem128 {
    let v1 = C::emit_u128_le_const(ctx, arg0);
    let v2 = &C::const_to_xmm_mem_128(ctx, v1);
    // Rule at src/isa/x64/inst.isle line 4799.
    return v2.clone();
}

// 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 4803.
    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 4805.
    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 4807.
    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 4809.
    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 4812.
    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 4825.
    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 4829.
    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 4859.
    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.1 {
        &InstructionData::AtomicCas {
            opcode: ref v2436,
            args: ref v2437,
            flags: v2438,
        } => {
            if let &Opcode::AtomicCas = v2436 {
                let v1 = C::first_result(ctx, arg0);
                if let Some(v2) = v1 {
                    let v3 = C::value_type(ctx, v2);
                    if v3 == I128 {
                        let v2402 = C::has_cmpxchg16b(ctx);
                        if v2402 == true {
                            let v2452 = C::mem_flags_data(ctx, v2438);
                            if let Some(v2453) = v2452 {
                                let v2439 = C::unpack_value_array_3(ctx, v2437);
                                let v2454 = C::put_in_regs(ctx, v2439.1);
                                let v2455 = C::put_in_regs(ctx, v2439.2);
                                let v2447 = C::zero_offset(ctx);
                                let v2456 = &constructor_to_amode(ctx, v2453, v2439.0, v2447);
                                let v2457 = constructor_x64_cmpxchg16b(ctx, v2454, v2455, v2456);
                                let v2458 = C::output(ctx, v2457);
                                let v2459 = Some(v2458);
                                // Rule at src/isa/x64/lower.isle line 3476.
                                return v2459;
                            }
                        }
                    }
                    let v4 = C::fits_in_64(ctx, v3);
                    if let Some(v5) = v4 {
                        let v2394 = C::ty_int(ctx, v3);
                        if let Some(v2395) = v2394 {
                            let v2443 = C::little_or_native_endian(ctx, v2438);
                            if let Some(v2444) = v2443 {
                                let v2439 = C::unpack_value_array_3(ctx, v2437);
                                let v2445 = constructor_put_in_gpr(ctx, v2439.1);
                                let v2446 = constructor_put_in_gpr(ctx, v2439.2);
                                let v2447 = C::zero_offset(ctx);
                                let v2448 = &constructor_to_amode(ctx, v2444, v2439.0, v2447);
                                let v2449 = constructor_x64_cmpxchg(ctx, v5, v2445, v2446, v2448);
                                let v2450 = constructor_output_gpr(ctx, v2449);
                                let v2451 = Some(v2450);
                                // Rule at src/isa/x64/lower.isle line 3473.
                                return v2451;
                            }
                        }
                    }
                }
            }
        }
        &InstructionData::AtomicRmw {
            opcode: ref v2460,
            args: ref v2461,
            flags: v2462,
            op: ref v2463,
        } => {
            if let &Opcode::AtomicRmw = v2460 {
                let v1 = C::first_result(ctx, arg0);
                if let Some(v2) = v1 {
                    let v2467 = C::little_or_native_endian(ctx, v2462);
                    if let Some(v2468) = v2467 {
                        let v3 = C::value_type(ctx, v2);
                        if v3 == I128 {
                            let v2402 = C::has_cmpxchg16b(ctx);
                            if v2402 == true {
                                let v72 = C::zero_offset(ctx);
                                let v2464 = C::unpack_value_array_2(ctx, v2461);
                                let v2475 = &constructor_to_amode(ctx, v2468, v2464.0, v72);
                                let v2506 = C::put_in_regs(ctx, v2464.1);
                                let v2507 = constructor_x64_atomic_128_rmw_seq(ctx, v2463, v2475, v2468, v2506);
                                let v2508 = C::output(ctx, v2507);
                                let v2509 = Some(v2508);
                                // Rule at src/isa/x64/lower.isle line 3529.
                                return v2509;
                            }
                        }
                        let v4 = C::fits_in_64(ctx, v3);
                        if let Some(v5) = v4 {
                            match v2463 {
                                &AtomicRmwOp::Add => {
                                    let v2487 = C::ty_int(ctx, v5);
                                    if let Some(v2488) = v2487 {
                                        let v2489 = C::value_is_unused(ctx, v2);
                                        if v2489 == true {
                                            let v2490 = &C::raw_operand_size_of_type(ctx, v2488);
                                            let v2396 = C::zero_offset(ctx);
                                            let v2464 = C::unpack_value_array_2(ctx, v2461);
                                            let v2470 = &constructor_to_amode(ctx, v2468, v2464.0, v2396);
                                            let v2471 = constructor_put_in_gpr(ctx, v2464.1);
                                            let v2491 = &constructor_x64_lock_add(ctx, v2490, v2470, v2471);
                                            let v2492 = constructor_side_effect_as_invalid(ctx, v2491);
                                            let v2493 = Some(v2492);
                                            // Rule at src/isa/x64/lower.isle line 3502.
                                            return v2493;
                                        }
                                    }
                                    let v2394 = C::ty_int(ctx, v3);
                                    if let Some(v2395) = v2394 {
                                        let v72 = C::zero_offset(ctx);
                                        let v2464 = C::unpack_value_array_2(ctx, v2461);
                                        let v2475 = &constructor_to_amode(ctx, v2468, v2464.0, v72);
                                        let v2476 = constructor_put_in_gpr(ctx, v2464.1);
                                        let v2477 = constructor_x64_xadd(ctx, v5, v2475, v2476);
                                        let v2478 = constructor_output_gpr(ctx, v2477);
                                        let v2479 = Some(v2478);
                                        // Rule at src/isa/x64/lower.isle line 3489.
                                        return v2479;
                                    }
                                }
                                &AtomicRmwOp::And => {
                                    let v2487 = C::ty_int(ctx, v5);
                                    if let Some(v2488) = v2487 {
                                        let v2489 = C::value_is_unused(ctx, v2);
                                        if v2489 == true {
                                            let v2490 = &C::raw_operand_size_of_type(ctx, v2488);
                                            let v2396 = C::zero_offset(ctx);
                                            let v2464 = C::unpack_value_array_2(ctx, v2461);
                                            let v2470 = &constructor_to_amode(ctx, v2468, v2464.0, v2396);
                                            let v2471 = constructor_put_in_gpr(ctx, v2464.1);
                                            let v2497 = &constructor_x64_lock_and(ctx, v2490, v2470, v2471);
                                            let v2498 = constructor_side_effect_as_invalid(ctx, v2497);
                                            let v2499 = Some(v2498);
                                            // Rule at src/isa/x64/lower.isle line 3512.
                                            return v2499;
                                        }
                                    }
                                }
                                &AtomicRmwOp::Or => {
                                    let v2487 = C::ty_int(ctx, v5);
                                    if let Some(v2488) = v2487 {
                                        let v2489 = C::value_is_unused(ctx, v2);
                                        if v2489 == true {
                                            let v2490 = &C::raw_operand_size_of_type(ctx, v2488);
                                            let v2396 = C::zero_offset(ctx);
                                            let v2464 = C::unpack_value_array_2(ctx, v2461);
                                            let v2470 = &constructor_to_amode(ctx, v2468, v2464.0, v2396);
                                            let v2471 = constructor_put_in_gpr(ctx, v2464.1);
                                            let v2500 = &constructor_x64_lock_or(ctx, v2490, v2470, v2471);
                                            let v2501 = constructor_side_effect_as_invalid(ctx, v2500);
                                            let v2502 = Some(v2501);
                                            // Rule at src/isa/x64/lower.isle line 3517.
                                            return v2502;
                                        }
                                    }
                                }
                                &AtomicRmwOp::Sub => {
                                    let v2487 = C::ty_int(ctx, v5);
                                    if let Some(v2488) = v2487 {
                                        let v2489 = C::value_is_unused(ctx, v2);
                                        if v2489 == true {
                                            let v2490 = &C::raw_operand_size_of_type(ctx, v2488);
                                            let v2396 = C::zero_offset(ctx);
                                            let v2464 = C::unpack_value_array_2(ctx, v2461);
                                            let v2470 = &constructor_to_amode(ctx, v2468, v2464.0, v2396);
                                            let v2471 = constructor_put_in_gpr(ctx, v2464.1);
                                            let v2494 = &constructor_x64_lock_sub(ctx, v2490, v2470, v2471);
                                            let v2495 = constructor_side_effect_as_invalid(ctx, v2494);
                                            let v2496 = Some(v2495);
                                            // Rule at src/isa/x64/lower.isle line 3507.
                                            return v2496;
                                        }
                                    }
                                    let v2394 = C::ty_int(ctx, v3);
                                    if let Some(v2395) = v2394 {
                                        let v72 = C::zero_offset(ctx);
                                        let v2464 = C::unpack_value_array_2(ctx, v2461);
                                        let v2475 = &constructor_to_amode(ctx, v2468, v2464.0, v72);
                                        let v2476 = constructor_put_in_gpr(ctx, v2464.1);
                                        let v2480 = constructor_x64_neg(ctx, v5, v2476);
                                        let v2481 = constructor_x64_xadd(ctx, v5, v2475, v2480);
                                        let v2482 = constructor_output_gpr(ctx, v2481);
                                        let v2483 = Some(v2482);
                                        // Rule at src/isa/x64/lower.isle line 3492.
                                        return v2483;
                                    }
                                }
                                &AtomicRmwOp::Xchg => {
                                    let v2394 = C::ty_int(ctx, v3);
                                    if let Some(v2395) = v2394 {
                                        let v72 = C::zero_offset(ctx);
                                        let v2464 = C::unpack_value_array_2(ctx, v2461);
                                        let v2475 = &constructor_to_amode(ctx, v2468, v2464.0, v72);
                                        let v2476 = constructor_put_in_gpr(ctx, v2464.1);
                                        let v2484 = constructor_x64_xchg(ctx, v5, v2475, v2476);
                                        let v2485 = constructor_output_gpr(ctx, v2484);
                                        let v2486 = Some(v2485);
                                        // Rule at src/isa/x64/lower.isle line 3496.
                                        return v2486;
                                    }
                                }
                                &AtomicRmwOp::Xor => {
                                    let v2487 = C::ty_int(ctx, v5);
                                    if let Some(v2488) = v2487 {
                                        let v2489 = C::value_is_unused(ctx, v2);
                                        if v2489 == true {
                                            let v2490 = &C::raw_operand_size_of_type(ctx, v2488);
                                            let v2396 = C::zero_offset(ctx);
                                            let v2464 = C::unpack_value_array_2(ctx, v2461);
                                            let v2470 = &constructor_to_amode(ctx, v2468, v2464.0, v2396);
                                            let v2471 = constructor_put_in_gpr(ctx, v2464.1);
                                            let v2503 = &constructor_x64_lock_xor(ctx, v2490, v2470, v2471);
                                            let v2504 = constructor_side_effect_as_invalid(ctx, v2503);
                                            let v2505 = Some(v2504);
                                            // Rule at src/isa/x64/lower.isle line 3522.
                                            return v2505;
                                        }
                                    }
                                }
                                _ => {}
                            }
                            let v2394 = C::ty_int(ctx, v3);
                            if let Some(v2395) = v2394 {
                                let v2469 = &constructor_atomic_rmw_seq_op(ctx, v2463);
                                let v2396 = C::zero_offset(ctx);
                                let v2464 = C::unpack_value_array_2(ctx, v2461);
                                let v2470 = &constructor_to_amode(ctx, v2468, v2464.0, v2396);
                                let v2471 = constructor_put_in_gpr(ctx, v2464.1);
                                let v2472 = constructor_x64_atomic_rmw_seq(ctx, v5, v2469, v2470, v2471);
                                let v2473 = constructor_output_gpr(ctx, v2472);
                                let v2474 = Some(v2473);
                                // Rule at src/isa/x64/lower.isle line 3484.
                                return v2474;
                            }
                        }
                    }
                }
            }
        }
        &InstructionData::Binary {
            opcode: ref v59,
            args: ref v60,
        } => {
            match v59 {
                &Opcode::Swizzle => {
                    let v61 = C::unpack_value_array_2(ctx, v60);
                    let v1792 = constructor_put_in_xmm(ctx, v61.1);
                    let v3282 = &constructor_emit_xmm_mem_128_le_const(ctx, 0x70707070707070707070707070707070_u128);
                    let v3283 = constructor_x64_paddusb(ctx, v1792, v3282);
                    let v3284 = constructor_put_in_xmm(ctx, v61.0);
                    let v3285 = &C::xmm_to_xmm_mem_128(ctx, v3283);
                    let v3286 = constructor_lower_pshufb(ctx, v3284, v3285);
                    let v3287 = constructor_output_xmm(ctx, v3286);
                    let v3288 = Some(v3287);
                    // Rule at src/isa/x64/lower.isle line 4755.
                    return v3288;
                }
                &Opcode::X86Pshufb => {
                    let v785 = C::has_ssse3(ctx);
                    if v785 == true {
                        let v61 = C::unpack_value_array_2(ctx, v60);
                        let v95 = constructor_put_in_xmm(ctx, v61.0);
                        let v96 = &C::put_in_xmm_mem_128(ctx, v61.1);
                        let v3289 = constructor_x64_pshufb(ctx, v95, v96);
                        let v3290 = constructor_output_xmm(ctx, v3289);
                        let v3291 = Some(v3290);
                        // Rule at src/isa/x64/lower.isle line 4761.
                        return v3291;
                    }
                }
                &Opcode::Smin => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        let v1180 = C::ty_vec128(ctx, v3);
                        if let Some(v1181) = v1180 {
                            let v1185 = constructor_has_pmins(ctx, v1181);
                            if v1185 == true {
                                let v61 = C::unpack_value_array_2(ctx, v60);
                                let v95 = constructor_put_in_xmm(ctx, v61.0);
                                let v96 = &C::put_in_xmm_mem_128(ctx, v61.1);
                                let v1186 = constructor_x64_pmins(ctx, v1181, v95, v96);
                                let v1187 = constructor_output_xmm(ctx, v1186);
                                let v1188 = Some(v1187);
                                // Rule at src/isa/x64/lower.isle line 1834.
                                return v1188;
                            }
                            let v61 = C::unpack_value_array_2(ctx, v60);
                            let v95 = constructor_put_in_xmm(ctx, v61.0);
                            let v277 = constructor_put_in_xmm(ctx, v61.1);
                            let v514 = &C::xmm_to_xmm_mem_128(ctx, v95);
                            let v1189 = constructor_x64_pcmpgt(ctx, v1181, v277, v514);
                            let v516 = &C::xmm_to_xmm_mem_128(ctx, v95);
                            let v1190 = constructor_x64_pand(ctx, v1189, v516);
                            let v700 = &C::xmm_to_xmm_mem_128(ctx, v277);
                            let v1191 = constructor_x64_pandn(ctx, v1189, v700);
                            let v1192 = &C::xmm_to_xmm_mem_128(ctx, v1191);
                            let v1193 = constructor_x64_por(ctx, v1190, v1192);
                            let v1194 = constructor_output_xmm(ctx, v1193);
                            let v1195 = Some(v1194);
                            // Rule at src/isa/x64/lower.isle line 1838.
                            return v1195;
                        }
                        let v4 = C::fits_in_64(ctx, v3);
                        if let Some(v5) = v4 {
                            let v61 = C::unpack_value_array_2(ctx, v60);
                            let v1173 = constructor_cmp_and_choose(ctx, v5, &CC::L, v61.0, v61.1);
                            let v1174 = C::output(ctx, v1173);
                            let v1175 = Some(v1174);
                            // Rule at src/isa/x64/lower.isle line 1784.
                            return v1175;
                        }
                    }
                }
                &Opcode::Umin => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        let v1180 = C::ty_vec128(ctx, v3);
                        if let Some(v1181) = v1180 {
                            let v1220 = constructor_has_pminu(ctx, v1181);
                            if v1220 == true {
                                let v61 = C::unpack_value_array_2(ctx, v60);
                                let v95 = constructor_put_in_xmm(ctx, v61.0);
                                let v96 = &C::put_in_xmm_mem_128(ctx, v61.1);
                                let v1221 = constructor_x64_pminu(ctx, v1181, v95, v96);
                                let v1222 = constructor_output_xmm(ctx, v1221);
                                let v1223 = Some(v1222);
                                // Rule at src/isa/x64/lower.isle line 1886.
                                return v1223;
                            }
                        }
                        if v3 == I16X8 {
                            let v61 = C::unpack_value_array_2(ctx, v60);
                            let v95 = constructor_put_in_xmm(ctx, v61.0);
                            let v96 = &C::put_in_xmm_mem_128(ctx, v61.1);
                            let v259 = constructor_x64_psubusw(ctx, v95, v96);
                            let v1224 = &C::xmm_to_xmm_mem_128(ctx, v259);
                            let v1225 = constructor_x64_psubw(ctx, v95, v1224);
                            let v1226 = constructor_output_xmm(ctx, v1225);
                            let v1227 = Some(v1226);
                            // Rule at src/isa/x64/lower.isle line 1892.
                            return v1227;
                        }
                        if let Some(v1181) = v1180 {
                            let v61 = C::unpack_value_array_2(ctx, v60);
                            let v95 = constructor_put_in_xmm(ctx, v61.0);
                            let v277 = constructor_put_in_xmm(ctx, v61.1);
                            let v1205 = constructor_flip_high_bit_mask(ctx, v1181);
                            let v1206 = &C::xmm_to_xmm_mem_128(ctx, v1205);
                            let v1207 = constructor_x64_pxor(ctx, v95, v1206);
                            let v1208 = &C::xmm_to_xmm_mem_128(ctx, v1205);
                            let v1209 = constructor_x64_pxor(ctx, v277, v1208);
                            let v1228 = &C::xmm_to_xmm_mem_128(ctx, v1207);
                            let v1229 = constructor_x64_pcmpgt(ctx, v1181, v1209, v1228);
                            let v1212 = &C::xmm_to_xmm_mem_128(ctx, v95);
                            let v1230 = constructor_x64_pand(ctx, v1229, v1212);
                            let v1214 = &C::xmm_to_xmm_mem_128(ctx, v277);
                            let v1231 = constructor_x64_pandn(ctx, v1229, v1214);
                            let v1232 = &C::xmm_to_xmm_mem_128(ctx, v1231);
                            let v1233 = constructor_x64_por(ctx, v1230, v1232);
                            let v1234 = constructor_output_xmm(ctx, v1233);
                            let v1235 = Some(v1234);
                            // Rule at src/isa/x64/lower.isle line 1897.
                            return v1235;
                        }
                        let v4 = C::fits_in_64(ctx, v3);
                        if let Some(v5) = v4 {
                            let v61 = C::unpack_value_array_2(ctx, v60);
                            let v1165 = constructor_cmp_and_choose(ctx, v5, &CC::B, v61.0, v61.1);
                            let v1166 = C::output(ctx, v1165);
                            let v1167 = Some(v1166);
                            // Rule at src/isa/x64/lower.isle line 1778.
                            return v1167;
                        }
                    }
                }
                &Opcode::Smax => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        let v1180 = C::ty_vec128(ctx, v3);
                        if let Some(v1181) = v1180 {
                            let v61 = C::unpack_value_array_2(ctx, v60);
                            let v95 = constructor_put_in_xmm(ctx, v61.0);
                            let v277 = constructor_put_in_xmm(ctx, v61.1);
                            let v1182 = constructor_lower_vec_smax(ctx, v1181, v95, v277);
                            let v1183 = constructor_output_xmm(ctx, v1182);
                            let v1184 = Some(v1183);
                            // Rule at src/isa/x64/lower.isle line 1814.
                            return v1184;
                        }
                        let v4 = C::fits_in_64(ctx, v3);
                        if let Some(v5) = v4 {
                            let v61 = C::unpack_value_array_2(ctx, v60);
                            let v1177 = constructor_cmp_and_choose(ctx, v5, &CC::NL, v61.0, v61.1);
                            let v1178 = C::output(ctx, v1177);
                            let v1179 = Some(v1178);
                            // Rule at src/isa/x64/lower.isle line 1787.
                            return v1179;
                        }
                    }
                }
                &Opcode::Umax => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        let v1180 = C::ty_vec128(ctx, v3);
                        if let Some(v1181) = v1180 {
                            let v1196 = constructor_has_pmaxu(ctx, v1181);
                            if v1196 == true {
                                let v61 = C::unpack_value_array_2(ctx, v60);
                                let v95 = constructor_put_in_xmm(ctx, v61.0);
                                let v96 = &C::put_in_xmm_mem_128(ctx, v61.1);
                                let v1197 = constructor_x64_pmaxu(ctx, v1181, v95, v96);
                                let v1198 = constructor_output_xmm(ctx, v1197);
                                let v1199 = Some(v1198);
                                // Rule at src/isa/x64/lower.isle line 1850.
                                return v1199;
                            }
                        }
                        if v3 == I16X8 {
                            let v61 = C::unpack_value_array_2(ctx, v60);
                            let v95 = constructor_put_in_xmm(ctx, v61.0);
                            let v277 = constructor_put_in_xmm(ctx, v61.1);
                            let v514 = &C::xmm_to_xmm_mem_128(ctx, v95);
                            let v1200 = constructor_x64_psubusw(ctx, v277, v514);
                            let v1201 = &C::xmm_to_xmm_mem_128(ctx, v1200);
                            let v1202 = constructor_x64_paddw(ctx, v95, v1201);
                            let v1203 = constructor_output_xmm(ctx, v1202);
                            let v1204 = Some(v1203);
                            // Rule at src/isa/x64/lower.isle line 1856.
                            return v1204;
                        }
                        if let Some(v1181) = v1180 {
                            let v61 = C::unpack_value_array_2(ctx, v60);
                            let v95 = constructor_put_in_xmm(ctx, v61.0);
                            let v277 = constructor_put_in_xmm(ctx, v61.1);
                            let v1205 = constructor_flip_high_bit_mask(ctx, v1181);
                            let v1206 = &C::xmm_to_xmm_mem_128(ctx, v1205);
                            let v1207 = constructor_x64_pxor(ctx, v95, v1206);
                            let v1208 = &C::xmm_to_xmm_mem_128(ctx, v1205);
                            let v1209 = constructor_x64_pxor(ctx, v277, v1208);
                            let v1210 = &C::xmm_to_xmm_mem_128(ctx, v1209);
                            let v1211 = constructor_x64_pcmpgt(ctx, v1181, v1207, v1210);
                            let v1212 = &C::xmm_to_xmm_mem_128(ctx, v95);
                            let v1213 = constructor_x64_pand(ctx, v1211, v1212);
                            let v1214 = &C::xmm_to_xmm_mem_128(ctx, v277);
                            let v1215 = constructor_x64_pandn(ctx, v1211, v1214);
                            let v1216 = &C::xmm_to_xmm_mem_128(ctx, v1215);
                            let v1217 = constructor_x64_por(ctx, v1213, v1216);
                            let v1218 = constructor_output_xmm(ctx, v1217);
                            let v1219 = Some(v1218);
                            // Rule at src/isa/x64/lower.isle line 1863.
                            return v1219;
                        }
                        let v4 = C::fits_in_64(ctx, v3);
                        if let Some(v5) = v4 {
                            let v61 = C::unpack_value_array_2(ctx, v60);
                            let v1169 = constructor_cmp_and_choose(ctx, v5, &CC::NB, v61.0, v61.1);
                            let v1170 = C::output(ctx, v1169);
                            let v1171 = Some(v1170);
                            // Rule at src/isa/x64/lower.isle line 1781.
                            return v1171;
                        }
                    }
                }
                &Opcode::AvgRound => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        let v91 = C::multi_lane(ctx, v3);
                        if let Some(v92) = v91 {
                            match v92.0 {
                                0x8_u32 => {
                                    if v92.1 == 0x10_u32 {
                                        let v61 = C::unpack_value_array_2(ctx, v60);
                                        let v95 = constructor_put_in_xmm(ctx, v61.0);
                                        let v96 = &C::put_in_xmm_mem_128(ctx, v61.1);
                                        let v631 = constructor_x64_pavgb(ctx, v95, v96);
                                        let v632 = constructor_output_xmm(ctx, v631);
                                        let v633 = Some(v632);
                                        // Rule at src/isa/x64/lower.isle line 1034.
                                        return v633;
                                    }
                                }
                                0x10_u32 => {
                                    if v92.1 == 0x8_u32 {
                                        let v61 = C::unpack_value_array_2(ctx, v60);
                                        let v95 = constructor_put_in_xmm(ctx, v61.0);
                                        let v96 = &C::put_in_xmm_mem_128(ctx, v61.1);
                                        let v634 = constructor_x64_pavgw(ctx, v95, v96);
                                        let v635 = constructor_output_xmm(ctx, v634);
                                        let v636 = Some(v635);
                                        // Rule at src/isa/x64/lower.isle line 1038.
                                        return v636;
                                    }
                                }
                                _ => {}
                            }
                        }
                    }
                }
                &Opcode::UaddSat => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        let v91 = C::multi_lane(ctx, v3);
                        if let Some(v92) = v91 {
                            match v92.0 {
                                0x8_u32 => {
                                    if v92.1 == 0x10_u32 {
                                        let v61 = C::unpack_value_array_2(ctx, v60);
                                        let v95 = constructor_put_in_xmm(ctx, v61.0);
                                        let v96 = &C::put_in_xmm_mem_128(ctx, v61.1);
                                        let v220 = constructor_x64_paddusb(ctx, v95, v96);
                                        let v221 = constructor_output_xmm(ctx, v220);
                                        let v222 = Some(v221);
                                        // Rule at src/isa/x64/lower.isle line 234.
                                        return v222;
                                    }
                                }
                                0x10_u32 => {
                                    if v92.1 == 0x8_u32 {
                                        let v61 = C::unpack_value_array_2(ctx, v60);
                                        let v95 = constructor_put_in_xmm(ctx, v61.0);
                                        let v96 = &C::put_in_xmm_mem_128(ctx, v61.1);
                                        let v223 = constructor_x64_paddusw(ctx, v95, v96);
                                        let v224 = constructor_output_xmm(ctx, v223);
                                        let v225 = Some(v224);
                                        // Rule at src/isa/x64/lower.isle line 238.
                                        return v225;
                                    }
                                }
                                _ => {}
                            }
                        }
                    }
                }
                &Opcode::SaddSat => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        let v91 = C::multi_lane(ctx, v3);
                        if let Some(v92) = v91 {
                            match v92.0 {
                                0x8_u32 => {
                                    if v92.1 == 0x10_u32 {
                                        let v61 = C::unpack_value_array_2(ctx, v60);
                                        let v95 = constructor_put_in_xmm(ctx, v61.0);
                                        let v96 = &C::put_in_xmm_mem_128(ctx, v61.1);
                                        let v214 = constructor_x64_paddsb(ctx, v95, v96);
                                        let v215 = constructor_output_xmm(ctx, v214);
                                        let v216 = Some(v215);
                                        // Rule at src/isa/x64/lower.isle line 224.
                                        return v216;
                                    }
                                }
                                0x10_u32 => {
                                    if v92.1 == 0x8_u32 {
                                        let v61 = C::unpack_value_array_2(ctx, v60);
                                        let v95 = constructor_put_in_xmm(ctx, v61.0);
                                        let v96 = &C::put_in_xmm_mem_128(ctx, v61.1);
                                        let v217 = constructor_x64_paddsw(ctx, v95, v96);
                                        let v218 = constructor_output_xmm(ctx, v217);
                                        let v219 = Some(v218);
                                        // Rule at src/isa/x64/lower.isle line 228.
                                        return v219;
                                    }
                                }
                                _ => {}
                            }
                        }
                    }
                }
                &Opcode::UsubSat => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        let v91 = C::multi_lane(ctx, v3);
                        if let Some(v92) = v91 {
                            match v92.0 {
                                0x8_u32 => {
                                    if v92.1 == 0x10_u32 {
                                        let v61 = C::unpack_value_array_2(ctx, v60);
                                        let v95 = constructor_put_in_xmm(ctx, v61.0);
                                        let v96 = &C::put_in_xmm_mem_128(ctx, v61.1);
                                        let v256 = constructor_x64_psubusb(ctx, v95, v96);
                                        let v257 = constructor_output_xmm(ctx, v256);
                                        let v258 = Some(v257);
                                        // Rule at src/isa/x64/lower.isle line 307.
                                        return v258;
                                    }
                                }
                                0x10_u32 => {
                                    if v92.1 == 0x8_u32 {
                                        let v61 = C::unpack_value_array_2(ctx, v60);
                                        let v95 = constructor_put_in_xmm(ctx, v61.0);
                                        let v96 = &C::put_in_xmm_mem_128(ctx, v61.1);
                                        let v259 = constructor_x64_psubusw(ctx, v95, v96);
                                        let v260 = constructor_output_xmm(ctx, v259);
                                        let v261 = Some(v260);
                                        // Rule at src/isa/x64/lower.isle line 311.
                                        return v261;
                                    }
                                }
                                _ => {}
                            }
                        }
                    }
                }
                &Opcode::SsubSat => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        let v91 = C::multi_lane(ctx, v3);
                        if let Some(v92) = v91 {
                            match v92.0 {
                                0x8_u32 => {
                                    if v92.1 == 0x10_u32 {
                                        let v61 = C::unpack_value_array_2(ctx, v60);
                                        let v95 = constructor_put_in_xmm(ctx, v61.0);
                                        let v96 = &C::put_in_xmm_mem_128(ctx, v61.1);
                                        let v250 = constructor_x64_psubsb(ctx, v95, v96);
                                        let v251 = constructor_output_xmm(ctx, v250);
                                        let v252 = Some(v251);
                                        // Rule at src/isa/x64/lower.isle line 297.
                                        return v252;
                                    }
                                }
                                0x10_u32 => {
                                    if v92.1 == 0x8_u32 {
                                        let v61 = C::unpack_value_array_2(ctx, v60);
                                        let v95 = constructor_put_in_xmm(ctx, v61.0);
                                        let v96 = &C::put_in_xmm_mem_128(ctx, v61.1);
                                        let v253 = constructor_x64_psubsw(ctx, v95, v96);
                                        let v254 = constructor_output_xmm(ctx, v253);
                                        let v255 = Some(v254);
                                        // Rule at src/isa/x64/lower.isle line 301.
                                        return v255;
                                    }
                                }
                                _ => {}
                            }
                        }
                    }
                }
                &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 v61 = C::unpack_value_array_2(ctx, v60);
                            let v122 = C::def_inst(ctx, v61.1);
                            if let Some(v123) = v122 {
                                let v124 = C::inst_data_value(ctx, v123);
                                match &v124.1 {
                                    &InstructionData::Binary {
                                        opcode: ref v127,
                                        args: ref v128,
                                    } => {
                                        if let &Opcode::Iconcat = v127 {
                                            let v109 = C::put_in_regs(ctx, v61.0);
                                            let v132 = C::put_in_regs(ctx, v61.0);
                                            let v133 = constructor_value_regs_get_gpr(ctx, v132, 0x0_usize);
                                            let v134 = C::put_in_regs(ctx, v61.0);
                                            let v135 = constructor_value_regs_get_gpr(ctx, v134, 0x1_usize);
                                            let v129 = C::unpack_value_array_2(ctx, v128);
                                            let v136 = &C::put_in_gpr_mem_imm_64(ctx, v129.0);
                                            let v137 = &C::put_in_gpr_mem_imm_64(ctx, v129.1);
                                            let v138 = constructor_iadd128(ctx, v133, v135, v136, v137);
                                            let v139 = C::output(ctx, v138);
                                            let v140 = Some(v139);
                                            // Rule at src/isa/x64/lower.isle line 106.
                                            return v140;
                                        }
                                    }
                                    &InstructionData::Unary {
                                        opcode: ref v141,
                                        arg: v142,
                                    } => {
                                        if let &Opcode::Uextend = v141 {
                                            let v143 = C::value_type(ctx, v142);
                                            if v143 == I64 {
                                                let v150 = C::def_inst(ctx, v61.0);
                                                if let Some(v151) = v150 {
                                                    let v152 = C::inst_data_value(ctx, v151);
                                                    if let &InstructionData::Unary {
                                                        opcode: ref v155,
                                                        arg: v156,
                                                    } = &v152.1 {
                                                        if let &Opcode::Uextend = v155 {
                                                            let v158 = constructor_extend_to_gpr(ctx, v156, I64, &ExtendKind::Zero);
                                                            let v159 = &constructor_put_in_gpr_mem_imm(ctx, v142);
                                                            let v160 = &constructor_x64_add_with_flags_paired(ctx, I64, v158, v159);
                                                            let v162 = &constructor_x64_setcc_paired(ctx, &CC::B);
                                                            let v163 = constructor_with_flags(ctx, v160, v162);
                                                            let v164 = C::value_regs_get(ctx, v163, 0x0_usize);
                                                            let v166 = C::value_regs_get(ctx, v163, 0x1_usize);
                                                            let v167 = &C::reg_to_gpr_mem(ctx, v166);
                                                            let v168 = constructor_x64_movzx(ctx, &ExtMode::BQ, v167);
                                                            let v169 = C::gpr_to_reg(ctx, v168);
                                                            let v170 = C::value_regs(ctx, v164, v169);
                                                            let v171 = C::output(ctx, v170);
                                                            let v172 = Some(v171);
                                                            // Rule at src/isa/x64/lower.isle line 117.
                                                            return v172;
                                                        }
                                                    }
                                                }
                                                let v109 = C::put_in_regs(ctx, v61.0);
                                                let v132 = C::put_in_regs(ctx, v61.0);
                                                let v133 = constructor_value_regs_get_gpr(ctx, v132, 0x0_usize);
                                                let v134 = C::put_in_regs(ctx, v61.0);
                                                let v135 = constructor_value_regs_get_gpr(ctx, v134, 0x1_usize);
                                                let v144 = &C::put_in_gpr_mem_imm_64(ctx, v142);
                                                let v146 = &C::gpr_mem_imm_64_imm(ctx, 0x0_u32);
                                                let v147 = constructor_iadd128(ctx, v133, v135, v144, v146);
                                                let v148 = C::output(ctx, v147);
                                                let v149 = Some(v148);
                                                // Rule at src/isa/x64/lower.isle line 109.
                                                return v149;
                                            }
                                        }
                                    }
                                    _ => {}
                                }
                            }
                            let v109 = C::put_in_regs(ctx, v61.0);
                            let v110 = C::put_in_regs(ctx, v61.1);
                            let v112 = constructor_value_regs_get_gpr(ctx, v109, 0x0_usize);
                            let v114 = constructor_value_regs_get_gpr(ctx, v109, 0x1_usize);
                            let v115 = constructor_value_regs_get_gpr(ctx, v110, 0x0_usize);
                            let v116 = &C::gpr_to_gpr_mem_imm_64(ctx, v115);
                            let v117 = constructor_value_regs_get_gpr(ctx, v110, 0x1_usize);
                            let v118 = &C::gpr_to_gpr_mem_imm_64(ctx, v117);
                            let v119 = constructor_iadd128(ctx, v112, v114, v116, v118);
                            let v120 = C::output(ctx, v119);
                            let v121 = Some(v120);
                            // Rule at src/isa/x64/lower.isle line 97.
                            return v121;
                        }
                        let v91 = C::multi_lane(ctx, v3);
                        if let Some(v92) = v91 {
                            match v92.0 {
                                0x8_u32 => {
                                    if v92.1 == 0x10_u32 {
                                        let v61 = C::unpack_value_array_2(ctx, v60);
                                        let v95 = constructor_put_in_xmm(ctx, v61.0);
                                        let v96 = &C::put_in_xmm_mem_128(ctx, v61.1);
                                        let v97 = constructor_x64_paddb(ctx, v95, v96);
                                        let v98 = constructor_output_xmm(ctx, v97);
                                        let v99 = Some(v98);
                                        // Rule at src/isa/x64/lower.isle line 80.
                                        return v99;
                                    }
                                }
                                0x10_u32 => {
                                    if v92.1 == 0x8_u32 {
                                        let v61 = C::unpack_value_array_2(ctx, v60);
                                        let v95 = constructor_put_in_xmm(ctx, v61.0);
                                        let v96 = &C::put_in_xmm_mem_128(ctx, v61.1);
                                        let v100 = constructor_x64_paddw(ctx, v95, v96);
                                        let v101 = constructor_output_xmm(ctx, v100);
                                        let v102 = Some(v101);
                                        // Rule at src/isa/x64/lower.isle line 84.
                                        return v102;
                                    }
                                }
                                0x20_u32 => {
                                    if v92.1 == 0x4_u32 {
                                        let v61 = C::unpack_value_array_2(ctx, v60);
                                        let v95 = constructor_put_in_xmm(ctx, v61.0);
                                        let v96 = &C::put_in_xmm_mem_128(ctx, v61.1);
                                        let v103 = constructor_x64_paddd(ctx, v95, v96);
                                        let v104 = constructor_output_xmm(ctx, v103);
                                        let v105 = Some(v104);
                                        // Rule at src/isa/x64/lower.isle line 88.
                                        return v105;
                                    }
                                }
                                0x40_u32 => {
                                    if v92.1 == 0x2_u32 {
                                        let v61 = C::unpack_value_array_2(ctx, v60);
                                        let v95 = constructor_put_in_xmm(ctx, v61.0);
                                        let v96 = &C::put_in_xmm_mem_128(ctx, v61.1);
                                        let v106 = constructor_x64_paddq(ctx, v95, v96);
                                        let v107 = constructor_output_xmm(ctx, v106);
                                        let v108 = Some(v107);
                                        // Rule at src/isa/x64/lower.isle line 92.
                                        return v108;
                                    }
                                }
                                _ => {}
                            }
                        }
                        let v4 = C::fits_in_64(ctx, v3);
                        if let Some(v5) = v4 {
                            let v61 = C::unpack_value_array_2(ctx, v60);
                            let v84 = &C::sinkable_load(ctx, v61.0);
                            if let Some(v85) = v84 {
                                let v86 = constructor_put_in_gpr(ctx, v61.1);
                                let v87 = &constructor_sink_load_to_gpr_mem_imm(ctx, v85);
                                let v88 = constructor_x64_add(ctx, v5, v86, v87);
                                let v89 = constructor_output_gpr(ctx, v88);
                                let v90 = Some(v89);
                                // Rule at src/isa/x64/lower.isle line 74.
                                return v90;
                            }
                            let v78 = &C::sinkable_load(ctx, v61.1);
                            if let Some(v79) = v78 {
                                let v64 = constructor_put_in_gpr(ctx, v61.0);
                                let v80 = &constructor_sink_load_to_gpr_mem_imm(ctx, v79);
                                let v81 = constructor_x64_add(ctx, v5, v64, v80);
                                let v82 = constructor_output_gpr(ctx, v81);
                                let v83 = Some(v82);
                                // Rule at src/isa/x64/lower.isle line 71.
                                return v83;
                            }
                        }
                        let v69 = C::ty_32_or_64(ctx, v3);
                        if let Some(v70) = v69 {
                            let v72 = C::zero_offset(ctx);
                            let v71 = C::mem_flags_trusted_data(ctx);
                            let v61 = C::unpack_value_array_2(ctx, v60);
                            let v73 = &constructor_to_amode_add(ctx, v71, v61.0, v61.1, v72);
                            let v74 = &C::amode_to_synthetic_amode(ctx, v73);
                            let v75 = constructor_x64_lea(ctx, v70, v74);
                            let v76 = constructor_output_gpr(ctx, v75);
                            let v77 = Some(v76);
                            // Rule at src/isa/x64/lower.isle line 65.
                            return v77;
                        }
                        let v57 = C::fits_in_16(ctx, v3);
                        if let Some(v58) = v57 {
                            let v61 = C::unpack_value_array_2(ctx, v60);
                            let v64 = constructor_put_in_gpr(ctx, v61.0);
                            let v65 = &constructor_put_in_gpr_mem_imm(ctx, v61.1);
                            let v66 = constructor_x64_add(ctx, v58, v64, v65);
                            let v67 = constructor_output_gpr(ctx, v66);
                            let v68 = Some(v67);
                            // Rule at src/isa/x64/lower.isle line 54.
                            return v68;
                        }
                    }
                }
                &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 v61 = C::unpack_value_array_2(ctx, v60);
                            let v122 = C::def_inst(ctx, v61.1);
                            if let Some(v123) = v122 {
                                let v124 = C::inst_data_value(ctx, v123);
                                match &v124.1 {
                                    &InstructionData::Binary {
                                        opcode: ref v127,
                                        args: ref v128,
                                    } => {
                                        if let &Opcode::Iconcat = v127 {
                                            let v109 = C::put_in_regs(ctx, v61.0);
                                            let v132 = C::put_in_regs(ctx, v61.0);
                                            let v133 = constructor_value_regs_get_gpr(ctx, v132, 0x0_usize);
                                            let v134 = C::put_in_regs(ctx, v61.0);
                                            let v135 = constructor_value_regs_get_gpr(ctx, v134, 0x1_usize);
                                            let v129 = C::unpack_value_array_2(ctx, v128);
                                            let v136 = &C::put_in_gpr_mem_imm_64(ctx, v129.0);
                                            let v137 = &C::put_in_gpr_mem_imm_64(ctx, v129.1);
                                            let v244 = constructor_isub128(ctx, v133, v135, v136, v137);
                                            let v245 = C::output(ctx, v244);
                                            let v246 = Some(v245);
                                            // Rule at src/isa/x64/lower.isle line 279.
                                            return v246;
                                        }
                                    }
                                    &InstructionData::Unary {
                                        opcode: ref v141,
                                        arg: v142,
                                    } => {
                                        if let &Opcode::Uextend = v141 {
                                            let v143 = C::value_type(ctx, v142);
                                            if v143 == I64 {
                                                let v109 = C::put_in_regs(ctx, v61.0);
                                                let v132 = C::put_in_regs(ctx, v61.0);
                                                let v133 = constructor_value_regs_get_gpr(ctx, v132, 0x0_usize);
                                                let v134 = C::put_in_regs(ctx, v61.0);
                                                let v135 = constructor_value_regs_get_gpr(ctx, v134, 0x1_usize);
                                                let v144 = &C::put_in_gpr_mem_imm_64(ctx, v142);
                                                let v146 = &C::gpr_mem_imm_64_imm(ctx, 0x0_u32);
                                                let v247 = constructor_isub128(ctx, v133, v135, v144, v146);
                                                let v248 = C::output(ctx, v247);
                                                let v249 = Some(v248);
                                                // Rule at src/isa/x64/lower.isle line 282.
                                                return v249;
                                            }
                                        }
                                    }
                                    _ => {}
                                }
                            }
                            let v109 = C::put_in_regs(ctx, v61.0);
                            let v110 = C::put_in_regs(ctx, v61.1);
                            let v112 = constructor_value_regs_get_gpr(ctx, v109, 0x0_usize);
                            let v114 = constructor_value_regs_get_gpr(ctx, v109, 0x1_usize);
                            let v115 = constructor_value_regs_get_gpr(ctx, v110, 0x0_usize);
                            let v116 = &C::gpr_to_gpr_mem_imm_64(ctx, v115);
                            let v117 = constructor_value_regs_get_gpr(ctx, v110, 0x1_usize);
                            let v118 = &C::gpr_to_gpr_mem_imm_64(ctx, v117);
                            let v241 = constructor_isub128(ctx, v112, v114, v116, v118);
                            let v242 = C::output(ctx, v241);
                            let v243 = Some(v242);
                            // Rule at src/isa/x64/lower.isle line 270.
                            return v243;
                        }
                        let v91 = C::multi_lane(ctx, v3);
                        if let Some(v92) = v91 {
                            match v92.0 {
                                0x8_u32 => {
                                    if v92.1 == 0x10_u32 {
                                        let v61 = C::unpack_value_array_2(ctx, v60);
                                        let v95 = constructor_put_in_xmm(ctx, v61.0);
                                        let v96 = &C::put_in_xmm_mem_128(ctx, v61.1);
                                        let v229 = constructor_x64_psubb(ctx, v95, v96);
                                        let v230 = constructor_output_xmm(ctx, v229);
                                        let v231 = Some(v230);
                                        // Rule at src/isa/x64/lower.isle line 253.
                                        return v231;
                                    }
                                }
                                0x10_u32 => {
                                    if v92.1 == 0x8_u32 {
                                        let v61 = C::unpack_value_array_2(ctx, v60);
                                        let v95 = constructor_put_in_xmm(ctx, v61.0);
                                        let v96 = &C::put_in_xmm_mem_128(ctx, v61.1);
                                        let v232 = constructor_x64_psubw(ctx, v95, v96);
                                        let v233 = constructor_output_xmm(ctx, v232);
                                        let v234 = Some(v233);
                                        // Rule at src/isa/x64/lower.isle line 257.
                                        return v234;
                                    }
                                }
                                0x20_u32 => {
                                    if v92.1 == 0x4_u32 {
                                        let v61 = C::unpack_value_array_2(ctx, v60);
                                        let v95 = constructor_put_in_xmm(ctx, v61.0);
                                        let v96 = &C::put_in_xmm_mem_128(ctx, v61.1);
                                        let v235 = constructor_x64_psubd(ctx, v95, v96);
                                        let v236 = constructor_output_xmm(ctx, v235);
                                        let v237 = Some(v236);
                                        // Rule at src/isa/x64/lower.isle line 261.
                                        return v237;
                                    }
                                }
                                0x40_u32 => {
                                    if v92.1 == 0x2_u32 {
                                        let v61 = C::unpack_value_array_2(ctx, v60);
                                        let v95 = constructor_put_in_xmm(ctx, v61.0);
                                        let v96 = &C::put_in_xmm_mem_128(ctx, v61.1);
                                        let v238 = constructor_x64_psubq(ctx, v95, v96);
                                        let v239 = constructor_output_xmm(ctx, v238);
                                        let v240 = Some(v239);
                                        // Rule at src/isa/x64/lower.isle line 265.
                                        return v240;
                                    }
                                }
                                _ => {}
                            }
                        }
                        let v4 = C::fits_in_64(ctx, v3);
                        if let Some(v5) = v4 {
                            let v61 = C::unpack_value_array_2(ctx, v60);
                            let v64 = constructor_put_in_gpr(ctx, v61.0);
                            let v65 = &constructor_put_in_gpr_mem_imm(ctx, v61.1);
                            let v226 = constructor_x64_sub(ctx, v5, v64, v65);
                            let v227 = constructor_output_gpr(ctx, v226);
                            let v228 = Some(v227);
                            // Rule at src/isa/x64/lower.isle line 247.
                            return v228;
                        }
                    }
                }
                &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 v61 = C::unpack_value_array_2(ctx, v60);
                            let v122 = C::def_inst(ctx, v61.1);
                            if let Some(v123) = v122 {
                                let v124 = C::inst_data_value(ctx, v123);
                                match &v124.1 {
                                    &InstructionData::Binary {
                                        opcode: ref v127,
                                        args: ref v128,
                                    } => {
                                        if let &Opcode::Iconcat = v127 {
                                            let v150 = C::def_inst(ctx, v61.0);
                                            if let Some(v151) = v150 {
                                                let v152 = C::inst_data_value(ctx, v151);
                                                if let &InstructionData::Binary {
                                                    opcode: ref v376,
                                                    args: ref v377,
                                                } = &v152.1 {
                                                    if let &Opcode::Iconcat = v376 {
                                                        let v378 = C::unpack_value_array_2(ctx, v377);
                                                        let v409 = constructor_put_in_gpr(ctx, v378.0);
                                                        let v676 = constructor_put_in_gpr(ctx, v378.1);
                                                        let v129 = C::unpack_value_array_2(ctx, v128);
                                                        let v677 = &C::put_in_gpr_mem_64(ctx, v129.0);
                                                        let v678 = &C::put_in_gpr_mem_64(ctx, v129.1);
                                                        let v679 = constructor_imul128(ctx, v409, v676, v677, v678);
                                                        let v680 = C::output(ctx, v679);
                                                        let v681 = Some(v680);
                                                        // Rule at src/isa/x64/lower.isle line 1082.
                                                        return v681;
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    &InstructionData::Unary {
                                        opcode: ref v141,
                                        arg: v142,
                                    } => {
                                        match v141 {
                                            &Opcode::Uextend => {
                                                let v143 = C::value_type(ctx, v142);
                                                if v143 == I64 {
                                                    let v150 = C::def_inst(ctx, v61.0);
                                                    if let Some(v151) = v150 {
                                                        let v152 = C::inst_data_value(ctx, v151);
                                                        if let &InstructionData::Unary {
                                                            opcode: ref v155,
                                                            arg: v156,
                                                        } = &v152.1 {
                                                            if let &Opcode::Uextend = v155 {
                                                                let v682 = C::value_type(ctx, v156);
                                                                if v682 == I64 {
                                                                    let v303 = constructor_put_in_gpr(ctx, v156);
                                                                    let v664 = &constructor_put_in_gpr_mem(ctx, v142);
                                                                    let v197 = false;
                                                                    let v683 = constructor_x64_mul(ctx, I64, v197, v303, v664);
                                                                    let v684 = C::output(ctx, v683);
                                                                    let v685 = Some(v684);
                                                                    // Rule at src/isa/x64/lower.isle line 1124.
                                                                    return v685;
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                            &Opcode::Sextend => {
                                                let v143 = C::value_type(ctx, v142);
                                                if v143 == I64 {
                                                    let v150 = C::def_inst(ctx, v61.0);
                                                    if let Some(v151) = v150 {
                                                        let v152 = C::inst_data_value(ctx, v151);
                                                        if let &InstructionData::Unary {
                                                            opcode: ref v155,
                                                            arg: v156,
                                                        } = &v152.1 {
                                                            if let &Opcode::Sextend = v155 {
                                                                let v682 = C::value_type(ctx, v156);
                                                                if v682 == I64 {
                                                                    let v303 = constructor_put_in_gpr(ctx, v156);
                                                                    let v664 = &constructor_put_in_gpr_mem(ctx, v142);
                                                                    let v207 = true;
                                                                    let v686 = constructor_x64_mul(ctx, I64, v207, v303, v664);
                                                                    let v687 = C::output(ctx, v686);
                                                                    let v688 = Some(v687);
                                                                    // Rule at src/isa/x64/lower.isle line 1127.
                                                                    return v688;
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                            _ => {}
                                        }
                                    }
                                    _ => {}
                                }
                            }
                        }
                        let v91 = C::multi_lane(ctx, v3);
                        if let Some(v92) = v91 {
                            if v92.0 == 0x40_u32 {
                                if v92.1 == 0x2_u32 {
                                    let v533 = C::has_avx512vl(ctx);
                                    if v533 == true {
                                        let v713 = C::has_avx512dq(ctx);
                                        if v713 == true {
                                            let v61 = C::unpack_value_array_2(ctx, v60);
                                            let v95 = constructor_put_in_xmm(ctx, v61.0);
                                            let v96 = &C::put_in_xmm_mem_128(ctx, v61.1);
                                            let v714 = constructor_x64_vpmullq(ctx, v95, v96);
                                            let v715 = constructor_output_xmm(ctx, v714);
                                            let v716 = Some(v715);
                                            // Rule at src/isa/x64/lower.isle line 1158.
                                            return v716;
                                        }
                                    }
                                }
                            }
                        }
                        if v3 == I128 {
                            let v61 = C::unpack_value_array_2(ctx, v60);
                            let v109 = C::put_in_regs(ctx, v61.0);
                            let v110 = C::put_in_regs(ctx, v61.1);
                            let v112 = constructor_value_regs_get_gpr(ctx, v109, 0x0_usize);
                            let v114 = constructor_value_regs_get_gpr(ctx, v109, 0x1_usize);
                            let v115 = constructor_value_regs_get_gpr(ctx, v110, 0x0_usize);
                            let v671 = &C::gpr_to_gpr_mem_64(ctx, v115);
                            let v117 = constructor_value_regs_get_gpr(ctx, v110, 0x1_usize);
                            let v672 = &C::gpr_to_gpr_mem_64(ctx, v117);
                            let v673 = constructor_imul128(ctx, v112, v114, v671, v672);
                            let v674 = C::output(ctx, v673);
                            let v675 = Some(v674);
                            // Rule at src/isa/x64/lower.isle line 1073.
                            return v675;
                        }
                        if let Some(v92) = v91 {
                            match v92.0 {
                                0x10_u32 => {
                                    if v92.1 == 0x8_u32 {
                                        let v61 = C::unpack_value_array_2(ctx, v60);
                                        let v95 = constructor_put_in_xmm(ctx, v61.0);
                                        let v96 = &C::put_in_xmm_mem_128(ctx, v61.1);
                                        let v689 = constructor_x64_pmullw(ctx, v95, v96);
                                        let v690 = constructor_output_xmm(ctx, v689);
                                        let v691 = Some(v690);
                                        // Rule at src/isa/x64/lower.isle line 1135.
                                        return v691;
                                    }
                                }
                                0x20_u32 => {
                                    if v92.1 == 0x4_u32 {
                                        let v61 = C::unpack_value_array_2(ctx, v60);
                                        let v122 = C::def_inst(ctx, v61.1);
                                        if let Some(v123) = v122 {
                                            let v124 = C::inst_data_value(ctx, v123);
                                            if let &InstructionData::Unary {
                                                opcode: ref v141,
                                                arg: v142,
                                            } = &v124.1 {
                                                match v141 {
                                                    &Opcode::SwidenLow => {
                                                        let v150 = C::def_inst(ctx, v61.0);
                                                        if let Some(v151) = v150 {
                                                            let v152 = C::inst_data_value(ctx, v151);
                                                            if let &InstructionData::Unary {
                                                                opcode: ref v155,
                                                                arg: v156,
                                                            } = &v152.1 {
                                                                if let &Opcode::SwidenLow = v155 {
                                                                    let v682 = C::value_type(ctx, v156);
                                                                    let v735 = C::multi_lane(ctx, v682);
                                                                    if let Some(v736) = v735 {
                                                                        if v736.0 == 0x10_u32 {
                                                                            if v736.1 == 0x8_u32 {
                                                                                let v143 = C::value_type(ctx, v142);
                                                                                let v739 = C::multi_lane(ctx, v143);
                                                                                if let Some(v740) = v739 {
                                                                                    if v740.0 == 0x10_u32 {
                                                                                        if v740.1 == 0x8_u32 {
                                                                                            let v293 = constructor_put_in_xmm(ctx, v156);
                                                                                            let v743 = constructor_put_in_xmm(ctx, v142);
                                                                                            let v744 = &C::xmm_to_xmm_mem_128(ctx, v743);
                                                                                            let v745 = constructor_x64_pmullw(ctx, v293, v744);
                                                                                            let v746 = &C::xmm_to_xmm_mem_128(ctx, v743);
                                                                                            let v747 = constructor_x64_pmulhw(ctx, v293, v746);
                                                                                            let v748 = &C::xmm_to_xmm_mem_128(ctx, v747);
                                                                                            let v761 = constructor_x64_punpcklwd(ctx, v745, v748);
                                                                                            let v762 = constructor_output_xmm(ctx, v761);
                                                                                            let v763 = Some(v762);
                                                                                            // Rule at src/isa/x64/lower.isle line 1228.
                                                                                            return v763;
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                    &Opcode::SwidenHigh => {
                                                        let v150 = C::def_inst(ctx, v61.0);
                                                        if let Some(v151) = v150 {
                                                            let v152 = C::inst_data_value(ctx, v151);
                                                            if let &InstructionData::Unary {
                                                                opcode: ref v155,
                                                                arg: v156,
                                                            } = &v152.1 {
                                                                if let &Opcode::SwidenHigh = v155 {
                                                                    let v682 = C::value_type(ctx, v156);
                                                                    let v735 = C::multi_lane(ctx, v682);
                                                                    if let Some(v736) = v735 {
                                                                        if v736.0 == 0x10_u32 {
                                                                            if v736.1 == 0x8_u32 {
                                                                                let v143 = C::value_type(ctx, v142);
                                                                                let v739 = C::multi_lane(ctx, v143);
                                                                                if let Some(v740) = v739 {
                                                                                    if v740.0 == 0x10_u32 {
                                                                                        if v740.1 == 0x8_u32 {
                                                                                            let v293 = constructor_put_in_xmm(ctx, v156);
                                                                                            let v743 = constructor_put_in_xmm(ctx, v142);
                                                                                            let v744 = &C::xmm_to_xmm_mem_128(ctx, v743);
                                                                                            let v745 = constructor_x64_pmullw(ctx, v293, v744);
                                                                                            let v746 = &C::xmm_to_xmm_mem_128(ctx, v743);
                                                                                            let v747 = constructor_x64_pmulhw(ctx, v293, v746);
                                                                                            let v748 = &C::xmm_to_xmm_mem_128(ctx, v747);
                                                                                            let v749 = constructor_x64_punpckhwd(ctx, v745, v748);
                                                                                            let v750 = constructor_output_xmm(ctx, v749);
                                                                                            let v751 = Some(v750);
                                                                                            // Rule at src/isa/x64/lower.isle line 1205.
                                                                                            return v751;
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                    &Opcode::UwidenLow => {
                                                        let v150 = C::def_inst(ctx, v61.0);
                                                        if let Some(v151) = v150 {
                                                            let v152 = C::inst_data_value(ctx, v151);
                                                            if let &InstructionData::Unary {
                                                                opcode: ref v155,
                                                                arg: v156,
                                                            } = &v152.1 {
                                                                if let &Opcode::UwidenLow = v155 {
                                                                    let v682 = C::value_type(ctx, v156);
                                                                    let v735 = C::multi_lane(ctx, v682);
                                                                    if let Some(v736) = v735 {
                                                                        if v736.0 == 0x10_u32 {
                                                                            if v736.1 == 0x8_u32 {
                                                                                let v143 = C::value_type(ctx, v142);
                                                                                let v739 = C::multi_lane(ctx, v143);
                                                                                if let Some(v740) = v739 {
                                                                                    if v740.0 == 0x10_u32 {
                                                                                        if v740.1 == 0x8_u32 {
                                                                                            let v293 = constructor_put_in_xmm(ctx, v156);
                                                                                            let v743 = constructor_put_in_xmm(ctx, v142);
                                                                                            let v744 = &C::xmm_to_xmm_mem_128(ctx, v743);
                                                                                            let v745 = constructor_x64_pmullw(ctx, v293, v744);
                                                                                            let v746 = &C::xmm_to_xmm_mem_128(ctx, v743);
                                                                                            let v771 = constructor_x64_pmulhuw(ctx, v293, v746);
                                                                                            let v772 = &C::xmm_to_xmm_mem_128(ctx, v771);
                                                                                            let v779 = constructor_x64_punpcklwd(ctx, v745, v772);
                                                                                            let v780 = constructor_output_xmm(ctx, v779);
                                                                                            let v781 = Some(v780);
                                                                                            // Rule at src/isa/x64/lower.isle line 1273.
                                                                                            return v781;
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                    &Opcode::UwidenHigh => {
                                                        let v150 = C::def_inst(ctx, v61.0);
                                                        if let Some(v151) = v150 {
                                                            let v152 = C::inst_data_value(ctx, v151);
                                                            if let &InstructionData::Unary {
                                                                opcode: ref v155,
                                                                arg: v156,
                                                            } = &v152.1 {
                                                                if let &Opcode::UwidenHigh = v155 {
                                                                    let v682 = C::value_type(ctx, v156);
                                                                    let v735 = C::multi_lane(ctx, v682);
                                                                    if let Some(v736) = v735 {
                                                                        if v736.0 == 0x10_u32 {
                                                                            if v736.1 == 0x8_u32 {
                                                                                let v143 = C::value_type(ctx, v142);
                                                                                let v739 = C::multi_lane(ctx, v143);
                                                                                if let Some(v740) = v739 {
                                                                                    if v740.0 == 0x10_u32 {
                                                                                        if v740.1 == 0x8_u32 {
                                                                                            let v293 = constructor_put_in_xmm(ctx, v156);
                                                                                            let v743 = constructor_put_in_xmm(ctx, v142);
                                                                                            let v744 = &C::xmm_to_xmm_mem_128(ctx, v743);
                                                                                            let v745 = constructor_x64_pmullw(ctx, v293, v744);
                                                                                            let v746 = &C::xmm_to_xmm_mem_128(ctx, v743);
                                                                                            let v771 = constructor_x64_pmulhuw(ctx, v293, v746);
                                                                                            let v772 = &C::xmm_to_xmm_mem_128(ctx, v771);
                                                                                            let v773 = constructor_x64_punpckhwd(ctx, v745, v772);
                                                                                            let v774 = constructor_output_xmm(ctx, v773);
                                                                                            let v775 = Some(v774);
                                                                                            // Rule at src/isa/x64/lower.isle line 1251.
                                                                                            return v775;
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                    _ => {}
                                                }
                                            }
                                        }
                                        let v692 = C::has_sse41(ctx);
                                        if v692 == true {
                                            let v95 = constructor_put_in_xmm(ctx, v61.0);
                                            let v96 = &C::put_in_xmm_mem_128(ctx, v61.1);
                                            let v693 = constructor_x64_pmulld(ctx, v95, v96);
                                            let v694 = constructor_output_xmm(ctx, v693);
                                            let v695 = Some(v694);
                                            // Rule at src/isa/x64/lower.isle line 1138.
                                            return v695;
                                        }
                                        let v95 = constructor_put_in_xmm(ctx, v61.0);
                                        let v277 = constructor_put_in_xmm(ctx, v61.1);
                                        let v514 = &C::xmm_to_xmm_mem_128(ctx, v95);
                                        let v697 = constructor_x64_pshufd(ctx, v514, 0x31_u8);
                                        let v698 = &C::xmm_to_xmm_mem_128(ctx, v277);
                                        let v699 = constructor_x64_pshufd(ctx, v698, 0x31_u8);
                                        let v700 = &C::xmm_to_xmm_mem_128(ctx, v277);
                                        let v701 = constructor_x64_pmuludq(ctx, v95, v700);
                                        let v702 = &C::xmm_to_xmm_mem_128(ctx, v701);
                                        let v704 = constructor_x64_pshufd(ctx, v702, 0x8_u8);
                                        let v705 = &C::xmm_to_xmm_mem_128(ctx, v699);
                                        let v706 = constructor_x64_pmuludq(ctx, v697, v705);
                                        let v707 = &C::xmm_to_xmm_mem_128(ctx, v706);
                                        let v708 = constructor_x64_pshufd(ctx, v707, 0x8_u8);
                                        let v709 = &C::xmm_to_xmm_mem_128(ctx, v708);
                                        let v710 = constructor_x64_punpckldq(ctx, v704, v709);
                                        let v711 = constructor_output_xmm(ctx, v710);
                                        let v712 = Some(v711);
                                        // Rule at src/isa/x64/lower.isle line 1145.
                                        return v712;
                                    }
                                }
                                0x40_u32 => {
                                    if v92.1 == 0x2_u32 {
                                        let v61 = C::unpack_value_array_2(ctx, v60);
                                        let v122 = C::def_inst(ctx, v61.1);
                                        if let Some(v123) = v122 {
                                            let v124 = C::inst_data_value(ctx, v123);
                                            if let &InstructionData::Unary {
                                                opcode: ref v141,
                                                arg: v142,
                                            } = &v124.1 {
                                                match v141 {
                                                    &Opcode::SwidenLow => {
                                                        let v150 = C::def_inst(ctx, v61.0);
                                                        if let Some(v151) = v150 {
                                                            let v152 = C::inst_data_value(ctx, v151);
                                                            if let &InstructionData::Unary {
                                                                opcode: ref v155,
                                                                arg: v156,
                                                            } = &v152.1 {
                                                                if let &Opcode::SwidenLow = v155 {
                                                                    let v692 = C::has_sse41(ctx);
                                                                    if v692 == true {
                                                                        let v682 = C::value_type(ctx, v156);
                                                                        let v735 = C::multi_lane(ctx, v682);
                                                                        if let Some(v736) = v735 {
                                                                            if v736.0 == 0x20_u32 {
                                                                                if v736.1 == 0x4_u32 {
                                                                                    let v143 = C::value_type(ctx, v142);
                                                                                    let v739 = C::multi_lane(ctx, v143);
                                                                                    if let Some(v740) = v739 {
                                                                                        if v740.0 == 0x20_u32 {
                                                                                            if v740.1 == 0x4_u32 {
                                                                                                let v752 = &C::put_in_xmm_mem_128(ctx, v156);
                                                                                                let v765 = constructor_x64_pshufd(ctx, v752, 0x50_u8);
                                                                                                let v755 = &C::put_in_xmm_mem_128(ctx, v142);
                                                                                                let v766 = constructor_x64_pshufd(ctx, v755, 0x50_u8);
                                                                                                let v767 = &C::xmm_to_xmm_mem_128(ctx, v766);
                                                                                                let v768 = constructor_x64_pmuldq(ctx, v765, v767);
                                                                                                let v769 = constructor_output_xmm(ctx, v768);
                                                                                                let v770 = Some(v769);
                                                                                                // Rule at src/isa/x64/lower.isle line 1240.
                                                                                                return v770;
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                    &Opcode::SwidenHigh => {
                                                        let v150 = C::def_inst(ctx, v61.0);
                                                        if let Some(v151) = v150 {
                                                            let v152 = C::inst_data_value(ctx, v151);
                                                            if let &InstructionData::Unary {
                                                                opcode: ref v155,
                                                                arg: v156,
                                                            } = &v152.1 {
                                                                if let &Opcode::SwidenHigh = v155 {
                                                                    let v692 = C::has_sse41(ctx);
                                                                    if v692 == true {
                                                                        let v682 = C::value_type(ctx, v156);
                                                                        let v735 = C::multi_lane(ctx, v682);
                                                                        if let Some(v736) = v735 {
                                                                            if v736.0 == 0x20_u32 {
                                                                                if v736.1 == 0x4_u32 {
                                                                                    let v143 = C::value_type(ctx, v142);
                                                                                    let v739 = C::multi_lane(ctx, v143);
                                                                                    if let Some(v740) = v739 {
                                                                                        if v740.0 == 0x20_u32 {
                                                                                            if v740.1 == 0x4_u32 {
                                                                                                let v752 = &C::put_in_xmm_mem_128(ctx, v156);
                                                                                                let v754 = constructor_x64_pshufd(ctx, v752, 0xfa_u8);
                                                                                                let v755 = &C::put_in_xmm_mem_128(ctx, v142);
                                                                                                let v756 = constructor_x64_pshufd(ctx, v755, 0xfa_u8);
                                                                                                let v757 = &C::xmm_to_xmm_mem_128(ctx, v756);
                                                                                                let v758 = constructor_x64_pmuldq(ctx, v754, v757);
                                                                                                let v759 = constructor_output_xmm(ctx, v758);
                                                                                                let v760 = Some(v759);
                                                                                                // Rule at src/isa/x64/lower.isle line 1217.
                                                                                                return v760;
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                    &Opcode::UwidenLow => {
                                                        let v150 = C::def_inst(ctx, v61.0);
                                                        if let Some(v151) = v150 {
                                                            let v152 = C::inst_data_value(ctx, v151);
                                                            if let &InstructionData::Unary {
                                                                opcode: ref v155,
                                                                arg: v156,
                                                            } = &v152.1 {
                                                                if let &Opcode::UwidenLow = v155 {
                                                                    let v682 = C::value_type(ctx, v156);
                                                                    let v735 = C::multi_lane(ctx, v682);
                                                                    if let Some(v736) = v735 {
                                                                        if v736.0 == 0x20_u32 {
                                                                            if v736.1 == 0x4_u32 {
                                                                                let v143 = C::value_type(ctx, v142);
                                                                                let v739 = C::multi_lane(ctx, v143);
                                                                                if let Some(v740) = v739 {
                                                                                    if v740.0 == 0x20_u32 {
                                                                                        if v740.1 == 0x4_u32 {
                                                                                            let v752 = &C::put_in_xmm_mem_128(ctx, v156);
                                                                                            let v765 = constructor_x64_pshufd(ctx, v752, 0x50_u8);
                                                                                            let v755 = &C::put_in_xmm_mem_128(ctx, v142);
                                                                                            let v766 = constructor_x64_pshufd(ctx, v755, 0x50_u8);
                                                                                            let v767 = &C::xmm_to_xmm_mem_128(ctx, v766);
                                                                                            let v782 = constructor_x64_pmuludq(ctx, v765, v767);
                                                                                            let v783 = constructor_output_xmm(ctx, v782);
                                                                                            let v784 = Some(v783);
                                                                                            // Rule at src/isa/x64/lower.isle line 1285.
                                                                                            return v784;
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                    &Opcode::UwidenHigh => {
                                                        let v150 = C::def_inst(ctx, v61.0);
                                                        if let Some(v151) = v150 {
                                                            let v152 = C::inst_data_value(ctx, v151);
                                                            if let &InstructionData::Unary {
                                                                opcode: ref v155,
                                                                arg: v156,
                                                            } = &v152.1 {
                                                                if let &Opcode::UwidenHigh = v155 {
                                                                    let v682 = C::value_type(ctx, v156);
                                                                    let v735 = C::multi_lane(ctx, v682);
                                                                    if let Some(v736) = v735 {
                                                                        if v736.0 == 0x20_u32 {
                                                                            if v736.1 == 0x4_u32 {
                                                                                let v143 = C::value_type(ctx, v142);
                                                                                let v739 = C::multi_lane(ctx, v143);
                                                                                if let Some(v740) = v739 {
                                                                                    if v740.0 == 0x20_u32 {
                                                                                        if v740.1 == 0x4_u32 {
                                                                                            let v752 = &C::put_in_xmm_mem_128(ctx, v156);
                                                                                            let v754 = constructor_x64_pshufd(ctx, v752, 0xfa_u8);
                                                                                            let v755 = &C::put_in_xmm_mem_128(ctx, v142);
                                                                                            let v756 = constructor_x64_pshufd(ctx, v755, 0xfa_u8);
                                                                                            let v757 = &C::xmm_to_xmm_mem_128(ctx, v756);
                                                                                            let v776 = constructor_x64_pmuludq(ctx, v754, v757);
                                                                                            let v777 = constructor_output_xmm(ctx, v776);
                                                                                            let v778 = Some(v777);
                                                                                            // Rule at src/isa/x64/lower.isle line 1263.
                                                                                            return v778;
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                    _ => {}
                                                }
                                            }
                                        }
                                        let v95 = constructor_put_in_xmm(ctx, v61.0);
                                        let v277 = constructor_put_in_xmm(ctx, v61.1);
                                        let v718 = &C::xmi_imm(ctx, 0x20_u32);
                                        let v719 = constructor_x64_psrlq(ctx, v95, v718);
                                        let v698 = &C::xmm_to_xmm_mem_128(ctx, v277);
                                        let v720 = constructor_x64_pmuludq(ctx, v719, v698);
                                        let v721 = &C::xmi_imm(ctx, 0x20_u32);
                                        let v722 = constructor_x64_psrlq(ctx, v277, v721);
                                        let v723 = &C::xmm_to_xmm_mem_128(ctx, v722);
                                        let v724 = constructor_x64_pmuludq(ctx, v95, v723);
                                        let v725 = &C::xmm_to_xmm_mem_128(ctx, v724);
                                        let v726 = constructor_x64_paddq(ctx, v720, v725);
                                        let v727 = &C::xmi_imm(ctx, 0x20_u32);
                                        let v728 = constructor_x64_psllq(ctx, v726, v727);
                                        let v729 = &C::xmm_to_xmm_mem_128(ctx, v277);
                                        let v730 = constructor_x64_pmuludq(ctx, v95, v729);
                                        let v731 = &C::xmm_to_xmm_mem_128(ctx, v728);
                                        let v732 = constructor_x64_paddq(ctx, v730, v731);
                                        let v733 = constructor_output_xmm(ctx, v732);
                                        let v734 = Some(v733);
                                        // Rule at src/isa/x64/lower.isle line 1183.
                                        return v734;
                                    }
                                }
                                _ => {}
                            }
                        }
                        if v3 == I16 {
                            let v61 = C::unpack_value_array_2(ctx, v60);
                            let v122 = C::def_inst(ctx, v61.1);
                            if let Some(v123) = v122 {
                                let v124 = C::inst_data_value(ctx, v123);
                                if let &InstructionData::Unary {
                                    opcode: ref v141,
                                    arg: v142,
                                } = &v124.1 {
                                    match v141 {
                                        &Opcode::Uextend => {
                                            let v150 = C::def_inst(ctx, v61.0);
                                            if let Some(v151) = v150 {
                                                let v152 = C::inst_data_value(ctx, v151);
                                                if let &InstructionData::Unary {
                                                    opcode: ref v155,
                                                    arg: v156,
                                                } = &v152.1 {
                                                    if let &Opcode::Uextend = v155 {
                                                        let v303 = constructor_put_in_gpr(ctx, v156);
                                                        let v664 = &constructor_put_in_gpr_mem(ctx, v142);
                                                        let v197 = false;
                                                        let v668 = constructor_x64_mul8(ctx, v197, v303, v664);
                                                        let v669 = constructor_output_gpr(ctx, v668);
                                                        let v670 = Some(v669);
                                                        // Rule at src/isa/x64/lower.isle line 1068.
                                                        return v670;
                                                    }
                                                }
                                            }
                                        }
                                        &Opcode::Sextend => {
                                            let v150 = C::def_inst(ctx, v61.0);
                                            if let Some(v151) = v150 {
                                                let v152 = C::inst_data_value(ctx, v151);
                                                if let &InstructionData::Unary {
                                                    opcode: ref v155,
                                                    arg: v156,
                                                } = &v152.1 {
                                                    if let &Opcode::Sextend = v155 {
                                                        let v303 = constructor_put_in_gpr(ctx, v156);
                                                        let v664 = &constructor_put_in_gpr_mem(ctx, v142);
                                                        let v207 = true;
                                                        let v665 = constructor_x64_mul8(ctx, v207, v303, v664);
                                                        let v666 = constructor_output_gpr(ctx, v665);
                                                        let v667 = Some(v666);
                                                        // Rule at src/isa/x64/lower.isle line 1066.
                                                        return v667;
                                                    }
                                                }
                                            }
                                        }
                                        _ => {}
                                    }
                                }
                            }
                        }
                        let v374 = C::ty_int_ref_16_to_64(ctx, v3);
                        if let Some(v375) = v374 {
                            let v61 = C::unpack_value_array_2(ctx, v60);
                            let v657 = C::i64_from_iconst(ctx, v61.0);
                            if let Some(v658) = v657 {
                                let v659 = C::i64_from_i32(ctx, v658);
                                if let Some(v660) = v659 {
                                    let v315 = &constructor_put_in_gpr_mem(ctx, v61.1);
                                    let v661 = constructor_x64_imul_imm(ctx, v375, v315, v660);
                                    let v662 = constructor_output_gpr(ctx, v661);
                                    let v663 = Some(v662);
                                    // Rule at src/isa/x64/lower.isle line 1060.
                                    return v663;
                                }
                            }
                            let v650 = C::i64_from_iconst(ctx, v61.1);
                            if let Some(v651) = v650 {
                                let v652 = C::i64_from_i32(ctx, v651);
                                if let Some(v653) = v652 {
                                    let v309 = &constructor_put_in_gpr_mem(ctx, v61.0);
                                    let v654 = constructor_x64_imul_imm(ctx, v375, v309, v653);
                                    let v655 = constructor_output_gpr(ctx, v654);
                                    let v656 = Some(v655);
                                    // Rule at src/isa/x64/lower.isle line 1058.
                                    return v656;
                                }
                            }
                            let v84 = &C::sinkable_load(ctx, v61.0);
                            if let Some(v85) = v84 {
                                let v86 = constructor_put_in_gpr(ctx, v61.1);
                                let v640 = &constructor_sink_load_to_gpr_mem(ctx, v85);
                                let v647 = constructor_x64_imul(ctx, v375, v86, v640);
                                let v648 = constructor_output_gpr(ctx, v647);
                                let v649 = Some(v648);
                                // Rule at src/isa/x64/lower.isle line 1054.
                                return v649;
                            }
                            let v64 = constructor_put_in_gpr(ctx, v61.0);
                            let v198 = &constructor_put_in_gpr_mem(ctx, v61.1);
                            let v644 = constructor_x64_imul(ctx, v375, v64, v198);
                            let v645 = constructor_output_gpr(ctx, v644);
                            let v646 = Some(v645);
                            // Rule at src/isa/x64/lower.isle line 1052.
                            return v646;
                        }
                        if v3 == I8 {
                            let v61 = C::unpack_value_array_2(ctx, v60);
                            let v84 = &C::sinkable_load(ctx, v61.0);
                            if let Some(v85) = v84 {
                                let v86 = constructor_put_in_gpr(ctx, v61.1);
                                let v640 = &constructor_sink_load_to_gpr_mem(ctx, v85);
                                let v197 = false;
                                let v641 = constructor_x64_mul8(ctx, v197, v86, v640);
                                let v642 = constructor_output_gpr(ctx, v641);
                                let v643 = Some(v642);
                                // Rule at src/isa/x64/lower.isle line 1049.
                                return v643;
                            }
                            let v64 = constructor_put_in_gpr(ctx, v61.0);
                            let v198 = &constructor_put_in_gpr_mem(ctx, v61.1);
                            let v197 = false;
                            let v637 = constructor_x64_mul8(ctx, v197, v64, v198);
                            let v638 = constructor_output_gpr(ctx, v637);
                            let v639 = Some(v638);
                            // Rule at src/isa/x64/lower.isle line 1048.
                            return v639;
                        }
                    }
                }
                &Opcode::Umulhi => {
                    let v326 = C::has_bmi2(ctx);
                    if v326 == true {
                        let v61 = C::unpack_value_array_2(ctx, v60);
                        let v2949 = C::value_type(ctx, v61.0);
                        let v3124 = C::ty_32_or_64(ctx, v2949);
                        if let Some(v3125) = v3124 {
                            let v64 = constructor_put_in_gpr(ctx, v61.0);
                            let v198 = &constructor_put_in_gpr_mem(ctx, v61.1);
                            let v3126 = constructor_x64_mulx_hi(ctx, v3125, v64, v198);
                            let v3127 = constructor_output_gpr(ctx, v3126);
                            let v3128 = Some(v3127);
                            // Rule at src/isa/x64/lower.isle line 4568.
                            return v3128;
                        }
                    }
                    let v61 = C::unpack_value_array_2(ctx, v60);
                    let v2949 = C::value_type(ctx, v61.0);
                    let v3118 = C::ty_int_ref_16_to_64(ctx, v2949);
                    if let Some(v3119) = v3118 {
                        let v64 = constructor_put_in_gpr(ctx, v61.0);
                        let v198 = &constructor_put_in_gpr_mem(ctx, v61.1);
                        let v197 = false;
                        let v3120 = constructor_x64_mul(ctx, v3119, v197, v64, v198);
                        let v3121 = constructor_value_regs_get_gpr(ctx, v3120, 0x1_usize);
                        let v3122 = constructor_output_gpr(ctx, v3121);
                        let v3123 = Some(v3122);
                        // Rule at src/isa/x64/lower.isle line 4561.
                        return v3123;
                    }
                    if v2949 == I8 {
                        let v64 = constructor_put_in_gpr(ctx, v61.0);
                        let v198 = &constructor_put_in_gpr_mem(ctx, v61.1);
                        let v197 = false;
                        let v637 = constructor_x64_mul8(ctx, v197, v64, v198);
                        let v3115 = constructor_x64_shrw_mi(ctx, v637, 0x8_u8);
                        let v3116 = constructor_output_gpr(ctx, v3115);
                        let v3117 = Some(v3116);
                        // Rule at src/isa/x64/lower.isle line 4558.
                        return v3117;
                    }
                }
                &Opcode::Smulhi => {
                    let v61 = C::unpack_value_array_2(ctx, v60);
                    let v2949 = C::value_type(ctx, v61.0);
                    let v3118 = C::ty_int_ref_16_to_64(ctx, v2949);
                    if let Some(v3119) = v3118 {
                        let v64 = constructor_put_in_gpr(ctx, v61.0);
                        let v198 = &constructor_put_in_gpr_mem(ctx, v61.1);
                        let v207 = true;
                        let v3133 = constructor_x64_mul(ctx, v3119, v207, v64, v198);
                        let v3134 = constructor_value_regs_get_gpr(ctx, v3133, 0x1_usize);
                        let v3135 = constructor_output_gpr(ctx, v3134);
                        let v3136 = Some(v3135);
                        // Rule at src/isa/x64/lower.isle line 4577.
                        return v3136;
                    }
                    if v2949 == I8 {
                        let v64 = constructor_put_in_gpr(ctx, v61.0);
                        let v198 = &constructor_put_in_gpr_mem(ctx, v61.1);
                        let v207 = true;
                        let v3129 = constructor_x64_mul8(ctx, v207, v64, v198);
                        let v3130 = constructor_x64_sarw_mi(ctx, v3129, 0x8_u8);
                        let v3131 = constructor_output_gpr(ctx, v3130);
                        let v3132 = Some(v3131);
                        // Rule at src/isa/x64/lower.isle line 4574.
                        return v3132;
                    }
                }
                &Opcode::SqmulRoundSat => {
                    let v61 = C::unpack_value_array_2(ctx, v60);
                    let v2949 = C::value_type(ctx, v61.0);
                    if v2949 == I16X8 {
                        let v785 = C::has_ssse3(ctx);
                        if v785 == true {
                            let v95 = constructor_put_in_xmm(ctx, v61.0);
                            let v277 = constructor_put_in_xmm(ctx, v61.1);
                            let v3509 = &constructor_emit_xmm_mem_128_le_const(ctx, 0x80008000800080008000800080008000_u128);
                            let v3510 = &C::xmm_to_xmm_mem_128(ctx, v277);
                            let v3511 = constructor_x64_pmulhrsw(ctx, v95, v3510);
                            let v3512 = constructor_x64_pcmpeqw(ctx, v3511, v3509);
                            let v3513 = &C::xmm_to_xmm_mem_128(ctx, v3512);
                            let v3514 = constructor_x64_pxor(ctx, v3511, v3513);
                            let v3515 = constructor_output_xmm(ctx, v3514);
                            let v3516 = Some(v3515);
                            // Rule at src/isa/x64/lower.isle line 5098.
                            return v3516;
                        }
                        let v95 = constructor_put_in_xmm(ctx, v61.0);
                        let v277 = constructor_put_in_xmm(ctx, v61.1);
                        let v278 = &C::xmm_to_xmm_mem_128(ctx, v277);
                        let v3517 = constructor_x64_pmullw(ctx, v95, v278);
                        let v698 = &C::xmm_to_xmm_mem_128(ctx, v277);
                        let v3518 = constructor_x64_pmulhw(ctx, v95, v698);
                        let v3519 = &C::xmm_to_xmm_mem_128(ctx, v3518);
                        let v3520 = constructor_x64_punpcklwd(ctx, v3517, v3519);
                        let v3521 = &C::xmm_to_xmm_mem_128(ctx, v3518);
                        let v3522 = constructor_x64_punpckhwd(ctx, v3517, v3521);
                        let v3524 = &constructor_emit_xmm_mem_128_le_const(ctx, 0x4000000040000000400000004000_u128);
                        let v3525 = constructor_x64_movdqu_load(ctx, v3524);
                        let v3526 = &C::xmm_to_xmm_mem_128(ctx, v3525);
                        let v3527 = constructor_x64_paddd(ctx, v3520, v3526);
                        let v3528 = &C::xmm_to_xmm_mem_128(ctx, v3525);
                        let v3529 = constructor_x64_paddd(ctx, v3522, v3528);
                        let v3531 = &C::xmi_imm(ctx, 0xf_u32);
                        let v3532 = constructor_x64_psrad(ctx, v3527, v3531);
                        let v3533 = &C::xmi_imm(ctx, 0xf_u32);
                        let v3534 = constructor_x64_psrad(ctx, v3529, v3533);
                        let v3535 = &C::xmm_to_xmm_mem_128(ctx, v3534);
                        let v3536 = constructor_x64_packssdw(ctx, v3532, v3535);
                        let v3537 = constructor_output_xmm(ctx, v3536);
                        let v3538 = Some(v3537);
                        // Rule at src/isa/x64/lower.isle line 5114.
                        return v3538;
                    }
                }
                &Opcode::X86Pmulhrsw => {
                    let v785 = C::has_ssse3(ctx);
                    if v785 == true {
                        let v61 = C::unpack_value_array_2(ctx, v60);
                        let v2949 = C::value_type(ctx, v61.0);
                        if v2949 == I16X8 {
                            let v95 = constructor_put_in_xmm(ctx, v61.0);
                            let v96 = &C::put_in_xmm_mem_128(ctx, v61.1);
                            let v3539 = constructor_x64_pmulhrsw(ctx, v95, v96);
                            let v3540 = constructor_output_xmm(ctx, v3539);
                            let v3541 = Some(v3540);
                            // Rule at src/isa/x64/lower.isle line 5140.
                            return v3541;
                        }
                    }
                }
                &Opcode::Udiv => {
                    let v61 = C::unpack_value_array_2(ctx, v60);
                    let v2949 = C::value_type(ctx, v61.0);
                    if v2949 == I8 {
                        let v3053 = constructor_extend_to_gpr(ctx, v61.0, I32, &ExtendKind::Zero);
                        let v560 = constructor_put_in_gpr(ctx, v61.1);
                        let v3054 = &C::gpr_to_gpr_mem_8(ctx, v560);
                        let v3056 = constructor_x64_divb_m(ctx, v3053, v3054, &TrapCode::INTEGER_DIVISION_BY_ZERO);
                        let v3057 = constructor_output_gpr(ctx, v3056);
                        let v3058 = Some(v3057);
                        // Rule at src/isa/x64/lower.isle line 4447.
                        return v3058;
                    }
                    let v3059 = C::fits_in_64(ctx, v2949);
                    if let Some(v3060) = v3059 {
                        let v64 = constructor_put_in_gpr(ctx, v61.0);
                        let v18 = constructor_imm(ctx, I64, 0x0_u64);
                        let v3061 = C::gpr_new(ctx, v18);
                        let v3062 = constructor_put_in_gpr(ctx, v61.1);
                        let v3063 = &C::gpr_to_gpr_mem(ctx, v3062);
                        let v3064 = constructor_x64_div(ctx, v3060, v64, v3061, v3063, &TrapCode::INTEGER_DIVISION_BY_ZERO);
                        let v3065 = C::value_regs_get(ctx, v3064, 0x0_usize);
                        let v3066 = constructor_output_reg(ctx, v3065);
                        let v3067 = Some(v3066);
                        // Rule at src/isa/x64/lower.isle line 4455.
                        return v3067;
                    }
                }
                &Opcode::Sdiv => {
                    let v61 = C::unpack_value_array_2(ctx, v60);
                    let v2949 = C::value_type(ctx, v61.0);
                    if v2949 == I8 {
                        let v64 = constructor_put_in_gpr(ctx, v61.0);
                        let v3068 = constructor_x64_cbtw_zo(ctx, v64);
                        let v3069 = constructor_nonzero_sdiv_divisor(ctx, I8, v61.1);
                        let v3070 = &C::reg_to_gpr_mem_8(ctx, v3069);
                        let v3072 = constructor_x64_idivb_m(ctx, v3068, v3070, &TrapCode::INTEGER_OVERFLOW);
                        let v3073 = constructor_output_gpr(ctx, v3072);
                        let v3074 = Some(v3073);
                        // Rule at src/isa/x64/lower.isle line 4462.
                        return v3074;
                    }
                    let v3059 = C::fits_in_64(ctx, v2949);
                    if let Some(v3060) = v3059 {
                        let v64 = constructor_put_in_gpr(ctx, v61.0);
                        let v3075 = constructor_repeat_sign_bit(ctx, v3060, v64);
                        let v3076 = constructor_nonzero_sdiv_divisor(ctx, v3060, v61.1);
                        let v3077 = &C::reg_to_gpr_mem(ctx, v3076);
                        let v3078 = constructor_x64_idiv(ctx, v3060, v64, v3075, v3077, &TrapCode::INTEGER_OVERFLOW);
                        let v3079 = C::value_regs_get(ctx, v3078, 0x0_usize);
                        let v3080 = constructor_output_reg(ctx, v3079);
                        let v3081 = Some(v3080);
                        // Rule at src/isa/x64/lower.isle line 4467.
                        return v3081;
                    }
                }
                &Opcode::Urem => {
                    let v61 = C::unpack_value_array_2(ctx, v60);
                    let v2949 = C::value_type(ctx, v61.0);
                    if v2949 == I8 {
                        let v3053 = constructor_extend_to_gpr(ctx, v61.0, I32, &ExtendKind::Zero);
                        let v560 = constructor_put_in_gpr(ctx, v61.1);
                        let v3054 = &C::gpr_to_gpr_mem_8(ctx, v560);
                        let v3056 = constructor_x64_divb_m(ctx, v3053, v3054, &TrapCode::INTEGER_DIVISION_BY_ZERO);
                        let v3082 = constructor_x64_shrq_mi(ctx, v3056, 0x8_u8);
                        let v3083 = constructor_output_gpr(ctx, v3082);
                        let v3084 = Some(v3083);
                        // Rule at src/isa/x64/lower.isle line 4505.
                        return v3084;
                    }
                    let v3059 = C::fits_in_64(ctx, v2949);
                    if let Some(v3060) = v3059 {
                        let v64 = constructor_put_in_gpr(ctx, v61.0);
                        let v18 = constructor_imm(ctx, I64, 0x0_u64);
                        let v3061 = C::gpr_new(ctx, v18);
                        let v3062 = constructor_put_in_gpr(ctx, v61.1);
                        let v3063 = &C::gpr_to_gpr_mem(ctx, v3062);
                        let v3064 = constructor_x64_div(ctx, v3060, v64, v3061, v3063, &TrapCode::INTEGER_DIVISION_BY_ZERO);
                        let v3085 = C::value_regs_get(ctx, v3064, 0x1_usize);
                        let v3086 = constructor_output_reg(ctx, v3085);
                        let v3087 = Some(v3086);
                        // Rule at src/isa/x64/lower.isle line 4513.
                        return v3087;
                    }
                }
                &Opcode::Srem => {
                    let v61 = C::unpack_value_array_2(ctx, v60);
                    let v122 = C::def_inst(ctx, v61.1);
                    if let Some(v123) = v122 {
                        let v124 = C::inst_data_value(ctx, v123);
                        if let &InstructionData::UnaryImm {
                            opcode: ref v531,
                            imm: v532,
                        } = &v124.1 {
                            if let &Opcode::Iconst = v531 {
                                let v2949 = C::value_type(ctx, v61.0);
                                if v2949 == I8 {
                                    let v3088 = C::safe_divisor_from_imm64(ctx, I8, v532);
                                    if let Some(v3089) = v3088 {
                                        let v64 = constructor_put_in_gpr(ctx, v61.0);
                                        let v3068 = constructor_x64_cbtw_zo(ctx, v64);
                                        let v3090 = constructor_imm(ctx, I8, v3089);
                                        let v3091 = &C::reg_to_gpr_mem_8(ctx, v3090);
                                        let v3092 = constructor_x64_idivb_m(ctx, v3068, v3091, &TrapCode::INTEGER_DIVISION_BY_ZERO);
                                        let v3093 = constructor_x64_shrq_mi(ctx, v3092, 0x8_u8);
                                        let v3094 = constructor_output_gpr(ctx, v3093);
                                        let v3095 = Some(v3094);
                                        // Rule at src/isa/x64/lower.isle line 4525.
                                        return v3095;
                                    }
                                }
                                let v3096 = C::safe_divisor_from_imm64(ctx, v2949, v532);
                                if let Some(v3097) = v3096 {
                                    let v64 = constructor_put_in_gpr(ctx, v61.0);
                                    let v3098 = &C::raw_operand_size_of_type(ctx, v2949);
                                    let v3099 = constructor_repeat_sign_bit(ctx, v2949, v64);
                                    let v3100 = constructor_imm(ctx, v2949, v3097);
                                    let v3101 = &C::reg_to_gpr_mem(ctx, v3100);
                                    let v3102 = constructor_x64_idiv(ctx, v2949, v64, v3099, v3101, &TrapCode::INTEGER_DIVISION_BY_ZERO);
                                    let v3103 = C::value_regs_get(ctx, v3102, 0x1_usize);
                                    let v3104 = constructor_output_reg(ctx, v3103);
                                    let v3105 = Some(v3104);
                                    // Rule at src/isa/x64/lower.isle line 4534.
                                    return v3105;
                                }
                            }
                        }
                    }
                    let v2949 = C::value_type(ctx, v61.0);
                    if v2949 == I8 {
                        let v64 = constructor_put_in_gpr(ctx, v61.0);
                        let v3068 = constructor_x64_cbtw_zo(ctx, v64);
                        let v3106 = constructor_put_in_gpr(ctx, v61.1);
                        let v3107 = constructor_x64_checked_srem_seq8(ctx, v3068, v3106);
                        let v3108 = constructor_x64_shrq_mi(ctx, v3107, 0x8_u8);
                        let v3109 = constructor_output_gpr(ctx, v3108);
                        let v3110 = Some(v3109);
                        // Rule at src/isa/x64/lower.isle line 4544.
                        return v3110;
                    }
                    let v64 = constructor_put_in_gpr(ctx, v61.0);
                    let v3098 = &C::raw_operand_size_of_type(ctx, v2949);
                    let v3099 = constructor_repeat_sign_bit(ctx, v2949, v64);
                    let v3062 = constructor_put_in_gpr(ctx, v61.1);
                    let v3111 = constructor_x64_checked_srem_seq(ctx, v3098, v64, v3099, v3062);
                    let v3112 = C::value_regs_get(ctx, v3111, 0x1_usize);
                    let v3113 = constructor_output_reg(ctx, v3112);
                    let v3114 = Some(v3113);
                    // Rule at src/isa/x64/lower.isle line 4547.
                    return v3114;
                }
                &Opcode::UaddOverflow => {
                    let v61 = C::unpack_value_array_2(ctx, v60);
                    let v173 = C::value_type(ctx, v61.1);
                    let v174 = C::fits_in_64(ctx, v173);
                    if let Some(v175) = v174 {
                        let v64 = constructor_put_in_gpr(ctx, v61.0);
                        let v65 = &constructor_put_in_gpr_mem_imm(ctx, v61.1);
                        let v177 = constructor_construct_overflow_op_alu(ctx, v175, &CC::B, &ProduceFlagsOp::Add, v64, v65);
                        let v178 = Some(v177);
                        // Rule at src/isa/x64/lower.isle line 175.
                        return v178;
                    }
                    if v173 == I128 {
                        let v180 = constructor_construct_overflow_op_alu_128(ctx, &CC::B, &ProduceFlagsOp::Add, &ChainFlagsOp::Adc, v61.0, v61.1);
                        let v181 = Some(v180);
                        // Rule at src/isa/x64/lower.isle line 179.
                        return v181;
                    }
                }
                &Opcode::SaddOverflow => {
                    let v61 = C::unpack_value_array_2(ctx, v60);
                    let v173 = C::value_type(ctx, v61.1);
                    let v174 = C::fits_in_64(ctx, v173);
                    if let Some(v175) = v174 {
                        let v64 = constructor_put_in_gpr(ctx, v61.0);
                        let v65 = &constructor_put_in_gpr_mem_imm(ctx, v61.1);
                        let v183 = constructor_construct_overflow_op_alu(ctx, v175, &CC::O, &ProduceFlagsOp::Add, v64, v65);
                        let v184 = Some(v183);
                        // Rule at src/isa/x64/lower.isle line 184.
                        return v184;
                    }
                    if v173 == I128 {
                        let v185 = constructor_construct_overflow_op_alu_128(ctx, &CC::O, &ProduceFlagsOp::Add, &ChainFlagsOp::Adc, v61.0, v61.1);
                        let v186 = Some(v185);
                        // Rule at src/isa/x64/lower.isle line 187.
                        return v186;
                    }
                }
                &Opcode::UsubOverflow => {
                    let v61 = C::unpack_value_array_2(ctx, v60);
                    let v173 = C::value_type(ctx, v61.1);
                    let v174 = C::fits_in_64(ctx, v173);
                    if let Some(v175) = v174 {
                        let v64 = constructor_put_in_gpr(ctx, v61.0);
                        let v65 = &constructor_put_in_gpr_mem_imm(ctx, v61.1);
                        let v188 = constructor_construct_overflow_op_alu(ctx, v175, &CC::B, &ProduceFlagsOp::Sub, v64, v65);
                        let v189 = Some(v188);
                        // Rule at src/isa/x64/lower.isle line 192.
                        return v189;
                    }
                    if v173 == I128 {
                        let v191 = constructor_construct_overflow_op_alu_128(ctx, &CC::B, &ProduceFlagsOp::Sub, &ChainFlagsOp::Sbb, v61.0, v61.1);
                        let v192 = Some(v191);
                        // Rule at src/isa/x64/lower.isle line 195.
                        return v192;
                    }
                }
                &Opcode::SsubOverflow => {
                    let v61 = C::unpack_value_array_2(ctx, v60);
                    let v173 = C::value_type(ctx, v61.1);
                    let v174 = C::fits_in_64(ctx, v173);
                    if let Some(v175) = v174 {
                        let v64 = constructor_put_in_gpr(ctx, v61.0);
                        let v65 = &constructor_put_in_gpr_mem_imm(ctx, v61.1);
                        let v193 = constructor_construct_overflow_op_alu(ctx, v175, &CC::O, &ProduceFlagsOp::Sub, v64, v65);
                        let v194 = Some(v193);
                        // Rule at src/isa/x64/lower.isle line 200.
                        return v194;
                    }
                    if v173 == I128 {
                        let v195 = constructor_construct_overflow_op_alu_128(ctx, &CC::O, &ProduceFlagsOp::Sub, &ChainFlagsOp::Sbb, v61.0, v61.1);
                        let v196 = Some(v195);
                        // Rule at src/isa/x64/lower.isle line 203.
                        return v196;
                    }
                }
                &Opcode::UmulOverflow => {
                    let v61 = C::unpack_value_array_2(ctx, v60);
                    let v173 = C::value_type(ctx, v61.1);
                    let v202 = C::ty_int_ref_16_to_64(ctx, v173);
                    if let Some(v203) = v202 {
                        let v64 = constructor_put_in_gpr(ctx, v61.0);
                        let v198 = &constructor_put_in_gpr_mem(ctx, v61.1);
                        let v197 = false;
                        let v204 = &constructor_x64_mul_lo_with_flags_paired(ctx, v203, v197, v64, v198);
                        let v205 = constructor_construct_overflow_op(ctx, &CC::O, v204);
                        let v206 = Some(v205);
                        // Rule at src/isa/x64/lower.isle line 211.
                        return v206;
                    }
                    if v173 == I8 {
                        let v64 = constructor_put_in_gpr(ctx, v61.0);
                        let v198 = &constructor_put_in_gpr_mem(ctx, v61.1);
                        let v197 = false;
                        let v199 = &constructor_x64_mul8_with_flags_paired(ctx, v197, v64, v198);
                        let v200 = constructor_construct_overflow_op(ctx, &CC::O, v199);
                        let v201 = Some(v200);
                        // Rule at src/isa/x64/lower.isle line 208.
                        return v201;
                    }
                }
                &Opcode::SmulOverflow => {
                    let v61 = C::unpack_value_array_2(ctx, v60);
                    let v173 = C::value_type(ctx, v61.1);
                    let v202 = C::ty_int_ref_16_to_64(ctx, v173);
                    if let Some(v203) = v202 {
                        let v64 = constructor_put_in_gpr(ctx, v61.0);
                        let v198 = &constructor_put_in_gpr_mem(ctx, v61.1);
                        let v207 = true;
                        let v211 = &constructor_x64_mul_lo_with_flags_paired(ctx, v203, v207, v64, v198);
                        let v212 = constructor_construct_overflow_op(ctx, &CC::O, v211);
                        let v213 = Some(v212);
                        // Rule at src/isa/x64/lower.isle line 219.
                        return v213;
                    }
                    if v173 == I8 {
                        let v64 = constructor_put_in_gpr(ctx, v61.0);
                        let v198 = &constructor_put_in_gpr_mem(ctx, v61.1);
                        let v207 = true;
                        let v208 = &constructor_x64_mul8_with_flags_paired(ctx, v207, v64, v198);
                        let v209 = constructor_construct_overflow_op(ctx, &CC::O, v208);
                        let v210 = Some(v209);
                        // Rule at src/isa/x64/lower.isle line 216.
                        return v210;
                    }
                }
                &Opcode::Band => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        let v69 = C::ty_32_or_64(ctx, v3);
                        if let Some(v70) = v69 {
                            let v61 = C::unpack_value_array_2(ctx, v60);
                            let v307 = constructor_val_minus_one(ctx, v61.1);
                            if let Some(v308) = v307 {
                                let v326 = C::has_bmi2(ctx);
                                if v326 == true {
                                    let v327 = C::def_inst(ctx, v308);
                                    if let Some(v328) = v327 {
                                        let v329 = C::inst_data_value(ctx, v328);
                                        if let &InstructionData::Binary {
                                            opcode: ref v332,
                                            args: ref v333,
                                        } = &v329.1 {
                                            if let &Opcode::Ishl = v332 {
                                                let v334 = C::unpack_value_array_2(ctx, v333);
                                                let v337 = C::def_inst(ctx, v334.0);
                                                if let Some(v338) = v337 {
                                                    let v339 = C::inst_data_value(ctx, v338);
                                                    if let &InstructionData::UnaryImm {
                                                        opcode: ref v342,
                                                        imm: v343,
                                                    } = &v339.1 {
                                                        if let &Opcode::Iconst = v342 {
                                                            let v344 = C::u64_from_imm64(ctx, v343);
                                                            if v344 == 0x1_u64 {
                                                                let v309 = &constructor_put_in_gpr_mem(ctx, v61.0);
                                                                let v345 = constructor_put_in_gpr(ctx, v334.1);
                                                                let v346 = C::ty_bits(ctx, v70);
                                                                let v347 = C::u8_into_u32(ctx, v346);
                                                                let v349 = C::u32_wrapping_sub(ctx, v347, 0x1_u32);
                                                                let v350 = RegMemImm::Imm {
                                                                    simm32: v349,
                                                                };
                                                                let v351 = &C::gpr_mem_imm_new(ctx, &v350);
                                                                let v352 = constructor_x64_and(ctx, v70, v345, v351);
                                                                let v353 = constructor_x64_bzhi(ctx, v70, v309, v352);
                                                                let v354 = constructor_output_gpr(ctx, v353);
                                                                let v355 = Some(v354);
                                                                // Rule at src/isa/x64/lower.isle line 437.
                                                                return v355;
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            let v297 = C::has_bmi1(ctx);
                            if v297 == true {
                                let v122 = C::def_inst(ctx, v61.1);
                                if let Some(v123) = v122 {
                                    let v124 = C::inst_data_value(ctx, v123);
                                    if let &InstructionData::Unary {
                                        opcode: ref v141,
                                        arg: v142,
                                    } = &v124.1 {
                                        if let &Opcode::Ineg = v141 {
                                            if v61.0 == v142 {
                                                let v309 = &constructor_put_in_gpr_mem(ctx, v61.0);
                                                let v323 = constructor_x64_blsi(ctx, v70, v309);
                                                let v324 = constructor_output_gpr(ctx, v323);
                                                let v325 = Some(v324);
                                                // Rule at src/isa/x64/lower.isle line 424.
                                                return v325;
                                            }
                                        }
                                    }
                                }
                                let v150 = C::def_inst(ctx, v61.0);
                                if let Some(v151) = v150 {
                                    let v152 = C::inst_data_value(ctx, v151);
                                    if let &InstructionData::Unary {
                                        opcode: ref v155,
                                        arg: v156,
                                    } = &v152.1 {
                                        if let &Opcode::Ineg = v155 {
                                            if v61.1 == v156 {
                                                let v319 = &constructor_put_in_gpr_mem(ctx, v156);
                                                let v320 = constructor_x64_blsi(ctx, v70, v319);
                                                let v321 = constructor_output_gpr(ctx, v320);
                                                let v322 = Some(v321);
                                                // Rule at src/isa/x64/lower.isle line 421.
                                                return v322;
                                            }
                                        }
                                    }
                                }
                                let v313 = constructor_val_minus_one(ctx, v61.0);
                                if let Some(v314) = v313 {
                                    if v61.1 == v314 {
                                        let v315 = &constructor_put_in_gpr_mem(ctx, v61.1);
                                        let v316 = constructor_x64_blsr(ctx, v70, v315);
                                        let v317 = constructor_output_gpr(ctx, v316);
                                        let v318 = Some(v317);
                                        // Rule at src/isa/x64/lower.isle line 414.
                                        return v318;
                                    }
                                }
                                if let Some(v308) = v307 {
                                    if v61.0 == v308 {
                                        let v309 = &constructor_put_in_gpr_mem(ctx, v61.0);
                                        let v310 = constructor_x64_blsr(ctx, v70, v309);
                                        let v311 = constructor_output_gpr(ctx, v310);
                                        let v312 = Some(v311);
                                        // Rule at src/isa/x64/lower.isle line 410.
                                        return v312;
                                    }
                                }
                            }
                        }
                        let v262 = C::ty_int_ref_scalar_64(ctx, v3);
                        if let Some(v263) = v262 {
                            let v297 = C::has_bmi1(ctx);
                            if v297 == true {
                                let v61 = C::unpack_value_array_2(ctx, v60);
                                let v150 = C::def_inst(ctx, v61.0);
                                if let Some(v151) = v150 {
                                    let v152 = C::inst_data_value(ctx, v151);
                                    if let &InstructionData::Unary {
                                        opcode: ref v155,
                                        arg: v156,
                                    } = &v152.1 {
                                        if let &Opcode::Bnot = v155 {
                                            let v303 = constructor_put_in_gpr(ctx, v156);
                                            let v198 = &constructor_put_in_gpr_mem(ctx, v61.1);
                                            let v304 = constructor_x64_andn(ctx, v3, v303, v198);
                                            let v305 = constructor_output_gpr(ctx, v304);
                                            let v306 = Some(v305);
                                            // Rule at src/isa/x64/lower.isle line 398.
                                            return v306;
                                        }
                                    }
                                }
                                let v122 = C::def_inst(ctx, v61.1);
                                if let Some(v123) = v122 {
                                    let v124 = C::inst_data_value(ctx, v123);
                                    if let &InstructionData::Unary {
                                        opcode: ref v141,
                                        arg: v142,
                                    } = &v124.1 {
                                        if let &Opcode::Bnot = v141 {
                                            let v298 = constructor_put_in_gpr(ctx, v142);
                                            let v299 = &constructor_put_in_gpr_mem(ctx, v61.0);
                                            let v300 = constructor_x64_andn(ctx, v3, v298, v299);
                                            let v301 = constructor_output_gpr(ctx, v300);
                                            let v302 = Some(v301);
                                            // Rule at src/isa/x64/lower.isle line 393.
                                            return v302;
                                        }
                                    }
                                }
                            }
                        }
                        let v91 = C::multi_lane(ctx, v3);
                        if let Some(v92) = v91 {
                            let v61 = C::unpack_value_array_2(ctx, v60);
                            let v150 = C::def_inst(ctx, v61.0);
                            if let Some(v151) = v150 {
                                let v152 = C::inst_data_value(ctx, v151);
                                if let &InstructionData::Unary {
                                    opcode: ref v155,
                                    arg: v156,
                                } = &v152.1 {
                                    if let &Opcode::Bnot = v155 {
                                        let v293 = constructor_put_in_xmm(ctx, v156);
                                        let v96 = &C::put_in_xmm_mem_128(ctx, v61.1);
                                        let v294 = constructor_sse_and_not(ctx, v3, v293, v96);
                                        let v295 = constructor_output_xmm(ctx, v294);
                                        let v296 = Some(v295);
                                        // Rule at src/isa/x64/lower.isle line 390.
                                        return v296;
                                    }
                                }
                            }
                            let v122 = C::def_inst(ctx, v61.1);
                            if let Some(v123) = v122 {
                                let v124 = C::inst_data_value(ctx, v123);
                                if let &InstructionData::Unary {
                                    opcode: ref v141,
                                    arg: v142,
                                } = &v124.1 {
                                    if let &Opcode::Bnot = v141 {
                                        let v288 = constructor_put_in_xmm(ctx, v142);
                                        let v289 = &C::put_in_xmm_mem_128(ctx, v61.0);
                                        let v290 = constructor_sse_and_not(ctx, v3, v288, v289);
                                        let v291 = constructor_output_xmm(ctx, v290);
                                        let v292 = Some(v291);
                                        // Rule at src/isa/x64/lower.isle line 388.
                                        return v292;
                                    }
                                }
                            }
                        }
                        if v3 == I128 {
                            let v61 = C::unpack_value_array_2(ctx, v60);
                            let v109 = C::put_in_regs(ctx, v61.0);
                            let v110 = C::put_in_regs(ctx, v61.1);
                            let v285 = constructor_and_i128(ctx, v109, v110);
                            let v286 = C::output(ctx, v285);
                            let v287 = Some(v286);
                            // Rule at src/isa/x64/lower.isle line 369.
                            return v287;
                        }
                        if let Some(v92) = v91 {
                            let v61 = C::unpack_value_array_2(ctx, v60);
                            let v95 = constructor_put_in_xmm(ctx, v61.0);
                            let v96 = &C::put_in_xmm_mem_128(ctx, v61.1);
                            let v282 = constructor_sse_and(ctx, v3, v95, v96);
                            let v283 = constructor_output_xmm(ctx, v282);
                            let v284 = Some(v283);
                            // Rule at src/isa/x64/lower.isle line 352.
                            return v284;
                        }
                        let v275 = C::ty_scalar_float(ctx, v3);
                        if let Some(v276) = v275 {
                            let v61 = C::unpack_value_array_2(ctx, v60);
                            let v95 = constructor_put_in_xmm(ctx, v61.0);
                            let v277 = constructor_put_in_xmm(ctx, v61.1);
                            let v278 = &C::xmm_to_xmm_mem_128(ctx, v277);
                            let v279 = constructor_sse_and(ctx, v276, v95, v278);
                            let v280 = constructor_output_xmm(ctx, v279);
                            let v281 = Some(v280);
                            // Rule at src/isa/x64/lower.isle line 340.
                            return v281;
                        }
                        if let Some(v263) = v262 {
                            let v61 = C::unpack_value_array_2(ctx, v60);
                            let v270 = &C::simm32_from_value(ctx, v61.0);
                            if let Some(v271) = v270 {
                                let v86 = constructor_put_in_gpr(ctx, v61.1);
                                let v272 = constructor_x64_and(ctx, v3, v86, v271);
                                let v273 = constructor_output_gpr(ctx, v272);
                                let v274 = Some(v273);
                                // Rule at src/isa/x64/lower.isle line 331.
                                return v274;
                            }
                            let v84 = &C::sinkable_load(ctx, v61.0);
                            if let Some(v85) = v84 {
                                let v86 = constructor_put_in_gpr(ctx, v61.1);
                                let v87 = &constructor_sink_load_to_gpr_mem_imm(ctx, v85);
                                let v267 = constructor_x64_and(ctx, v3, v86, v87);
                                let v268 = constructor_output_gpr(ctx, v267);
                                let v269 = Some(v268);
                                // Rule at src/isa/x64/lower.isle line 327.
                                return v269;
                            }
                            let v64 = constructor_put_in_gpr(ctx, v61.0);
                            let v65 = &constructor_put_in_gpr_mem_imm(ctx, v61.1);
                            let v264 = constructor_x64_and(ctx, v3, v64, v65);
                            let v265 = constructor_output_gpr(ctx, v264);
                            let v266 = Some(v265);
                            // Rule at src/isa/x64/lower.isle line 320.
                            return v266;
                        }
                    }
                }
                &Opcode::Bor => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v61 = C::unpack_value_array_2(ctx, v60);
                        let v122 = C::def_inst(ctx, v61.1);
                        if let Some(v123) = v122 {
                            let v124 = C::inst_data_value(ctx, v123);
                            if let &InstructionData::Binary {
                                opcode: ref v127,
                                args: ref v128,
                            } = &v124.1 {
                                match v127 {
                                    &Opcode::Ishl => {
                                        let v150 = C::def_inst(ctx, v61.0);
                                        if let Some(v151) = v150 {
                                            let v152 = C::inst_data_value(ctx, v151);
                                            if let &InstructionData::Binary {
                                                opcode: ref v376,
                                                args: ref v377,
                                            } = &v152.1 {
                                                if let &Opcode::Ushr = v376 {
                                                    let v3 = C::value_type(ctx, v2);
                                                    let v374 = C::ty_int_ref_16_to_64(ctx, v3);
                                                    if let Some(v375) = v374 {
                                                        let v378 = C::unpack_value_array_2(ctx, v377);
                                                        let v381 = C::def_inst(ctx, v378.1);
                                                        if let Some(v382) = v381 {
                                                            let v383 = C::inst_data_value(ctx, v382);
                                                            if let &InstructionData::UnaryImm {
                                                                opcode: ref v386,
                                                                imm: v387,
                                                            } = &v383.1 {
                                                                if let &Opcode::Iconst = v386 {
                                                                    let v388 = C::u64_from_imm64(ctx, v387);
                                                                    let v389 = C::u64_from_u8(ctx, v388);
                                                                    if let Some(v390) = v389 {
                                                                        let v129 = C::unpack_value_array_2(ctx, v128);
                                                                        let v391 = C::def_inst(ctx, v129.1);
                                                                        if let Some(v392) = v391 {
                                                                            let v393 = C::inst_data_value(ctx, v392);
                                                                            if let &InstructionData::UnaryImm {
                                                                                opcode: ref v396,
                                                                                imm: v397,
                                                                            } = &v393.1 {
                                                                                if let &Opcode::Iconst = v396 {
                                                                                    let v398 = C::u64_from_imm64(ctx, v397);
                                                                                    let v399 = C::u64_from_u8(ctx, v398);
                                                                                    if let Some(v400) = v399 {
                                                                                        let v403 = C::u8_into_u64(ctx, v390);
                                                                                        let v407 = C::u64_gt(ctx, v403, 0x0_u64);
                                                                                        if v407 == true {
                                                                                            let v404 = C::u8_into_u64(ctx, v400);
                                                                                            let v408 = C::u64_gt(ctx, v404, 0x0_u64);
                                                                                            if v408 == true {
                                                                                                let v401 = C::ty_bits(ctx, v375);
                                                                                                let v402 = C::u8_into_u64(ctx, v401);
                                                                                                let v414 = C::u64_wrapping_add(ctx, v404, v403);
                                                                                                let v415 = C::u64_eq(ctx, v402, v414);
                                                                                                if v415 == true {
                                                                                                    let v416 = constructor_put_in_gpr(ctx, v129.0);
                                                                                                    let v417 = constructor_put_in_gpr(ctx, v378.0);
                                                                                                    let v418 = constructor_x64_shld(ctx, v375, v416, v417, v400);
                                                                                                    let v419 = constructor_output_gpr(ctx, v418);
                                                                                                    let v420 = Some(v419);
                                                                                                    // Rule at src/isa/x64/lower.isle line 509.
                                                                                                    return v420;
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    &Opcode::Ushr => {
                                        let v150 = C::def_inst(ctx, v61.0);
                                        if let Some(v151) = v150 {
                                            let v152 = C::inst_data_value(ctx, v151);
                                            if let &InstructionData::Binary {
                                                opcode: ref v376,
                                                args: ref v377,
                                            } = &v152.1 {
                                                if let &Opcode::Ishl = v376 {
                                                    let v3 = C::value_type(ctx, v2);
                                                    let v374 = C::ty_int_ref_16_to_64(ctx, v3);
                                                    if let Some(v375) = v374 {
                                                        let v378 = C::unpack_value_array_2(ctx, v377);
                                                        let v381 = C::def_inst(ctx, v378.1);
                                                        if let Some(v382) = v381 {
                                                            let v383 = C::inst_data_value(ctx, v382);
                                                            if let &InstructionData::UnaryImm {
                                                                opcode: ref v386,
                                                                imm: v387,
                                                            } = &v383.1 {
                                                                if let &Opcode::Iconst = v386 {
                                                                    let v388 = C::u64_from_imm64(ctx, v387);
                                                                    let v389 = C::u64_from_u8(ctx, v388);
                                                                    if let Some(v390) = v389 {
                                                                        let v129 = C::unpack_value_array_2(ctx, v128);
                                                                        let v391 = C::def_inst(ctx, v129.1);
                                                                        if let Some(v392) = v391 {
                                                                            let v393 = C::inst_data_value(ctx, v392);
                                                                            if let &InstructionData::UnaryImm {
                                                                                opcode: ref v396,
                                                                                imm: v397,
                                                                            } = &v393.1 {
                                                                                if let &Opcode::Iconst = v396 {
                                                                                    let v398 = C::u64_from_imm64(ctx, v397);
                                                                                    let v399 = C::u64_from_u8(ctx, v398);
                                                                                    if let Some(v400) = v399 {
                                                                                        let v401 = C::ty_bits(ctx, v375);
                                                                                        let v402 = C::u8_into_u64(ctx, v401);
                                                                                        let v403 = C::u8_into_u64(ctx, v390);
                                                                                        let v404 = C::u8_into_u64(ctx, v400);
                                                                                        let v405 = C::u64_wrapping_add(ctx, v403, v404);
                                                                                        let v406 = C::u64_eq(ctx, v402, v405);
                                                                                        if v406 == true {
                                                                                            let v407 = C::u64_gt(ctx, v403, 0x0_u64);
                                                                                            if v407 == true {
                                                                                                let v408 = C::u64_gt(ctx, v404, 0x0_u64);
                                                                                                if v408 == true {
                                                                                                    let v409 = constructor_put_in_gpr(ctx, v378.0);
                                                                                                    let v410 = constructor_put_in_gpr(ctx, v129.0);
                                                                                                    let v411 = constructor_x64_shld(ctx, v375, v409, v410, v390);
                                                                                                    let v412 = constructor_output_gpr(ctx, v411);
                                                                                                    let v413 = Some(v412);
                                                                                                    // Rule at src/isa/x64/lower.isle line 503.
                                                                                                    return v413;
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    _ => {}
                                }
                            }
                        }
                        let v3 = C::value_type(ctx, v2);
                        if v3 == I128 {
                            let v109 = C::put_in_regs(ctx, v61.0);
                            let v110 = C::put_in_regs(ctx, v61.1);
                            let v371 = constructor_or_i128(ctx, v109, v110);
                            let v372 = C::output(ctx, v371);
                            let v373 = Some(v372);
                            // Rule at src/isa/x64/lower.isle line 495.
                            return v373;
                        }
                        let v91 = C::multi_lane(ctx, v3);
                        if let Some(v92) = v91 {
                            let v95 = constructor_put_in_xmm(ctx, v61.0);
                            let v96 = &C::put_in_xmm_mem_128(ctx, v61.1);
                            let v368 = constructor_sse_or(ctx, v3, v95, v96);
                            let v369 = constructor_output_xmm(ctx, v368);
                            let v370 = Some(v369);
                            // Rule at src/isa/x64/lower.isle line 480.
                            return v370;
                        }
                        let v275 = C::ty_scalar_float(ctx, v3);
                        if let Some(v276) = v275 {
                            let v95 = constructor_put_in_xmm(ctx, v61.0);
                            let v277 = constructor_put_in_xmm(ctx, v61.1);
                            let v278 = &C::xmm_to_xmm_mem_128(ctx, v277);
                            let v365 = constructor_sse_or(ctx, v276, v95, v278);
                            let v366 = constructor_output_xmm(ctx, v365);
                            let v367 = Some(v366);
                            // Rule at src/isa/x64/lower.isle line 467.
                            return v367;
                        }
                        let v262 = C::ty_int_ref_scalar_64(ctx, v3);
                        if let Some(v263) = v262 {
                            let v270 = &C::simm32_from_value(ctx, v61.0);
                            if let Some(v271) = v270 {
                                let v86 = constructor_put_in_gpr(ctx, v61.1);
                                let v362 = constructor_x64_or(ctx, v3, v86, v271);
                                let v363 = constructor_output_gpr(ctx, v362);
                                let v364 = Some(v363);
                                // Rule at src/isa/x64/lower.isle line 458.
                                return v364;
                            }
                            let v84 = &C::sinkable_load(ctx, v61.0);
                            if let Some(v85) = v84 {
                                let v86 = constructor_put_in_gpr(ctx, v61.1);
                                let v87 = &constructor_sink_load_to_gpr_mem_imm(ctx, v85);
                                let v359 = constructor_x64_or(ctx, v3, v86, v87);
                                let v360 = constructor_output_gpr(ctx, v359);
                                let v361 = Some(v360);
                                // Rule at src/isa/x64/lower.isle line 454.
                                return v361;
                            }
                            let v64 = constructor_put_in_gpr(ctx, v61.0);
                            let v65 = &constructor_put_in_gpr_mem_imm(ctx, v61.1);
                            let v356 = constructor_x64_or(ctx, v3, v64, v65);
                            let v357 = constructor_output_gpr(ctx, v356);
                            let v358 = Some(v357);
                            // Rule at src/isa/x64/lower.isle line 447.
                            return v358;
                        }
                    }
                }
                &Opcode::Bxor => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        let v69 = C::ty_32_or_64(ctx, v3);
                        if let Some(v70) = v69 {
                            let v297 = C::has_bmi1(ctx);
                            if v297 == true {
                                let v61 = C::unpack_value_array_2(ctx, v60);
                                let v313 = constructor_val_minus_one(ctx, v61.0);
                                if let Some(v314) = v313 {
                                    if v61.1 == v314 {
                                        let v315 = &constructor_put_in_gpr_mem(ctx, v61.1);
                                        let v451 = constructor_x64_blsmsk(ctx, v70, v315);
                                        let v452 = constructor_output_gpr(ctx, v451);
                                        let v453 = Some(v452);
                                        // Rule at src/isa/x64/lower.isle line 568.
                                        return v453;
                                    }
                                }
                                let v307 = constructor_val_minus_one(ctx, v61.1);
                                if let Some(v308) = v307 {
                                    if v61.0 == v308 {
                                        let v309 = &constructor_put_in_gpr_mem(ctx, v61.0);
                                        let v448 = constructor_x64_blsmsk(ctx, v70, v309);
                                        let v449 = constructor_output_gpr(ctx, v448);
                                        let v450 = Some(v449);
                                        // Rule at src/isa/x64/lower.isle line 564.
                                        return v450;
                                    }
                                }
                            }
                        }
                        if v3 == I128 {
                            let v61 = C::unpack_value_array_2(ctx, v60);
                            let v109 = C::put_in_regs(ctx, v61.0);
                            let v436 = constructor_value_regs_get_gpr(ctx, v109, 0x0_usize);
                            let v437 = constructor_value_regs_get_gpr(ctx, v109, 0x1_usize);
                            let v438 = C::put_in_regs(ctx, v61.1);
                            let v439 = constructor_value_regs_get_gpr(ctx, v438, 0x0_usize);
                            let v440 = constructor_value_regs_get_gpr(ctx, v438, 0x1_usize);
                            let v441 = &C::gpr_to_gpr_mem_imm(ctx, v439);
                            let v442 = constructor_x64_xor(ctx, I64, v436, v441);
                            let v443 = &C::gpr_to_gpr_mem_imm(ctx, v440);
                            let v444 = constructor_x64_xor(ctx, I64, v437, v443);
                            let v445 = constructor_value_gprs(ctx, v442, v444);
                            let v446 = C::output(ctx, v445);
                            let v447 = Some(v446);
                            // Rule at src/isa/x64/lower.isle line 552.
                            return v447;
                        }
                        let v91 = C::multi_lane(ctx, v3);
                        if let Some(v92) = v91 {
                            let v61 = C::unpack_value_array_2(ctx, v60);
                            let v95 = constructor_put_in_xmm(ctx, v61.0);
                            let v96 = &C::put_in_xmm_mem_128(ctx, v61.1);
                            let v433 = constructor_x64_xor_vector(ctx, v3, v95, v96);
                            let v434 = constructor_output_xmm(ctx, v433);
                            let v435 = Some(v434);
                            // Rule at src/isa/x64/lower.isle line 547.
                            return v435;
                        }
                        let v275 = C::ty_scalar_float(ctx, v3);
                        if let Some(v276) = v275 {
                            let v61 = C::unpack_value_array_2(ctx, v60);
                            let v95 = constructor_put_in_xmm(ctx, v61.0);
                            let v277 = constructor_put_in_xmm(ctx, v61.1);
                            let v278 = &C::xmm_to_xmm_mem_128(ctx, v277);
                            let v430 = constructor_x64_xor_vector(ctx, v276, v95, v278);
                            let v431 = constructor_output_xmm(ctx, v430);
                            let v432 = Some(v431);
                            // Rule at src/isa/x64/lower.isle line 542.
                            return v432;
                        }
                        let v262 = C::ty_int_ref_scalar_64(ctx, v3);
                        if let Some(v263) = v262 {
                            let v61 = C::unpack_value_array_2(ctx, v60);
                            let v270 = &C::simm32_from_value(ctx, v61.0);
                            if let Some(v271) = v270 {
                                let v86 = constructor_put_in_gpr(ctx, v61.1);
                                let v427 = constructor_x64_xor(ctx, v3, v86, v271);
                                let v428 = constructor_output_gpr(ctx, v427);
                                let v429 = Some(v428);
                                // Rule at src/isa/x64/lower.isle line 533.
                                return v429;
                            }
                            let v84 = &C::sinkable_load(ctx, v61.0);
                            if let Some(v85) = v84 {
                                let v86 = constructor_put_in_gpr(ctx, v61.1);
                                let v87 = &constructor_sink_load_to_gpr_mem_imm(ctx, v85);
                                let v424 = constructor_x64_xor(ctx, v3, v86, v87);
                                let v425 = constructor_output_gpr(ctx, v424);
                                let v426 = Some(v425);
                                // Rule at src/isa/x64/lower.isle line 529.
                                return v426;
                            }
                            let v64 = constructor_put_in_gpr(ctx, v61.0);
                            let v65 = &constructor_put_in_gpr_mem_imm(ctx, v61.1);
                            let v421 = constructor_x64_xor(ctx, v3, v64, v65);
                            let v422 = constructor_output_gpr(ctx, v421);
                            let v423 = Some(v422);
                            // Rule at src/isa/x64/lower.isle line 522.
                            return v423;
                        }
                    }
                }
                &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 v61 = C::unpack_value_array_2(ctx, v60);
                            let v109 = C::put_in_regs(ctx, v61.0);
                            let v570 = constructor_lo_gpr(ctx, v61.1);
                            let v571 = constructor_shl_i128(ctx, v109, v570);
                            let v573 = constructor_imm(ctx, I64, 0x80_u64);
                            let v574 = C::gpr_new(ctx, v573);
                            let v575 = &C::gpr_to_gpr_mem_imm(ctx, v570);
                            let v576 = constructor_x64_sub(ctx, I64, v574, v575);
                            let v577 = constructor_shr_i128(ctx, v109, v576);
                            let v578 = constructor_or_i128(ctx, v571, v577);
                            let v579 = C::output(ctx, v578);
                            let v580 = Some(v579);
                            // Rule at src/isa/x64/lower.isle line 971.
                            return v580;
                        }
                        let v4 = C::fits_in_64(ctx, v3);
                        if let Some(v5) = v4 {
                            let v61 = C::unpack_value_array_2(ctx, v60);
                            let v64 = constructor_put_in_gpr(ctx, v61.0);
                            let v454 = &constructor_put_masked_in_imm8_gpr(ctx, v61.1, v5);
                            let v567 = constructor_x64_rotl(ctx, v5, v64, v454);
                            let v568 = constructor_output_gpr(ctx, v567);
                            let v569 = Some(v568);
                            // Rule at src/isa/x64/lower.isle line 965.
                            return v569;
                        }
                    }
                }
                &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 v61 = C::unpack_value_array_2(ctx, v60);
                            let v109 = C::put_in_regs(ctx, v61.0);
                            let v570 = constructor_lo_gpr(ctx, v61.1);
                            let v584 = constructor_shr_i128(ctx, v109, v570);
                            let v573 = constructor_imm(ctx, I64, 0x80_u64);
                            let v574 = C::gpr_new(ctx, v573);
                            let v575 = &C::gpr_to_gpr_mem_imm(ctx, v570);
                            let v576 = constructor_x64_sub(ctx, I64, v574, v575);
                            let v585 = constructor_shl_i128(ctx, v109, v576);
                            let v586 = constructor_or_i128(ctx, v584, v585);
                            let v587 = C::output(ctx, v586);
                            let v588 = Some(v587);
                            // Rule at src/isa/x64/lower.isle line 992.
                            return v588;
                        }
                        let v4 = C::fits_in_64(ctx, v3);
                        if let Some(v5) = v4 {
                            let v61 = C::unpack_value_array_2(ctx, v60);
                            let v64 = constructor_put_in_gpr(ctx, v61.0);
                            let v454 = &constructor_put_masked_in_imm8_gpr(ctx, v61.1, v5);
                            let v581 = constructor_x64_rotr(ctx, v5, v64, v454);
                            let v582 = constructor_output_gpr(ctx, v581);
                            let v583 = Some(v582);
                            // Rule at src/isa/x64/lower.isle line 986.
                            return v583;
                        }
                    }
                }
                &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 v61 = C::unpack_value_array_2(ctx, v60);
                                let v458 = constructor_lo_gpr(ctx, v61.1);
                                let v132 = C::put_in_regs(ctx, v61.0);
                                let v459 = constructor_shl_i128(ctx, v132, v458);
                                let v460 = C::output(ctx, v459);
                                let v461 = Some(v460);
                                // Rule at src/isa/x64/lower.isle line 614.
                                return v461;
                            }
                            I8X16 => {
                                let v61 = C::unpack_value_array_2(ctx, v60);
                                let v462 = &constructor_mask_xmm_shift(ctx, v3, v61.1);
                                let v463 = constructor_put_in_xmm(ctx, v61.0);
                                let v464 = &constructor_mov_rmi_to_xmm(ctx, v462);
                                let v465 = constructor_x64_psllw(ctx, v463, v464);
                                let v466 = &constructor_ishl_i8x16_mask(ctx, v462);
                                let v467 = &C::synthetic_amode_to_xmm_mem_128(ctx, v466);
                                let v468 = constructor_x64_movdqu_load(ctx, v467);
                                let v469 = &C::xmm_to_xmm_mem_128(ctx, v468);
                                let v470 = constructor_x64_pand(ctx, v465, v469);
                                let v471 = constructor_output_xmm(ctx, v470);
                                let v472 = Some(v471);
                                // Rule at src/isa/x64/lower.isle line 626.
                                return v472;
                            }
                            I16X8 => {
                                let v61 = C::unpack_value_array_2(ctx, v60);
                                let v95 = constructor_put_in_xmm(ctx, v61.0);
                                let v473 = &constructor_mask_xmm_shift(ctx, v3, v61.1);
                                let v474 = &constructor_mov_rmi_to_xmm(ctx, v473);
                                let v475 = constructor_x64_psllw(ctx, v95, v474);
                                let v476 = constructor_output_xmm(ctx, v475);
                                let v477 = Some(v476);
                                // Rule at src/isa/x64/lower.isle line 672.
                                return v477;
                            }
                            I32X4 => {
                                let v61 = C::unpack_value_array_2(ctx, v60);
                                let v95 = constructor_put_in_xmm(ctx, v61.0);
                                let v473 = &constructor_mask_xmm_shift(ctx, v3, v61.1);
                                let v474 = &constructor_mov_rmi_to_xmm(ctx, v473);
                                let v478 = constructor_x64_pslld(ctx, v95, v474);
                                let v479 = constructor_output_xmm(ctx, v478);
                                let v480 = Some(v479);
                                // Rule at src/isa/x64/lower.isle line 675.
                                return v480;
                            }
                            I64X2 => {
                                let v61 = C::unpack_value_array_2(ctx, v60);
                                let v95 = constructor_put_in_xmm(ctx, v61.0);
                                let v473 = &constructor_mask_xmm_shift(ctx, v3, v61.1);
                                let v474 = &constructor_mov_rmi_to_xmm(ctx, v473);
                                let v481 = constructor_x64_psllq(ctx, v95, v474);
                                let v482 = constructor_output_xmm(ctx, v481);
                                let v483 = Some(v482);
                                // Rule at src/isa/x64/lower.isle line 678.
                                return v483;
                            }
                            _ => {}
                        }
                        let v4 = C::fits_in_64(ctx, v3);
                        if let Some(v5) = v4 {
                            let v61 = C::unpack_value_array_2(ctx, v60);
                            let v64 = constructor_put_in_gpr(ctx, v61.0);
                            let v454 = &constructor_put_masked_in_imm8_gpr(ctx, v61.1, v5);
                            let v455 = constructor_x64_shl(ctx, v5, v64, v454);
                            let v456 = constructor_output_gpr(ctx, v455);
                            let v457 = Some(v456);
                            // Rule at src/isa/x64/lower.isle line 577.
                            return v457;
                        }
                    }
                }
                &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 v61 = C::unpack_value_array_2(ctx, v60);
                                let v458 = constructor_lo_gpr(ctx, v61.1);
                                let v132 = C::put_in_regs(ctx, v61.0);
                                let v488 = constructor_shr_i128(ctx, v132, v458);
                                let v489 = C::output(ctx, v488);
                                let v490 = Some(v489);
                                // Rule at src/isa/x64/lower.isle line 722.
                                return v490;
                            }
                            I8X16 => {
                                let v61 = C::unpack_value_array_2(ctx, v60);
                                let v462 = &constructor_mask_xmm_shift(ctx, v3, v61.1);
                                let v463 = constructor_put_in_xmm(ctx, v61.0);
                                let v464 = &constructor_mov_rmi_to_xmm(ctx, v462);
                                let v491 = constructor_x64_psrlw(ctx, v463, v464);
                                let v492 = &constructor_ushr_i8x16_mask(ctx, v462);
                                let v493 = &C::synthetic_amode_to_xmm_mem_128(ctx, v492);
                                let v494 = constructor_x64_pand(ctx, v491, v493);
                                let v495 = constructor_output_xmm(ctx, v494);
                                let v496 = Some(v495);
                                // Rule at src/isa/x64/lower.isle line 732.
                                return v496;
                            }
                            I16X8 => {
                                let v61 = C::unpack_value_array_2(ctx, v60);
                                let v95 = constructor_put_in_xmm(ctx, v61.0);
                                let v473 = &constructor_mask_xmm_shift(ctx, v3, v61.1);
                                let v474 = &constructor_mov_rmi_to_xmm(ctx, v473);
                                let v497 = constructor_x64_psrlw(ctx, v95, v474);
                                let v498 = constructor_output_xmm(ctx, v497);
                                let v499 = Some(v498);
                                // Rule at src/isa/x64/lower.isle line 776.
                                return v499;
                            }
                            I32X4 => {
                                let v61 = C::unpack_value_array_2(ctx, v60);
                                let v95 = constructor_put_in_xmm(ctx, v61.0);
                                let v473 = &constructor_mask_xmm_shift(ctx, v3, v61.1);
                                let v474 = &constructor_mov_rmi_to_xmm(ctx, v473);
                                let v500 = constructor_x64_psrld(ctx, v95, v474);
                                let v501 = constructor_output_xmm(ctx, v500);
                                let v502 = Some(v501);
                                // Rule at src/isa/x64/lower.isle line 779.
                                return v502;
                            }
                            I64X2 => {
                                let v61 = C::unpack_value_array_2(ctx, v60);
                                let v95 = constructor_put_in_xmm(ctx, v61.0);
                                let v473 = &constructor_mask_xmm_shift(ctx, v3, v61.1);
                                let v474 = &constructor_mov_rmi_to_xmm(ctx, v473);
                                let v503 = constructor_x64_psrlq(ctx, v95, v474);
                                let v504 = constructor_output_xmm(ctx, v503);
                                let v505 = Some(v504);
                                // Rule at src/isa/x64/lower.isle line 782.
                                return v505;
                            }
                            _ => {}
                        }
                        let v4 = C::fits_in_64(ctx, v3);
                        if let Some(v5) = v4 {
                            let v61 = C::unpack_value_array_2(ctx, v60);
                            let v484 = constructor_extend_to_gpr(ctx, v61.0, v5, &ExtendKind::Zero);
                            let v454 = &constructor_put_masked_in_imm8_gpr(ctx, v61.1, v5);
                            let v485 = constructor_x64_shr(ctx, v5, v484, v454);
                            let v486 = constructor_output_gpr(ctx, v485);
                            let v487 = Some(v486);
                            // Rule at src/isa/x64/lower.isle line 685.
                            return v487;
                        }
                    }
                }
                &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 v61 = C::unpack_value_array_2(ctx, v60);
                                let v458 = constructor_lo_gpr(ctx, v61.1);
                                let v132 = C::put_in_regs(ctx, v61.0);
                                let v511 = constructor_sar_i128(ctx, v132, v458);
                                let v512 = C::output(ctx, v511);
                                let v513 = Some(v512);
                                // Rule at src/isa/x64/lower.isle line 832.
                                return v513;
                            }
                            I8X16 => {
                                let v61 = C::unpack_value_array_2(ctx, v60);
                                let v95 = constructor_put_in_xmm(ctx, v61.0);
                                let v473 = &constructor_mask_xmm_shift(ctx, v3, v61.1);
                                let v514 = &C::xmm_to_xmm_mem_128(ctx, v95);
                                let v515 = constructor_x64_punpcklbw(ctx, v95, v514);
                                let v516 = &C::xmm_to_xmm_mem_128(ctx, v95);
                                let v517 = constructor_x64_punpckhbw(ctx, v95, v516);
                                let v173 = C::value_type(ctx, v61.1);
                                let v518 = &constructor_sshr_i8x16_bigger_shift(ctx, v173, v473);
                                let v519 = constructor_x64_psraw(ctx, v515, v518);
                                let v520 = constructor_x64_psraw(ctx, v517, v518);
                                let v521 = &C::xmm_to_xmm_mem_128(ctx, v520);
                                let v522 = constructor_x64_packsswb(ctx, v519, v521);
                                let v523 = constructor_output_xmm(ctx, v522);
                                let v524 = Some(v523);
                                // Rule at src/isa/x64/lower.isle line 853.
                                return v524;
                            }
                            I16X8 => {
                                let v61 = C::unpack_value_array_2(ctx, v60);
                                let v95 = constructor_put_in_xmm(ctx, v61.0);
                                let v473 = &constructor_mask_xmm_shift(ctx, v3, v61.1);
                                let v474 = &constructor_mov_rmi_to_xmm(ctx, v473);
                                let v525 = constructor_x64_psraw(ctx, v95, v474);
                                let v526 = constructor_output_xmm(ctx, v525);
                                let v527 = Some(v526);
                                // Rule at src/isa/x64/lower.isle line 882.
                                return v527;
                            }
                            I32X4 => {
                                let v61 = C::unpack_value_array_2(ctx, v60);
                                let v95 = constructor_put_in_xmm(ctx, v61.0);
                                let v473 = &constructor_mask_xmm_shift(ctx, v3, v61.1);
                                let v474 = &constructor_mov_rmi_to_xmm(ctx, v473);
                                let v528 = constructor_x64_psrad(ctx, v95, v474);
                                let v529 = constructor_output_xmm(ctx, v528);
                                let v530 = Some(v529);
                                // Rule at src/isa/x64/lower.isle line 885.
                                return v530;
                            }
                            I64X2 => {
                                let v533 = C::has_avx512vl(ctx);
                                if v533 == true {
                                    let v534 = C::has_avx512f(ctx);
                                    if v534 == true {
                                        let v61 = C::unpack_value_array_2(ctx, v60);
                                        let v122 = C::def_inst(ctx, v61.1);
                                        if let Some(v123) = v122 {
                                            let v124 = C::inst_data_value(ctx, v123);
                                            if let &InstructionData::UnaryImm {
                                                opcode: ref v531,
                                                imm: v532,
                                            } = &v124.1 {
                                                if let &Opcode::Iconst = v531 {
                                                    let v535 = &C::put_in_xmm_mem_128(ctx, v61.0);
                                                    let v536 = C::shift_amount_masked(ctx, v3, v532);
                                                    let v537 = constructor_x64_vpsraq_imm(ctx, v535, v536);
                                                    let v538 = constructor_output_xmm(ctx, v537);
                                                    let v539 = Some(v538);
                                                    // Rule at src/isa/x64/lower.isle line 891.
                                                    return v539;
                                                }
                                            }
                                        }
                                        let v86 = constructor_put_in_gpr(ctx, v61.1);
                                        let v540 = C::shift_mask(ctx, v3);
                                        let v541 = C::u8_into_u32(ctx, v540);
                                        let v542 = RegMemImm::Imm {
                                            simm32: v541,
                                        };
                                        let v543 = &C::gpr_mem_imm_new(ctx, &v542);
                                        let v544 = constructor_x64_and(ctx, I64, v86, v543);
                                        let v545 = constructor_put_in_xmm(ctx, v61.0);
                                        let v546 = &C::gpr_to_gpr_mem_32(ctx, v544);
                                        let v547 = constructor_x64_movd_to_xmm(ctx, v546);
                                        let v548 = &C::xmm_to_xmm_mem_128(ctx, v547);
                                        let v549 = constructor_x64_vpsraq(ctx, v545, v548);
                                        let v550 = constructor_output_xmm(ctx, v549);
                                        let v551 = Some(v550);
                                        // Rule at src/isa/x64/lower.isle line 896.
                                        return v551;
                                    }
                                }
                                let v61 = C::unpack_value_array_2(ctx, v60);
                                let v122 = C::def_inst(ctx, v61.1);
                                if let Some(v123) = v122 {
                                    let v124 = C::inst_data_value(ctx, v123);
                                    if let &InstructionData::UnaryImm {
                                        opcode: ref v531,
                                        imm: v532,
                                    } = &v124.1 {
                                        if let &Opcode::Iconst = v531 {
                                            let v552 = C::u64_from_imm64(ctx, v532);
                                            let v553 = C::u64_from_u32(ctx, v552);
                                            if let Some(v554) = v553 {
                                                let v95 = constructor_put_in_xmm(ctx, v61.0);
                                                let v556 = C::u32_and(ctx, v554, 0x3f_u32);
                                                let v557 = constructor_lower_i64x2_sshr_imm(ctx, v95, v556);
                                                let v558 = constructor_output_xmm(ctx, v557);
                                                let v559 = Some(v558);
                                                // Rule at src/isa/x64/lower.isle line 902.
                                                return v559;
                                            }
                                        }
                                    }
                                }
                                let v95 = constructor_put_in_xmm(ctx, v61.0);
                                let v560 = constructor_put_in_gpr(ctx, v61.1);
                                let v561 = RegMemImm::Imm {
                                    simm32: 0x3f_u32,
                                };
                                let v562 = &C::gpr_mem_imm_new(ctx, &v561);
                                let v563 = constructor_x64_and(ctx, I64, v560, v562);
                                let v564 = constructor_lower_i64x2_sshr_gpr(ctx, v95, v563);
                                let v565 = constructor_output_xmm(ctx, v564);
                                let v566 = Some(v565);
                                // Rule at src/isa/x64/lower.isle line 905.
                                return v566;
                            }
                            _ => {}
                        }
                        let v4 = C::fits_in_64(ctx, v3);
                        if let Some(v5) = v4 {
                            let v61 = C::unpack_value_array_2(ctx, v60);
                            let v507 = constructor_extend_to_gpr(ctx, v61.0, v5, &ExtendKind::Sign);
                            let v454 = &constructor_put_masked_in_imm8_gpr(ctx, v61.1, v5);
                            let v508 = constructor_x64_sar(ctx, v5, v507, v454);
                            let v509 = constructor_output_gpr(ctx, v508);
                            let v510 = Some(v509);
                            // Rule at src/isa/x64/lower.isle line 795.
                            return v510;
                        }
                    }
                }
                &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 v61 = C::unpack_value_array_2(ctx, v60);
                                let v1810 = &C::sinkable_load_32(ctx, v61.0);
                                if let Some(v1811) = v1810 {
                                    let v1792 = constructor_put_in_xmm(ctx, v61.1);
                                    let v1812 = &C::sink_load_32_to_xmm_mem_32(ctx, v1811);
                                    let v1813 = constructor_x64_addss(ctx, v1792, v1812);
                                    let v1814 = constructor_output_xmm(ctx, v1813);
                                    let v1815 = Some(v1814);
                                    // Rule at src/isa/x64/lower.isle line 2699.
                                    return v1815;
                                }
                                let v95 = constructor_put_in_xmm(ctx, v61.0);
                                let v1796 = &C::put_in_xmm_mem_32(ctx, v61.1);
                                let v1797 = constructor_x64_addss(ctx, v95, v1796);
                                let v1798 = constructor_output_xmm(ctx, v1797);
                                let v1799 = Some(v1798);
                                // Rule at src/isa/x64/lower.isle line 2688.
                                return v1799;
                            }
                            F64 => {
                                let v61 = C::unpack_value_array_2(ctx, v60);
                                let v1816 = &C::sinkable_load_64(ctx, v61.0);
                                if let Some(v1817) = v1816 {
                                    let v1792 = constructor_put_in_xmm(ctx, v61.1);
                                    let v1818 = &C::sink_load_64_to_xmm_mem_64(ctx, v1817);
                                    let v1819 = constructor_x64_addsd(ctx, v1792, v1818);
                                    let v1820 = constructor_output_xmm(ctx, v1819);
                                    let v1821 = Some(v1820);
                                    // Rule at src/isa/x64/lower.isle line 2701.
                                    return v1821;
                                }
                                let v95 = constructor_put_in_xmm(ctx, v61.0);
                                let v1800 = &C::put_in_xmm_mem_64(ctx, v61.1);
                                let v1801 = constructor_x64_addsd(ctx, v95, v1800);
                                let v1802 = constructor_output_xmm(ctx, v1801);
                                let v1803 = Some(v1802);
                                // Rule at src/isa/x64/lower.isle line 2690.
                                return v1803;
                            }
                            F32X4 => {
                                let v61 = C::unpack_value_array_2(ctx, v60);
                                let v1822 = &C::sinkable_load_128(ctx, v61.0);
                                if let Some(v1823) = v1822 {
                                    let v1792 = constructor_put_in_xmm(ctx, v61.1);
                                    let v1824 = &C::sink_load_128_to_xmm_mem_128(ctx, v1823);
                                    let v1825 = constructor_x64_addps(ctx, v1792, v1824);
                                    let v1826 = constructor_output_xmm(ctx, v1825);
                                    let v1827 = Some(v1826);
                                    // Rule at src/isa/x64/lower.isle line 2703.
                                    return v1827;
                                }
                                let v95 = constructor_put_in_xmm(ctx, v61.0);
                                let v96 = &C::put_in_xmm_mem_128(ctx, v61.1);
                                let v1804 = constructor_x64_addps(ctx, v95, v96);
                                let v1805 = constructor_output_xmm(ctx, v1804);
                                let v1806 = Some(v1805);
                                // Rule at src/isa/x64/lower.isle line 2692.
                                return v1806;
                            }
                            F64X2 => {
                                let v61 = C::unpack_value_array_2(ctx, v60);
                                let v1822 = &C::sinkable_load_128(ctx, v61.0);
                                if let Some(v1823) = v1822 {
                                    let v1792 = constructor_put_in_xmm(ctx, v61.1);
                                    let v1824 = &C::sink_load_128_to_xmm_mem_128(ctx, v1823);
                                    let v1828 = constructor_x64_addpd(ctx, v1792, v1824);
                                    let v1829 = constructor_output_xmm(ctx, v1828);
                                    let v1830 = Some(v1829);
                                    // Rule at src/isa/x64/lower.isle line 2705.
                                    return v1830;
                                }
                                let v95 = constructor_put_in_xmm(ctx, v61.0);
                                let v96 = &C::put_in_xmm_mem_128(ctx, v61.1);
                                let v1807 = constructor_x64_addpd(ctx, v95, v96);
                                let v1808 = constructor_output_xmm(ctx, v1807);
                                let v1809 = Some(v1808);
                                // Rule at src/isa/x64/lower.isle line 2694.
                                return v1809;
                            }
                            _ => {}
                        }
                    }
                }
                &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 v61 = C::unpack_value_array_2(ctx, v60);
                                let v95 = constructor_put_in_xmm(ctx, v61.0);
                                let v1796 = &C::put_in_xmm_mem_32(ctx, v61.1);
                                let v1831 = constructor_x64_subss(ctx, v95, v1796);
                                let v1832 = constructor_output_xmm(ctx, v1831);
                                let v1833 = Some(v1832);
                                // Rule at src/isa/x64/lower.isle line 2710.
                                return v1833;
                            }
                            F64 => {
                                let v61 = C::unpack_value_array_2(ctx, v60);
                                let v95 = constructor_put_in_xmm(ctx, v61.0);
                                let v1800 = &C::put_in_xmm_mem_64(ctx, v61.1);
                                let v1834 = constructor_x64_subsd(ctx, v95, v1800);
                                let v1835 = constructor_output_xmm(ctx, v1834);
                                let v1836 = Some(v1835);
                                // Rule at src/isa/x64/lower.isle line 2712.
                                return v1836;
                            }
                            F32X4 => {
                                let v61 = C::unpack_value_array_2(ctx, v60);
                                let v95 = constructor_put_in_xmm(ctx, v61.0);
                                let v96 = &C::put_in_xmm_mem_128(ctx, v61.1);
                                let v1837 = constructor_x64_subps(ctx, v95, v96);
                                let v1838 = constructor_output_xmm(ctx, v1837);
                                let v1839 = Some(v1838);
                                // Rule at src/isa/x64/lower.isle line 2714.
                                return v1839;
                            }
                            F64X2 => {
                                let v61 = C::unpack_value_array_2(ctx, v60);
                                let v95 = constructor_put_in_xmm(ctx, v61.0);
                                let v96 = &C::put_in_xmm_mem_128(ctx, v61.1);
                                let v1840 = constructor_x64_subpd(ctx, v95, v96);
                                let v1841 = constructor_output_xmm(ctx, v1840);
                                let v1842 = Some(v1841);
                                // Rule at src/isa/x64/lower.isle line 2716.
                                return v1842;
                            }
                            _ => {}
                        }
                    }
                }
                &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 v61 = C::unpack_value_array_2(ctx, v60);
                                let v1810 = &C::sinkable_load_32(ctx, v61.0);
                                if let Some(v1811) = v1810 {
                                    let v1792 = constructor_put_in_xmm(ctx, v61.1);
                                    let v1812 = &C::sink_load_32_to_xmm_mem_32(ctx, v1811);
                                    let v1855 = constructor_x64_mulss(ctx, v1792, v1812);
                                    let v1856 = constructor_output_xmm(ctx, v1855);
                                    let v1857 = Some(v1856);
                                    // Rule at src/isa/x64/lower.isle line 2732.
                                    return v1857;
                                }
                                let v95 = constructor_put_in_xmm(ctx, v61.0);
                                let v1796 = &C::put_in_xmm_mem_32(ctx, v61.1);
                                let v1843 = constructor_x64_mulss(ctx, v95, v1796);
                                let v1844 = constructor_output_xmm(ctx, v1843);
                                let v1845 = Some(v1844);
                                // Rule at src/isa/x64/lower.isle line 2721.
                                return v1845;
                            }
                            F64 => {
                                let v61 = C::unpack_value_array_2(ctx, v60);
                                let v1816 = &C::sinkable_load_64(ctx, v61.0);
                                if let Some(v1817) = v1816 {
                                    let v1792 = constructor_put_in_xmm(ctx, v61.1);
                                    let v1818 = &C::sink_load_64_to_xmm_mem_64(ctx, v1817);
                                    let v1858 = constructor_x64_mulsd(ctx, v1792, v1818);
                                    let v1859 = constructor_output_xmm(ctx, v1858);
                                    let v1860 = Some(v1859);
                                    // Rule at src/isa/x64/lower.isle line 2734.
                                    return v1860;
                                }
                                let v95 = constructor_put_in_xmm(ctx, v61.0);
                                let v1800 = &C::put_in_xmm_mem_64(ctx, v61.1);
                                let v1846 = constructor_x64_mulsd(ctx, v95, v1800);
                                let v1847 = constructor_output_xmm(ctx, v1846);
                                let v1848 = Some(v1847);
                                // Rule at src/isa/x64/lower.isle line 2723.
                                return v1848;
                            }
                            F32X4 => {
                                let v61 = C::unpack_value_array_2(ctx, v60);
                                let v1822 = &C::sinkable_load_128(ctx, v61.0);
                                if let Some(v1823) = v1822 {
                                    let v1792 = constructor_put_in_xmm(ctx, v61.1);
                                    let v1824 = &C::sink_load_128_to_xmm_mem_128(ctx, v1823);
                                    let v1861 = constructor_x64_mulps(ctx, v1792, v1824);
                                    let v1862 = constructor_output_xmm(ctx, v1861);
                                    let v1863 = Some(v1862);
                                    // Rule at src/isa/x64/lower.isle line 2736.
                                    return v1863;
                                }
                                let v95 = constructor_put_in_xmm(ctx, v61.0);
                                let v96 = &C::put_in_xmm_mem_128(ctx, v61.1);
                                let v1849 = constructor_x64_mulps(ctx, v95, v96);
                                let v1850 = constructor_output_xmm(ctx, v1849);
                                let v1851 = Some(v1850);
                                // Rule at src/isa/x64/lower.isle line 2725.
                                return v1851;
                            }
                            F64X2 => {
                                let v61 = C::unpack_value_array_2(ctx, v60);
                                let v1822 = &C::sinkable_load_128(ctx, v61.0);
                                if let Some(v1823) = v1822 {
                                    let v1792 = constructor_put_in_xmm(ctx, v61.1);
                                    let v1824 = &C::sink_load_128_to_xmm_mem_128(ctx, v1823);
                                    let v1864 = constructor_x64_mulpd(ctx, v1792, v1824);
                                    let v1865 = constructor_output_xmm(ctx, v1864);
                                    let v1866 = Some(v1865);
                                    // Rule at src/isa/x64/lower.isle line 2738.
                                    return v1866;
                                }
                                let v95 = constructor_put_in_xmm(ctx, v61.0);
                                let v96 = &C::put_in_xmm_mem_128(ctx, v61.1);
                                let v1852 = constructor_x64_mulpd(ctx, v95, v96);
                                let v1853 = constructor_output_xmm(ctx, v1852);
                                let v1854 = Some(v1853);
                                // Rule at src/isa/x64/lower.isle line 2727.
                                return v1854;
                            }
                            _ => {}
                        }
                    }
                }
                &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 v61 = C::unpack_value_array_2(ctx, v60);
                                let v95 = constructor_put_in_xmm(ctx, v61.0);
                                let v1796 = &C::put_in_xmm_mem_32(ctx, v61.1);
                                let v1867 = constructor_x64_divss(ctx, v95, v1796);
                                let v1868 = constructor_output_xmm(ctx, v1867);
                                let v1869 = Some(v1868);
                                // Rule at src/isa/x64/lower.isle line 2743.
                                return v1869;
                            }
                            F64 => {
                                let v61 = C::unpack_value_array_2(ctx, v60);
                                let v95 = constructor_put_in_xmm(ctx, v61.0);
                                let v1800 = &C::put_in_xmm_mem_64(ctx, v61.1);
                                let v1870 = constructor_x64_divsd(ctx, v95, v1800);
                                let v1871 = constructor_output_xmm(ctx, v1870);
                                let v1872 = Some(v1871);
                                // Rule at src/isa/x64/lower.isle line 2745.
                                return v1872;
                            }
                            F32X4 => {
                                let v61 = C::unpack_value_array_2(ctx, v60);
                                let v95 = constructor_put_in_xmm(ctx, v61.0);
                                let v96 = &C::put_in_xmm_mem_128(ctx, v61.1);
                                let v1873 = constructor_x64_divps(ctx, v95, v96);
                                let v1874 = constructor_output_xmm(ctx, v1873);
                                let v1875 = Some(v1874);
                                // Rule at src/isa/x64/lower.isle line 2747.
                                return v1875;
                            }
                            F64X2 => {
                                let v61 = C::unpack_value_array_2(ctx, v60);
                                let v95 = constructor_put_in_xmm(ctx, v61.0);
                                let v96 = &C::put_in_xmm_mem_128(ctx, v61.1);
                                let v1876 = constructor_x64_divpd(ctx, v95, v96);
                                let v1877 = constructor_output_xmm(ctx, v1876);
                                let v1878 = Some(v1877);
                                // Rule at src/isa/x64/lower.isle line 2749.
                                return v1878;
                            }
                            _ => {}
                        }
                    }
                }
                &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 v61 = C::unpack_value_array_2(ctx, v60);
                                let v2949 = C::value_type(ctx, v61.0);
                                if v2949 == F32 {
                                    let v3012 = constructor_imm(ctx, F32, 0x80000000_u64);
                                    let v3013 = C::xmm_new(ctx, v3012);
                                    let v2775 = constructor_put_in_xmm(ctx, v61.0);
                                    let v3014 = constructor_put_in_xmm(ctx, v61.1);
                                    let v3015 = &C::xmm_to_xmm_mem_128(ctx, v2775);
                                    let v3016 = constructor_x64_andnps(ctx, v3013, v3015);
                                    let v3017 = &C::xmm_to_xmm_mem_128(ctx, v3014);
                                    let v3018 = constructor_x64_andps(ctx, v3013, v3017);
                                    let v3019 = &C::xmm_to_xmm_mem_128(ctx, v3018);
                                    let v3020 = constructor_x64_orps(ctx, v3016, v3019);
                                    let v3021 = constructor_output_xmm(ctx, v3020);
                                    let v3022 = Some(v3021);
                                    // Rule at src/isa/x64/lower.isle line 4322.
                                    return v3022;
                                }
                            }
                            F64 => {
                                let v61 = C::unpack_value_array_2(ctx, v60);
                                let v2949 = C::value_type(ctx, v61.0);
                                if v2949 == F64 {
                                    let v3023 = constructor_imm(ctx, F64, 0x8000000000000000_u64);
                                    let v3024 = C::xmm_new(ctx, v3023);
                                    let v2775 = constructor_put_in_xmm(ctx, v61.0);
                                    let v3014 = constructor_put_in_xmm(ctx, v61.1);
                                    let v3015 = &C::xmm_to_xmm_mem_128(ctx, v2775);
                                    let v3025 = constructor_x64_andnpd(ctx, v3024, v3015);
                                    let v3017 = &C::xmm_to_xmm_mem_128(ctx, v3014);
                                    let v3026 = constructor_x64_andpd(ctx, v3024, v3017);
                                    let v3027 = &C::xmm_to_xmm_mem_128(ctx, v3026);
                                    let v3028 = constructor_x64_orpd(ctx, v3025, v3027);
                                    let v3029 = constructor_output_xmm(ctx, v3028);
                                    let v3030 = Some(v3029);
                                    // Rule at src/isa/x64/lower.isle line 4330.
                                    return v3030;
                                }
                            }
                            _ => {}
                        }
                    }
                }
                &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 v61 = C::unpack_value_array_2(ctx, v60);
                                let v95 = constructor_put_in_xmm(ctx, v61.0);
                                let v277 = constructor_put_in_xmm(ctx, v61.1);
                                let v207 = true;
                                let v1910 = constructor_xmm_min_max_seq(ctx, F32, v207, v95, v277);
                                let v1911 = constructor_output_xmm(ctx, v1910);
                                let v1912 = Some(v1911);
                                // Rule at src/isa/x64/lower.isle line 2780.
                                return v1912;
                            }
                            F64 => {
                                let v61 = C::unpack_value_array_2(ctx, v60);
                                let v95 = constructor_put_in_xmm(ctx, v61.0);
                                let v277 = constructor_put_in_xmm(ctx, v61.1);
                                let v207 = true;
                                let v1913 = constructor_xmm_min_max_seq(ctx, F64, v207, v95, v277);
                                let v1914 = constructor_output_xmm(ctx, v1913);
                                let v1915 = Some(v1914);
                                // Rule at src/isa/x64/lower.isle line 2782.
                                return v1915;
                            }
                            F32X4 => {
                                let v61 = C::unpack_value_array_2(ctx, v60);
                                let v95 = constructor_put_in_xmm(ctx, v61.0);
                                let v277 = constructor_put_in_xmm(ctx, v61.1);
                                let v278 = &C::xmm_to_xmm_mem_128(ctx, v277);
                                let v1916 = constructor_x64_minps(ctx, v95, v278);
                                let v516 = &C::xmm_to_xmm_mem_128(ctx, v95);
                                let v1917 = constructor_x64_minps(ctx, v277, v516);
                                let v1918 = &C::xmm_to_xmm_mem_128(ctx, v1917);
                                let v1919 = constructor_x64_orps(ctx, v1916, v1918);
                                let v1920 = &C::xmm_to_xmm_mem_128(ctx, v1917);
                                let v1921 = constructor_x64_cmpps(ctx, v1919, v1920, &FcmpImm::Unordered);
                                let v1922 = &C::xmm_to_xmm_mem_128(ctx, v1921);
                                let v1923 = constructor_x64_orps(ctx, v1919, v1922);
                                let v1925 = &C::xmi_imm(ctx, 0xa_u32);
                                let v1926 = constructor_x64_psrld(ctx, v1921, v1925);
                                let v1927 = &C::xmm_to_xmm_mem_128(ctx, v1923);
                                let v1928 = constructor_x64_andnps(ctx, v1926, v1927);
                                let v1929 = constructor_output_xmm(ctx, v1928);
                                let v1930 = Some(v1929);
                                // Rule at src/isa/x64/lower.isle line 2797.
                                return v1930;
                            }
                            F64X2 => {
                                let v61 = C::unpack_value_array_2(ctx, v60);
                                let v95 = constructor_put_in_xmm(ctx, v61.0);
                                let v277 = constructor_put_in_xmm(ctx, v61.1);
                                let v278 = &C::xmm_to_xmm_mem_128(ctx, v277);
                                let v1931 = constructor_x64_minpd(ctx, v95, v278);
                                let v516 = &C::xmm_to_xmm_mem_128(ctx, v95);
                                let v1932 = constructor_x64_minpd(ctx, v277, v516);
                                let v1933 = &C::xmm_to_xmm_mem_128(ctx, v1932);
                                let v1934 = constructor_x64_orpd(ctx, v1931, v1933);
                                let v1935 = &C::xmm_to_xmm_mem_128(ctx, v1932);
                                let v1936 = constructor_x64_cmppd(ctx, v1931, v1935, &FcmpImm::Unordered);
                                let v1937 = &C::xmm_to_xmm_mem_128(ctx, v1936);
                                let v1938 = constructor_x64_orpd(ctx, v1934, v1937);
                                let v1940 = &C::xmi_imm(ctx, 0xd_u32);
                                let v1941 = constructor_x64_psrlq(ctx, v1936, v1940);
                                let v1942 = &C::xmm_to_xmm_mem_128(ctx, v1938);
                                let v1943 = constructor_x64_andnpd(ctx, v1941, v1942);
                                let v1944 = constructor_output_xmm(ctx, v1943);
                                let v1945 = Some(v1944);
                                // Rule at src/isa/x64/lower.isle line 2842.
                                return v1945;
                            }
                            _ => {}
                        }
                    }
                }
                &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 v61 = C::unpack_value_array_2(ctx, v60);
                                let v95 = constructor_put_in_xmm(ctx, v61.0);
                                let v277 = constructor_put_in_xmm(ctx, v61.1);
                                let v197 = false;
                                let v1946 = constructor_xmm_min_max_seq(ctx, F32, v197, v95, v277);
                                let v1947 = constructor_output_xmm(ctx, v1946);
                                let v1948 = Some(v1947);
                                // Rule at src/isa/x64/lower.isle line 2856.
                                return v1948;
                            }
                            F64 => {
                                let v61 = C::unpack_value_array_2(ctx, v60);
                                let v95 = constructor_put_in_xmm(ctx, v61.0);
                                let v277 = constructor_put_in_xmm(ctx, v61.1);
                                let v197 = false;
                                let v1949 = constructor_xmm_min_max_seq(ctx, F64, v197, v95, v277);
                                let v1950 = constructor_output_xmm(ctx, v1949);
                                let v1951 = Some(v1950);
                                // Rule at src/isa/x64/lower.isle line 2858.
                                return v1951;
                            }
                            F32X4 => {
                                let v61 = C::unpack_value_array_2(ctx, v60);
                                let v95 = constructor_put_in_xmm(ctx, v61.0);
                                let v277 = constructor_put_in_xmm(ctx, v61.1);
                                let v278 = &C::xmm_to_xmm_mem_128(ctx, v277);
                                let v1952 = constructor_x64_maxps(ctx, v95, v278);
                                let v516 = &C::xmm_to_xmm_mem_128(ctx, v95);
                                let v1953 = constructor_x64_maxps(ctx, v277, v516);
                                let v1954 = &C::xmm_to_xmm_mem_128(ctx, v1953);
                                let v1955 = constructor_x64_xorps(ctx, v1952, v1954);
                                let v1956 = &C::xmm_to_xmm_mem_128(ctx, v1955);
                                let v1957 = constructor_x64_orps(ctx, v1952, v1956);
                                let v1958 = &C::xmm_to_xmm_mem_128(ctx, v1955);
                                let v1959 = constructor_x64_subps(ctx, v1957, v1958);
                                let v1960 = &C::xmm_to_xmm_mem_128(ctx, v1957);
                                let v1961 = constructor_x64_cmpps(ctx, v1957, v1960, &FcmpImm::Unordered);
                                let v1962 = &C::xmi_imm(ctx, 0xa_u32);
                                let v1963 = constructor_x64_psrld(ctx, v1961, v1962);
                                let v1964 = &C::xmm_to_xmm_mem_128(ctx, v1959);
                                let v1965 = constructor_x64_andnps(ctx, v1963, v1964);
                                let v1966 = constructor_output_xmm(ctx, v1965);
                                let v1967 = Some(v1966);
                                // Rule at src/isa/x64/lower.isle line 2864.
                                return v1967;
                            }
                            F64X2 => {
                                let v61 = C::unpack_value_array_2(ctx, v60);
                                let v95 = constructor_put_in_xmm(ctx, v61.0);
                                let v277 = constructor_put_in_xmm(ctx, v61.1);
                                let v278 = &C::xmm_to_xmm_mem_128(ctx, v277);
                                let v1968 = constructor_x64_maxpd(ctx, v95, v278);
                                let v516 = &C::xmm_to_xmm_mem_128(ctx, v95);
                                let v1969 = constructor_x64_maxpd(ctx, v277, v516);
                                let v1970 = &C::xmm_to_xmm_mem_128(ctx, v1969);
                                let v1971 = constructor_x64_xorpd(ctx, v1968, v1970);
                                let v1972 = &C::xmm_to_xmm_mem_128(ctx, v1971);
                                let v1973 = constructor_x64_orpd(ctx, v1968, v1972);
                                let v1974 = &C::xmm_to_xmm_mem_128(ctx, v1971);
                                let v1975 = constructor_x64_subpd(ctx, v1973, v1974);
                                let v1976 = &C::xmm_to_xmm_mem_128(ctx, v1973);
                                let v1977 = constructor_x64_cmppd(ctx, v1973, v1976, &FcmpImm::Unordered);
                                let v1978 = &C::xmi_imm(ctx, 0xd_u32);
                                let v1979 = constructor_x64_psrlq(ctx, v1977, v1978);
                                let v1980 = &C::xmm_to_xmm_mem_128(ctx, v1975);
                                let v1981 = constructor_x64_andnpd(ctx, v1979, v1980);
                                let v1982 = constructor_output_xmm(ctx, v1981);
                                let v1983 = Some(v1982);
                                // Rule at src/isa/x64/lower.isle line 2909.
                                return v1983;
                            }
                            _ => {}
                        }
                    }
                }
                &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 v61 = C::unpack_value_array_2(ctx, v60);
                                let v2949 = C::value_type(ctx, v61.0);
                                if v2949 == I16X8 {
                                    let v95 = constructor_put_in_xmm(ctx, v61.0);
                                    let v96 = &C::put_in_xmm_mem_128(ctx, v61.1);
                                    let v2950 = constructor_x64_packsswb(ctx, v95, v96);
                                    let v2951 = constructor_output_xmm(ctx, v2950);
                                    let v2952 = Some(v2951);
                                    // Rule at src/isa/x64/lower.isle line 4206.
                                    return v2952;
                                }
                            }
                            I16X8 => {
                                let v61 = C::unpack_value_array_2(ctx, v60);
                                let v2949 = C::value_type(ctx, v61.0);
                                if v2949 == I32X4 {
                                    let v95 = constructor_put_in_xmm(ctx, v61.0);
                                    let v96 = &C::put_in_xmm_mem_128(ctx, v61.1);
                                    let v2953 = constructor_x64_packssdw(ctx, v95, v96);
                                    let v2954 = constructor_output_xmm(ctx, v2953);
                                    let v2955 = Some(v2954);
                                    // Rule at src/isa/x64/lower.isle line 4209.
                                    return v2955;
                                }
                            }
                            I32X4 => {
                                let v61 = C::unpack_value_array_2(ctx, v60);
                                let v122 = C::def_inst(ctx, v61.1);
                                if let Some(v123) = v122 {
                                    let v124 = C::inst_data_value(ctx, v123);
                                    if let &InstructionData::UnaryConst {
                                        opcode: ref v2959,
                                        constant_handle: v2960,
                                    } = &v124.1 {
                                        if let &Opcode::Vconst = v2959 {
                                            let v150 = C::def_inst(ctx, v61.0);
                                            if let Some(v151) = v150 {
                                                let v152 = C::inst_data_value(ctx, v151);
                                                if let &InstructionData::Unary {
                                                    opcode: ref v155,
                                                    arg: v156,
                                                } = &v152.1 {
                                                    match v155 {
                                                        &Opcode::FcvtToSintSat => {
                                                            let v2956 = C::first_result(ctx, v151);
                                                            if let Some(v2957) = v2956 {
                                                                let v2958 = C::value_type(ctx, v2957);
                                                                if v2958 == I64X2 {
                                                                    let v2961 = C::u128_from_constant(ctx, v2960);
                                                                    if let Some(v2962) = v2961 {
                                                                        if v2962 == 0x0_u128 {
                                                                            let v293 = constructor_put_in_xmm(ctx, v156);
                                                                            let v2963 = &C::xmm_to_xmm_mem_128(ctx, v293);
                                                                            let v2964 = constructor_x64_cmppd(ctx, v293, v2963, &FcmpImm::Equal);
                                                                            let v2966 = &constructor_emit_xmm_mem_128_le_const(ctx, 0x41dfffffffc0000041dfffffffc00000_u128);
                                                                            let v2967 = constructor_x64_andps(ctx, v2964, v2966);
                                                                            let v2968 = &C::xmm_to_xmm_mem_128(ctx, v2967);
                                                                            let v2969 = constructor_x64_minpd(ctx, v293, v2968);
                                                                            let v2970 = &C::xmm_to_xmm_mem_128(ctx, v2969);
                                                                            let v2971 = constructor_x64_cvttpd2dq(ctx, v2970);
                                                                            let v2972 = constructor_output_xmm(ctx, v2971);
                                                                            let v2973 = Some(v2972);
                                                                            // Rule at src/isa/x64/lower.isle line 4218.
                                                                            return v2973;
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        &Opcode::X86Cvtt2dq => {
                                                            let v2956 = C::first_result(ctx, v151);
                                                            if let Some(v2957) = v2956 {
                                                                let v2958 = C::value_type(ctx, v2957);
                                                                if v2958 == I64X2 {
                                                                    let v2961 = C::u128_from_constant(ctx, v2960);
                                                                    if let Some(v2962) = v2961 {
                                                                        if v2962 == 0x0_u128 {
                                                                            let v752 = &C::put_in_xmm_mem_128(ctx, v156);
                                                                            let v2974 = constructor_x64_cvttpd2dq(ctx, v752);
                                                                            let v2975 = constructor_output_xmm(ctx, v2974);
                                                                            let v2976 = Some(v2975);
                                                                            // Rule at src/isa/x64/lower.isle line 4242.
                                                                            return v2976;
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            _ => {}
                        }
                    }
                }
                &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 v61 = C::unpack_value_array_2(ctx, v60);
                                let v2949 = C::value_type(ctx, v61.0);
                                if v2949 == I16X8 {
                                    let v95 = constructor_put_in_xmm(ctx, v61.0);
                                    let v96 = &C::put_in_xmm_mem_128(ctx, v61.1);
                                    let v2977 = constructor_x64_packuswb(ctx, v95, v96);
                                    let v2978 = constructor_output_xmm(ctx, v2977);
                                    let v2979 = Some(v2978);
                                    // Rule at src/isa/x64/lower.isle line 4248.
                                    return v2979;
                                }
                            }
                            I16X8 => {
                                let v61 = C::unpack_value_array_2(ctx, v60);
                                let v2949 = C::value_type(ctx, v61.0);
                                if v2949 == I32X4 {
                                    let v692 = C::has_sse41(ctx);
                                    if v692 == true {
                                        let v95 = constructor_put_in_xmm(ctx, v61.0);
                                        let v96 = &C::put_in_xmm_mem_128(ctx, v61.1);
                                        let v2980 = constructor_x64_packusdw(ctx, v95, v96);
                                        let v2981 = constructor_output_xmm(ctx, v2980);
                                        let v2982 = Some(v2981);
                                        // Rule at src/isa/x64/lower.isle line 4251.
                                        return v2982;
                                    }
                                    let v95 = constructor_put_in_xmm(ctx, v61.0);
                                    let v2983 = constructor_unarrow_i32x4_lanes_to_low_u16_lanes(ctx, v95);
                                    let v2984 = constructor_put_in_xmm(ctx, v61.1);
                                    let v2985 = constructor_unarrow_i32x4_lanes_to_low_u16_lanes(ctx, v2984);
                                    let v2986 = &C::xmm_to_xmm_mem_128(ctx, v2985);
                                    let v2987 = constructor_x64_punpcklqdq(ctx, v2983, v2986);
                                    let v2988 = constructor_output_xmm(ctx, v2987);
                                    let v2989 = Some(v2988);
                                    // Rule at src/isa/x64/lower.isle line 4261.
                                    return v2989;
                                }
                            }
                            _ => {}
                        }
                    }
                }
                &Opcode::Uunarrow => {
                    let v61 = C::unpack_value_array_2(ctx, v60);
                    let v122 = C::def_inst(ctx, v61.1);
                    if let Some(v123) = v122 {
                        let v124 = C::inst_data_value(ctx, v123);
                        if let &InstructionData::UnaryConst {
                            opcode: ref v2959,
                            constant_handle: v2960,
                        } = &v124.1 {
                            if let &Opcode::Vconst = v2959 {
                                let v150 = C::def_inst(ctx, v61.0);
                                if let Some(v151) = v150 {
                                    let v152 = C::inst_data_value(ctx, v151);
                                    if let &InstructionData::Unary {
                                        opcode: ref v155,
                                        arg: v156,
                                    } = &v152.1 {
                                        if let &Opcode::FcvtToUintSat = v155 {
                                            let v682 = C::value_type(ctx, v156);
                                            if v682 == F64X2 {
                                                let v2961 = C::u128_from_constant(ctx, v2960);
                                                if let Some(v2962) = v2961 {
                                                    if v2962 == 0x0_u128 {
                                                        let v293 = constructor_put_in_xmm(ctx, v156);
                                                        let v2624 = constructor_xmm_zero(ctx, F64X2);
                                                        let v3542 = &C::xmm_to_xmm_mem_128(ctx, v2624);
                                                        let v3543 = constructor_x64_maxpd(ctx, v293, v3542);
                                                        let v3545 = &constructor_emit_xmm_mem_128_le_const(ctx, 0x41efffffffe0000041efffffffe00000_u128);
                                                        let v3546 = constructor_x64_minpd(ctx, v3543, v3545);
                                                        let v3547 = &C::xmm_to_xmm_mem_128(ctx, v3546);
                                                        let v3548 = constructor_x64_round_f64x2(ctx, v3547, &RoundImm::RoundZero);
                                                        let v3549 = &constructor_emit_xmm_mem_128_le_const(ctx, 0x43300000000000004330000000000000_u128);
                                                        let v3550 = constructor_x64_addpd(ctx, v3548, v3549);
                                                        let v3551 = &C::xmm_to_xmm_mem_128(ctx, v2624);
                                                        let v3552 = constructor_x64_shufps(ctx, v3550, v3551, 0x88_u8);
                                                        let v3553 = constructor_output_xmm(ctx, v3552);
                                                        let v3554 = Some(v3553);
                                                        // Rule at src/isa/x64/lower.isle line 5158.
                                                        return v3554;
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
                &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 v2773 = &constructor_emit_xmm_mem_128_le_const(ctx, 0xff00ff00ff00ff00ff00ff00ff00ff_u128);
                                let v2774 = constructor_x64_movdqu_load(ctx, v2773);
                                let v61 = C::unpack_value_array_2(ctx, v60);
                                let v2775 = constructor_put_in_xmm(ctx, v61.0);
                                let v2776 = &C::xmm_to_xmm_mem_128(ctx, v2774);
                                let v2777 = constructor_x64_pand(ctx, v2775, v2776);
                                let v2778 = constructor_put_in_xmm(ctx, v61.1);
                                let v2779 = &C::xmm_to_xmm_mem_128(ctx, v2774);
                                let v2780 = constructor_x64_pand(ctx, v2778, v2779);
                                let v2781 = &C::xmm_to_xmm_mem_128(ctx, v2780);
                                let v2782 = constructor_x64_packuswb(ctx, v2777, v2781);
                                let v2783 = constructor_put_in_xmm(ctx, v61.0);
                                let v2785 = &C::xmi_imm(ctx, 0x8_u32);
                                let v2786 = constructor_x64_psrlw(ctx, v2783, v2785);
                                let v2787 = constructor_put_in_xmm(ctx, v61.1);
                                let v2788 = &C::xmi_imm(ctx, 0x8_u32);
                                let v2789 = constructor_x64_psrlw(ctx, v2787, v2788);
                                let v2790 = &C::xmm_to_xmm_mem_128(ctx, v2789);
                                let v2791 = constructor_x64_packuswb(ctx, v2786, v2790);
                                let v2792 = &C::xmm_to_xmm_mem_128(ctx, v2791);
                                let v2793 = constructor_x64_paddb(ctx, v2782, v2792);
                                let v2794 = constructor_output_xmm(ctx, v2793);
                                let v2795 = Some(v2794);
                                // Rule at src/isa/x64/lower.isle line 3990.
                                return v2795;
                            }
                            I16X8 => {
                                let v785 = C::has_ssse3(ctx);
                                if v785 == true {
                                    let v61 = C::unpack_value_array_2(ctx, v60);
                                    let v122 = C::def_inst(ctx, v61.1);
                                    if let Some(v123) = v122 {
                                        let v124 = C::inst_data_value(ctx, v123);
                                        if let &InstructionData::Unary {
                                            opcode: ref v141,
                                            arg: v142,
                                        } = &v124.1 {
                                            match v141 {
                                                &Opcode::SwidenHigh => {
                                                    let v150 = C::def_inst(ctx, v61.0);
                                                    if let Some(v151) = v150 {
                                                        let v152 = C::inst_data_value(ctx, v151);
                                                        if let &InstructionData::Unary {
                                                            opcode: ref v155,
                                                            arg: v156,
                                                        } = &v152.1 {
                                                            if let &Opcode::SwidenLow = v155 {
                                                                if v142 == v156 {
                                                                    let v682 = C::value_type(ctx, v156);
                                                                    if v682 == I8X16 {
                                                                        let v2835 = C::emit_u128_le_const(ctx, 0x1010101010101010101010101010101_u128);
                                                                        let v2836 = constructor_x64_xmm_load_const(ctx, I8X16, v2835);
                                                                        let v2837 = &C::put_in_xmm_mem_128(ctx, v156);
                                                                        let v2838 = constructor_x64_pmaddubsw(ctx, v2836, v2837);
                                                                        let v2839 = constructor_output_xmm(ctx, v2838);
                                                                        let v2840 = Some(v2839);
                                                                        // Rule at src/isa/x64/lower.isle line 4052.
                                                                        return v2840;
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                &Opcode::UwidenHigh => {
                                                    let v150 = C::def_inst(ctx, v61.0);
                                                    if let Some(v151) = v150 {
                                                        let v152 = C::inst_data_value(ctx, v151);
                                                        if let &InstructionData::Unary {
                                                            opcode: ref v155,
                                                            arg: v156,
                                                        } = &v152.1 {
                                                            if let &Opcode::UwidenLow = v155 {
                                                                if v142 == v156 {
                                                                    let v682 = C::value_type(ctx, v156);
                                                                    if v682 == I8X16 {
                                                                        let v2847 = &constructor_emit_xmm_mem_128_le_const(ctx, 0x1010101010101010101010101010101_u128);
                                                                        let v2843 = constructor_put_in_xmm(ctx, v156);
                                                                        let v2848 = constructor_x64_pmaddubsw(ctx, v2843, v2847);
                                                                        let v2849 = constructor_output_xmm(ctx, v2848);
                                                                        let v2850 = Some(v2849);
                                                                        // Rule at src/isa/x64/lower.isle line 4070.
                                                                        return v2850;
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                _ => {}
                                            }
                                        }
                                    }
                                    let v95 = constructor_put_in_xmm(ctx, v61.0);
                                    let v96 = &C::put_in_xmm_mem_128(ctx, v61.1);
                                    let v2796 = constructor_x64_phaddw(ctx, v95, v96);
                                    let v2797 = constructor_output_xmm(ctx, v2796);
                                    let v2798 = Some(v2797);
                                    // Rule at src/isa/x64/lower.isle line 4006.
                                    return v2798;
                                }
                                let v61 = C::unpack_value_array_2(ctx, v60);
                                let v95 = constructor_put_in_xmm(ctx, v61.0);
                                let v277 = constructor_put_in_xmm(ctx, v61.1);
                                let v514 = &C::xmm_to_xmm_mem_128(ctx, v95);
                                let v2800 = constructor_x64_pshuflw(ctx, v514, 0xe8_u8);
                                let v2801 = &C::xmm_to_xmm_mem_128(ctx, v2800);
                                let v2802 = constructor_x64_pshufhw(ctx, v2801, 0xe8_u8);
                                let v2803 = &C::xmm_to_xmm_mem_128(ctx, v2802);
                                let v2804 = constructor_x64_pshufd(ctx, v2803, 0xe8_u8);
                                let v2805 = &C::xmm_to_xmm_mem_128(ctx, v277);
                                let v2806 = constructor_x64_pshuflw(ctx, v2805, 0xe8_u8);
                                let v2807 = &C::xmm_to_xmm_mem_128(ctx, v2806);
                                let v2808 = constructor_x64_pshufhw(ctx, v2807, 0xe8_u8);
                                let v2809 = &C::xmm_to_xmm_mem_128(ctx, v2808);
                                let v2810 = constructor_x64_pshufd(ctx, v2809, 0xe8_u8);
                                let v2811 = &C::xmm_to_xmm_mem_128(ctx, v2810);
                                let v2812 = constructor_x64_punpcklqdq(ctx, v2804, v2811);
                                let v2813 = &C::xmi_imm(ctx, 0x10_u32);
                                let v2814 = constructor_x64_psrad(ctx, v95, v2813);
                                let v2815 = &C::xmi_imm(ctx, 0x10_u32);
                                let v2816 = constructor_x64_psrad(ctx, v277, v2815);
                                let v2817 = &C::xmm_to_xmm_mem_128(ctx, v2816);
                                let v2818 = constructor_x64_packssdw(ctx, v2814, v2817);
                                let v2819 = &C::xmm_to_xmm_mem_128(ctx, v2818);
                                let v2820 = constructor_x64_paddw(ctx, v2812, v2819);
                                let v2821 = constructor_output_xmm(ctx, v2820);
                                let v2822 = Some(v2821);
                                // Rule at src/isa/x64/lower.isle line 4010.
                                return v2822;
                            }
                            I32X4 => {
                                let v61 = C::unpack_value_array_2(ctx, v60);
                                let v122 = C::def_inst(ctx, v61.1);
                                if let Some(v123) = v122 {
                                    let v124 = C::inst_data_value(ctx, v123);
                                    match &v124.1 {
                                        &InstructionData::Binary {
                                            opcode: ref v127,
                                            args: ref v128,
                                        } => {
                                            if let &Opcode::Imul = v127 {
                                                let v150 = C::def_inst(ctx, v61.0);
                                                if let Some(v151) = v150 {
                                                    let v152 = C::inst_data_value(ctx, v151);
                                                    if let &InstructionData::Binary {
                                                        opcode: ref v376,
                                                        args: ref v377,
                                                    } = &v152.1 {
                                                        if let &Opcode::Imul = v376 {
                                                            let v378 = C::unpack_value_array_2(ctx, v377);
                                                            let v381 = C::def_inst(ctx, v378.1);
                                                            if let Some(v382) = v381 {
                                                                let v383 = C::inst_data_value(ctx, v382);
                                                                if let &InstructionData::Unary {
                                                                    opcode: ref v2868,
                                                                    arg: v2869,
                                                                } = &v383.1 {
                                                                    if let &Opcode::SwidenLow = v2868 {
                                                                        let v129 = C::unpack_value_array_2(ctx, v128);
                                                                        let v391 = C::def_inst(ctx, v129.1);
                                                                        if let Some(v392) = v391 {
                                                                            let v393 = C::inst_data_value(ctx, v392);
                                                                            if let &InstructionData::Unary {
                                                                                opcode: ref v2877,
                                                                                arg: v2878,
                                                                            } = &v393.1 {
                                                                                if let &Opcode::SwidenHigh = v2877 {
                                                                                    if v2869 == v2878 {
                                                                                        let v2861 = C::def_inst(ctx, v378.0);
                                                                                        if let Some(v2862) = v2861 {
                                                                                            let v2863 = C::inst_data_value(ctx, v2862);
                                                                                            if let &InstructionData::Unary {
                                                                                                opcode: ref v2866,
                                                                                                arg: v2867,
                                                                                            } = &v2863.1 {
                                                                                                if let &Opcode::SwidenLow = v2866 {
                                                                                                    let v2870 = C::def_inst(ctx, v129.0);
                                                                                                    if let Some(v2871) = v2870 {
                                                                                                        let v2872 = C::inst_data_value(ctx, v2871);
                                                                                                        if let &InstructionData::Unary {
                                                                                                            opcode: ref v2875,
                                                                                                            arg: v2876,
                                                                                                        } = &v2872.1 {
                                                                                                            if let &Opcode::SwidenHigh = v2875 {
                                                                                                                if v2867 == v2876 {
                                                                                                                    let v2879 = constructor_put_in_xmm(ctx, v2867);
                                                                                                                    let v2880 = &C::put_in_xmm_mem_128(ctx, v2869);
                                                                                                                    let v2881 = constructor_x64_pmaddwd(ctx, v2879, v2880);
                                                                                                                    let v2882 = constructor_output_xmm(ctx, v2881);
                                                                                                                    let v2883 = Some(v2882);
                                                                                                                    // Rule at src/isa/x64/lower.isle line 4093.
                                                                                                                    return v2883;
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        &InstructionData::Unary {
                                            opcode: ref v141,
                                            arg: v142,
                                        } => {
                                            match v141 {
                                                &Opcode::SwidenHigh => {
                                                    let v150 = C::def_inst(ctx, v61.0);
                                                    if let Some(v151) = v150 {
                                                        let v152 = C::inst_data_value(ctx, v151);
                                                        if let &InstructionData::Unary {
                                                            opcode: ref v155,
                                                            arg: v156,
                                                        } = &v152.1 {
                                                            if let &Opcode::SwidenLow = v155 {
                                                                if v142 == v156 {
                                                                    let v682 = C::value_type(ctx, v156);
                                                                    if v682 == I16X8 {
                                                                        let v2842 = &constructor_emit_xmm_mem_128_le_const(ctx, 0x10001000100010001000100010001_u128);
                                                                        let v2843 = constructor_put_in_xmm(ctx, v156);
                                                                        let v2844 = constructor_x64_pmaddwd(ctx, v2843, v2842);
                                                                        let v2845 = constructor_output_xmm(ctx, v2844);
                                                                        let v2846 = Some(v2845);
                                                                        // Rule at src/isa/x64/lower.isle line 4062.
                                                                        return v2846;
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                &Opcode::UwidenHigh => {
                                                    let v150 = C::def_inst(ctx, v61.0);
                                                    if let Some(v151) = v150 {
                                                        let v152 = C::inst_data_value(ctx, v151);
                                                        if let &InstructionData::Unary {
                                                            opcode: ref v155,
                                                            arg: v156,
                                                        } = &v152.1 {
                                                            if let &Opcode::UwidenLow = v155 {
                                                                if v142 == v156 {
                                                                    let v682 = C::value_type(ctx, v156);
                                                                    if v682 == I16X8 {
                                                                        let v2852 = &constructor_emit_xmm_mem_128_le_const(ctx, 0x80008000800080008000800080008000_u128);
                                                                        let v2843 = constructor_put_in_xmm(ctx, v156);
                                                                        let v2853 = constructor_x64_pxor(ctx, v2843, v2852);
                                                                        let v2854 = &constructor_emit_xmm_mem_128_le_const(ctx, 0x10001000100010001000100010001_u128);
                                                                        let v2855 = constructor_x64_pmaddwd(ctx, v2853, v2854);
                                                                        let v2857 = &constructor_emit_xmm_mem_128_le_const(ctx, 0x10000000100000001000000010000_u128);
                                                                        let v2858 = constructor_x64_paddd(ctx, v2855, v2857);
                                                                        let v2859 = constructor_output_xmm(ctx, v2858);
                                                                        let v2860 = Some(v2859);
                                                                        // Rule at src/isa/x64/lower.isle line 4079.
                                                                        return v2860;
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                _ => {}
                                            }
                                        }
                                        _ => {}
                                    }
                                }
                                let v785 = C::has_ssse3(ctx);
                                if v785 == true {
                                    let v95 = constructor_put_in_xmm(ctx, v61.0);
                                    let v96 = &C::put_in_xmm_mem_128(ctx, v61.1);
                                    let v2823 = constructor_x64_phaddd(ctx, v95, v96);
                                    let v2824 = constructor_output_xmm(ctx, v2823);
                                    let v2825 = Some(v2824);
                                    // Rule at src/isa/x64/lower.isle line 4036.
                                    return v2825;
                                }
                                let v95 = constructor_put_in_xmm(ctx, v61.0);
                                let v277 = constructor_put_in_xmm(ctx, v61.1);
                                let v278 = &C::xmm_to_xmm_mem_128(ctx, v277);
                                let v2827 = constructor_x64_shufps(ctx, v95, v278, 0x88_u8);
                                let v698 = &C::xmm_to_xmm_mem_128(ctx, v277);
                                let v2829 = constructor_x64_shufps(ctx, v95, v698, 0xdd_u8);
                                let v2830 = &C::xmm_to_xmm_mem_128(ctx, v2829);
                                let v2831 = constructor_x64_paddd(ctx, v2827, v2830);
                                let v2832 = constructor_output_xmm(ctx, v2831);
                                let v2833 = Some(v2832);
                                // Rule at src/isa/x64/lower.isle line 4040.
                                return v2833;
                            }
                            _ => {}
                        }
                    }
                }
                &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 v785 = C::has_ssse3(ctx);
                            if v785 == true {
                                let v61 = C::unpack_value_array_2(ctx, v60);
                                let v1792 = constructor_put_in_xmm(ctx, v61.1);
                                let v289 = &C::put_in_xmm_mem_128(ctx, v61.0);
                                let v1793 = constructor_x64_pmaddubsw(ctx, v1792, v289);
                                let v1794 = constructor_output_xmm(ctx, v1793);
                                let v1795 = Some(v1794);
                                // Rule at src/isa/x64/lower.isle line 2682.
                                return v1795;
                            }
                        }
                    }
                }
                &Opcode::Iconcat => {
                    let v61 = C::unpack_value_array_2(ctx, v60);
                    let v2949 = C::value_type(ctx, v61.0);
                    if v2949 == I64 {
                        let v3488 = C::put_in_reg(ctx, v61.0);
                        let v3489 = C::put_in_reg(ctx, v61.1);
                        let v3490 = C::value_regs(ctx, v3488, v3489);
                        let v3491 = C::output(ctx, v3490);
                        let v3492 = Some(v3491);
                        // Rule at src/isa/x64/lower.isle line 5074.
                        return v3492;
                    }
                }
                _ => {}
            }
        }
        &InstructionData::BinaryImm8 {
            opcode: ref v3292,
            arg: v3293,
            imm: v3294,
        } => {
            if let &Opcode::Extractlane = v3292 {
                if v3294 == 0x0 {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        let v275 = C::ty_scalar_float(ctx, v3);
                        if let Some(v276) = v275 {
                            let v3295 = constructor_output_value(ctx, v3293);
                            let v3296 = Some(v3295);
                            // Rule at src/isa/x64/lower.isle line 4786.
                            return v3296;
                        }
                    }
                }
                let v3297 = C::value_type(ctx, v3293);
                match v3297 {
                    I8X16 => {
                        let v692 = C::has_sse41(ctx);
                        if v692 == true {
                            let v3306 = constructor_put_in_xmm(ctx, v3293);
                            let v3298 = C::u8_from_uimm8(ctx, v3294);
                            let v3307 = constructor_x64_pextrb(ctx, v3306, v3298);
                            let v3308 = constructor_output_gpr(ctx, v3307);
                            let v3309 = Some(v3308);
                            // Rule at src/isa/x64/lower.isle line 4801.
                            return v3309;
                        }
                        let v3298 = C::u8_from_uimm8(ctx, v3294);
                        let v3310 = C::u8_and(ctx, v3298, 0x1_u8);
                        match v3310 {
                            0x0_u8 => {
                                let v3306 = constructor_put_in_xmm(ctx, v3293);
                                let v3311 = C::u8_wrapping_shr(ctx, v3298, 0x1_u32);
                                let v3312 = constructor_x64_pextrw(ctx, v3306, v3311);
                                let v3316 = constructor_output_gpr(ctx, v3312);
                                let v3317 = Some(v3316);
                                // Rule at src/isa/x64/lower.isle line 4812.
                                return v3317;
                            }
                            0x1_u8 => {
                                let v3306 = constructor_put_in_xmm(ctx, v3293);
                                let v3311 = C::u8_wrapping_shr(ctx, v3298, 0x1_u32);
                                let v3312 = constructor_x64_pextrw(ctx, v3306, v3311);
                                let v3313 = constructor_x64_shrw_mi(ctx, v3312, 0x8_u8);
                                let v3314 = constructor_output_gpr(ctx, v3313);
                                let v3315 = Some(v3314);
                                // Rule at src/isa/x64/lower.isle line 4805.
                                return v3315;
                            }
                            _ => {}
                        }
                    }
                    I16X8 => {
                        let v3306 = constructor_put_in_xmm(ctx, v3293);
                        let v3298 = C::u8_from_uimm8(ctx, v3294);
                        let v3318 = constructor_x64_pextrw(ctx, v3306, v3298);
                        let v3319 = constructor_output_gpr(ctx, v3318);
                        let v3320 = Some(v3319);
                        // Rule at src/isa/x64/lower.isle line 4817.
                        return v3320;
                    }
                    I32X4 => {
                        let v692 = C::has_sse41(ctx);
                        if v692 == true {
                            let v3306 = constructor_put_in_xmm(ctx, v3293);
                            let v3298 = C::u8_from_uimm8(ctx, v3294);
                            let v3321 = constructor_x64_pextrd(ctx, v3306, v3298);
                            let v3322 = constructor_output_gpr(ctx, v3321);
                            let v3323 = Some(v3322);
                            // Rule at src/isa/x64/lower.isle line 4821.
                            return v3323;
                        }
                        if v3294 == 0x0 {
                            let v3306 = constructor_put_in_xmm(ctx, v3293);
                            let v3324 = constructor_x64_movd_to_gpr(ctx, v3306);
                            let v3325 = constructor_output_gpr(ctx, v3324);
                            let v3326 = Some(v3325);
                            // Rule at src/isa/x64/lower.isle line 4824.
                            return v3326;
                        }
                        let v3299 = &C::put_in_xmm_mem_128(ctx, v3293);
                        let v3298 = C::u8_from_uimm8(ctx, v3294);
                        let v3300 = constructor_x64_pshufd(ctx, v3299, v3298);
                        let v3327 = constructor_x64_movd_to_gpr(ctx, v3300);
                        let v3328 = constructor_output_gpr(ctx, v3327);
                        let v3329 = Some(v3328);
                        // Rule at src/isa/x64/lower.isle line 4826.
                        return v3329;
                    }
                    I64X2 => {
                        let v692 = C::has_sse41(ctx);
                        if v692 == true {
                            let v3306 = constructor_put_in_xmm(ctx, v3293);
                            let v3298 = C::u8_from_uimm8(ctx, v3294);
                            let v3330 = constructor_x64_pextrq(ctx, v3306, v3298);
                            let v3331 = constructor_output_gpr(ctx, v3330);
                            let v3332 = Some(v3331);
                            // Rule at src/isa/x64/lower.isle line 4830.
                            return v3332;
                        }
                        match v3294 {
                            0x0 => {
                                let v3306 = constructor_put_in_xmm(ctx, v3293);
                                let v3333 = constructor_x64_movq_to_gpr(ctx, v3306);
                                let v3334 = constructor_output_gpr(ctx, v3333);
                                let v3335 = Some(v3334);
                                // Rule at src/isa/x64/lower.isle line 4833.
                                return v3335;
                            }
                            0x1 => {
                                let v3299 = &C::put_in_xmm_mem_128(ctx, v3293);
                                let v3336 = constructor_x64_pshufd(ctx, v3299, 0xe_u8);
                                let v3337 = constructor_x64_movq_to_gpr(ctx, v3336);
                                let v3338 = constructor_output_gpr(ctx, v3337);
                                let v3339 = Some(v3338);
                                // Rule at src/isa/x64/lower.isle line 4835.
                                return v3339;
                            }
                            _ => {}
                        }
                    }
                    F32X4 => {
                        let v3299 = &C::put_in_xmm_mem_128(ctx, v3293);
                        let v3298 = C::u8_from_uimm8(ctx, v3294);
                        let v3300 = constructor_x64_pshufd(ctx, v3299, v3298);
                        let v3301 = constructor_output_xmm(ctx, v3300);
                        let v3302 = Some(v3301);
                        // Rule at src/isa/x64/lower.isle line 4790.
                        return v3302;
                    }
                    F64X2 => {
                        if v3294 == 0x1 {
                            let v3299 = &C::put_in_xmm_mem_128(ctx, v3293);
                            let v3303 = constructor_x64_pshufd(ctx, v3299, 0xee_u8);
                            let v3304 = constructor_output_xmm(ctx, v3303);
                            let v3305 = Some(v3304);
                            // Rule at src/isa/x64/lower.isle line 4794.
                            return v3305;
                        }
                    }
                    _ => {}
                }
            }
        }
        &InstructionData::Call {
            opcode: ref v2510,
            args: v2511,
            func_ref: v2512,
        } => {
            match v2510 {
                &Opcode::Call => {
                    let v2514 = C::func_ref_data(ctx, v2512);
                    if let &RelocDistance::Near = &v2514.2 {
                        let v2519 = &C::gen_call_output(ctx, v2514.0);
                        let v2520 = C::abi_sig(ctx, v2514.0);
                        let v2513 = C::value_list_slice(ctx, v2511);
                        let v2521 = &C::put_in_regs_vec(ctx, v2513);
                        let v2522 = C::gen_call_args(ctx, v2520, v2521);
                        let v2523 = C::gen_call_rets(ctx, v2520, v2519);
                        let v2524 = C::try_call_none(ctx);
                        let v2525 = &C::gen_call_info(ctx, v2520, v2514.1, v2522, v2523, v2524, v2514.3);
                        let v2526 = &constructor_call_known(ctx, v2525);
                        let v2527 = constructor_emit_side_effect(ctx, v2526);
                        let v2528 = C::output_vec(ctx, v2519);
                        let v2529 = Some(v2528);
                        // Rule at src/isa/x64/lower.isle line 3536.
                        return v2529;
                    }
                    if v2514.3 == false {
                        let v2519 = &C::gen_call_output(ctx, v2514.0);
                        let v2520 = C::abi_sig(ctx, v2514.0);
                        let v2513 = C::value_list_slice(ctx, v2511);
                        let v2521 = &C::put_in_regs_vec(ctx, v2513);
                        let v2522 = C::gen_call_args(ctx, v2520, v2521);
                        let v2523 = C::gen_call_rets(ctx, v2520, v2519);
                        let v2530 = constructor_load_ext_name(ctx, v2514.1, 0_i64, &v2514.2);
                        let v2531 = C::gpr_to_reg(ctx, v2530);
                        let v2533 = C::try_call_none(ctx);
                        let v2532 = RegMem::Reg {
                            reg: v2531,
                        };
                        let v2534 = &C::gen_call_ind_info(ctx, v2520, &v2532, v2522, v2523, v2533);
                        let v2535 = &constructor_call_unknown(ctx, v2534);
                        let v2536 = constructor_emit_side_effect(ctx, v2535);
                        let v2537 = C::output_vec(ctx, v2519);
                        let v2538 = Some(v2537);
                        // Rule at src/isa/x64/lower.isle line 3546.
                        return v2538;
                    }
                }
                &Opcode::ReturnCall => {
                    let v2514 = C::func_ref_data(ctx, v2512);
                    if v2514.3 == false {
                        if let &RelocDistance::Near = &v2514.2 {
                            let v2560 = C::abi_sig(ctx, v2514.0);
                            let v2513 = C::value_list_slice(ctx, v2511);
                            let v2561 = &C::put_in_regs_vec(ctx, v2513);
                            let v2562 = C::gen_return_call_args(ctx, v2560, v2561);
                            let v2563 = &C::gen_return_call_info(ctx, v2560, v2514.1, v2562);
                            let v2564 = &constructor_return_call_known(ctx, v2563);
                            let v2565 = constructor_side_effect(ctx, v2564);
                            let v2566 = Some(v2565);
                            // Rule at src/isa/x64/lower.isle line 3570.
                            return v2566;
                        }
                        let v2560 = C::abi_sig(ctx, v2514.0);
                        let v2513 = C::value_list_slice(ctx, v2511);
                        let v2561 = &C::put_in_regs_vec(ctx, v2513);
                        let v2562 = C::gen_return_call_args(ctx, v2560, v2561);
                        let v2567 = constructor_load_ext_name(ctx, v2514.1, 0_i64, &v2514.2);
                        let v2568 = C::gpr_to_reg(ctx, v2567);
                        let v2569 = &C::gen_return_call_ind_info(ctx, v2560, v2568, v2562);
                        let v2570 = &constructor_return_call_unknown(ctx, v2569);
                        let v2571 = constructor_side_effect(ctx, v2570);
                        let v2572 = Some(v2571);
                        // Rule at src/isa/x64/lower.isle line 3577.
                        return v2572;
                    }
                }
                _ => {}
            }
        }
        &InstructionData::CallIndirect {
            opcode: ref v2539,
            args: v2540,
            sig_ref: v2541,
        } => {
            match v2539 {
                &Opcode::CallIndirect => {
                    let v2542 = C::value_list_slice(ctx, v2540);
                    let v2543 = C::value_slice_unwrap(ctx, v2542);
                    if let Some(v2544) = v2543 {
                        let v2547 = &C::gen_call_output(ctx, v2541);
                        let v2548 = C::abi_sig(ctx, v2541);
                        let v2549 = C::put_in_reg(ctx, v2544.0);
                        let v2551 = &C::put_in_regs_vec(ctx, v2544.1);
                        let v2552 = C::gen_call_args(ctx, v2548, v2551);
                        let v2553 = C::gen_call_rets(ctx, v2548, v2547);
                        let v2554 = C::try_call_none(ctx);
                        let v2550 = RegMem::Reg {
                            reg: v2549,
                        };
                        let v2555 = &C::gen_call_ind_info(ctx, v2548, &v2550, v2552, v2553, v2554);
                        let v2556 = &constructor_call_unknown(ctx, v2555);
                        let v2557 = constructor_emit_side_effect(ctx, v2556);
                        let v2558 = C::output_vec(ctx, v2547);
                        let v2559 = Some(v2558);
                        // Rule at src/isa/x64/lower.isle line 3557.
                        return v2559;
                    }
                }
                &Opcode::ReturnCallIndirect => {
                    let v2542 = C::value_list_slice(ctx, v2540);
                    let v2543 = C::value_slice_unwrap(ctx, v2542);
                    if let Some(v2544) = v2543 {
                        let v2573 = C::abi_sig(ctx, v2541);
                        let v2574 = C::put_in_reg(ctx, v2544.0);
                        let v2575 = &C::put_in_regs_vec(ctx, v2544.1);
                        let v2576 = C::gen_return_call_args(ctx, v2573, v2575);
                        let v2577 = &C::gen_return_call_ind_info(ctx, v2573, v2574, v2576);
                        let v2578 = &constructor_return_call_unknown(ctx, v2577);
                        let v2579 = constructor_side_effect(ctx, v2578);
                        let v2580 = Some(v2579);
                        // Rule at src/isa/x64/lower.isle line 3585.
                        return v2580;
                    }
                }
                _ => {}
            }
        }
        &InstructionData::CondTrap {
            opcode: ref v1241,
            arg: v1242,
            code: ref v1243,
        } => {
            match v1241 {
                &Opcode::Trapz => {
                    let v1244 = &constructor_is_nonzero_cmp(ctx, v1242);
                    let v1245 = &constructor_cond_invert(ctx, v1244);
                    let v1246 = &constructor_trap_if_cond(ctx, v1245, v1243);
                    let v1247 = constructor_side_effect(ctx, v1246);
                    let v1248 = Some(v1247);
                    // Rule at src/isa/x64/lower.isle line 1917.
                    return v1248;
                }
                &Opcode::Trapnz => {
                    let v1244 = &constructor_is_nonzero_cmp(ctx, v1242);
                    let v1249 = &constructor_trap_if_cond(ctx, v1244, v1243);
                    let v1250 = constructor_side_effect(ctx, v1249);
                    let v1251 = Some(v1250);
                    // Rule at src/isa/x64/lower.isle line 1930.
                    return v1251;
                }
                _ => {}
            }
        }
        &InstructionData::ExceptionHandlerAddress {
            opcode: ref v3555,
            block: ref v3556,
            imm: v3557,
        } => {
            if let &Opcode::GetExceptionHandlerAddress = v3555 {
                let v3558 = C::u64_from_imm64(ctx, v3557);
                let v3559 = C::block_exn_successor_label(ctx, v3556, v3558);
                let v3560 = constructor_x64_label_address(ctx, v3559);
                let v3561 = constructor_output_gpr(ctx, v3560);
                let v3562 = Some(v3561);
                // Rule at src/isa/x64/lower.isle line 5186.
                return v3562;
            }
        }
        &InstructionData::FloatCompare {
            opcode: ref v1449,
            args: ref v1450,
            cond: ref v1451,
        } => {
            if let &Opcode::Fcmp = v1449 {
                match v1451 {
                    &FloatCC::Equal => {
                        let v1452 = C::unpack_value_array_2(ctx, v1450);
                        let v1455 = C::value_type(ctx, v1452.0);
                        let v1462 = C::ty_vec128(ctx, v1455);
                        if let Some(v1463) = v1462 {
                            let v1464 = constructor_put_in_xmm(ctx, v1452.0);
                            let v1465 = &C::put_in_xmm_mem_128(ctx, v1452.1);
                            let v1467 = constructor_x64_cmpp(ctx, v1463, v1464, v1465, &FcmpImm::Equal);
                            let v1468 = constructor_output_xmm(ctx, v1467);
                            let v1469 = Some(v1468);
                            // Rule at src/isa/x64/lower.isle line 2163.
                            return v1469;
                        }
                    }
                    &FloatCC::GreaterThan => {
                        let v1452 = C::unpack_value_array_2(ctx, v1450);
                        let v1455 = C::value_type(ctx, v1452.0);
                        let v1462 = C::ty_vec128(ctx, v1455);
                        if let Some(v1463) = v1462 {
                            let v1498 = constructor_put_in_xmm(ctx, v1452.1);
                            let v1499 = &C::put_in_xmm_mem_128(ctx, v1452.0);
                            let v1500 = constructor_x64_cmpp(ctx, v1463, v1498, v1499, &FcmpImm::LessThan);
                            let v1501 = constructor_output_xmm(ctx, v1500);
                            let v1502 = Some(v1501);
                            // Rule at src/isa/x64/lower.isle line 2183.
                            return v1502;
                        }
                    }
                    &FloatCC::GreaterThanOrEqual => {
                        let v1452 = C::unpack_value_array_2(ctx, v1450);
                        let v1455 = C::value_type(ctx, v1452.0);
                        let v1462 = C::ty_vec128(ctx, v1455);
                        if let Some(v1463) = v1462 {
                            let v1498 = constructor_put_in_xmm(ctx, v1452.1);
                            let v1499 = &C::put_in_xmm_mem_128(ctx, v1452.0);
                            let v1503 = constructor_x64_cmpp(ctx, v1463, v1498, v1499, &FcmpImm::LessThanOrEqual);
                            let v1504 = constructor_output_xmm(ctx, v1503);
                            let v1505 = Some(v1504);
                            // Rule at src/isa/x64/lower.isle line 2185.
                            return v1505;
                        }
                    }
                    &FloatCC::LessThan => {
                        let v1452 = C::unpack_value_array_2(ctx, v1450);
                        let v1455 = C::value_type(ctx, v1452.0);
                        let v1462 = C::ty_vec128(ctx, v1455);
                        if let Some(v1463) = v1462 {
                            let v1464 = constructor_put_in_xmm(ctx, v1452.0);
                            let v1465 = &C::put_in_xmm_mem_128(ctx, v1452.1);
                            let v1475 = constructor_x64_cmpp(ctx, v1463, v1464, v1465, &FcmpImm::LessThan);
                            let v1476 = constructor_output_xmm(ctx, v1475);
                            let v1477 = Some(v1476);
                            // Rule at src/isa/x64/lower.isle line 2167.
                            return v1477;
                        }
                    }
                    &FloatCC::LessThanOrEqual => {
                        let v1452 = C::unpack_value_array_2(ctx, v1450);
                        let v1455 = C::value_type(ctx, v1452.0);
                        let v1462 = C::ty_vec128(ctx, v1455);
                        if let Some(v1463) = v1462 {
                            let v1464 = constructor_put_in_xmm(ctx, v1452.0);
                            let v1465 = &C::put_in_xmm_mem_128(ctx, v1452.1);
                            let v1479 = constructor_x64_cmpp(ctx, v1463, v1464, v1465, &FcmpImm::LessThanOrEqual);
                            let v1480 = constructor_output_xmm(ctx, v1479);
                            let v1481 = Some(v1480);
                            // Rule at src/isa/x64/lower.isle line 2169.
                            return v1481;
                        }
                    }
                    &FloatCC::NotEqual => {
                        let v1452 = C::unpack_value_array_2(ctx, v1450);
                        let v1455 = C::value_type(ctx, v1452.0);
                        let v1462 = C::ty_vec128(ctx, v1455);
                        if let Some(v1463) = v1462 {
                            let v1464 = constructor_put_in_xmm(ctx, v1452.0);
                            let v1465 = &C::put_in_xmm_mem_128(ctx, v1452.1);
                            let v1471 = constructor_x64_cmpp(ctx, v1463, v1464, v1465, &FcmpImm::NotEqual);
                            let v1472 = constructor_output_xmm(ctx, v1471);
                            let v1473 = Some(v1472);
                            // Rule at src/isa/x64/lower.isle line 2165.
                            return v1473;
                        }
                    }
                    &FloatCC::Ordered => {
                        let v1452 = C::unpack_value_array_2(ctx, v1450);
                        let v1455 = C::value_type(ctx, v1452.0);
                        let v1462 = C::ty_vec128(ctx, v1455);
                        if let Some(v1463) = v1462 {
                            let v1464 = constructor_put_in_xmm(ctx, v1452.0);
                            let v1465 = &C::put_in_xmm_mem_128(ctx, v1452.1);
                            let v1483 = constructor_x64_cmpp(ctx, v1463, v1464, v1465, &FcmpImm::Ordered);
                            let v1484 = constructor_output_xmm(ctx, v1483);
                            let v1485 = Some(v1484);
                            // Rule at src/isa/x64/lower.isle line 2171.
                            return v1485;
                        }
                    }
                    &FloatCC::Unordered => {
                        let v1452 = C::unpack_value_array_2(ctx, v1450);
                        let v1455 = C::value_type(ctx, v1452.0);
                        let v1462 = C::ty_vec128(ctx, v1455);
                        if let Some(v1463) = v1462 {
                            let v1464 = constructor_put_in_xmm(ctx, v1452.0);
                            let v1465 = &C::put_in_xmm_mem_128(ctx, v1452.1);
                            let v1487 = constructor_x64_cmpp(ctx, v1463, v1464, v1465, &FcmpImm::Unordered);
                            let v1488 = constructor_output_xmm(ctx, v1487);
                            let v1489 = Some(v1488);
                            // Rule at src/isa/x64/lower.isle line 2173.
                            return v1489;
                        }
                    }
                    &FloatCC::UnorderedOrGreaterThan => {
                        let v1452 = C::unpack_value_array_2(ctx, v1450);
                        let v1455 = C::value_type(ctx, v1452.0);
                        let v1462 = C::ty_vec128(ctx, v1455);
                        if let Some(v1463) = v1462 {
                            let v1464 = constructor_put_in_xmm(ctx, v1452.0);
                            let v1465 = &C::put_in_xmm_mem_128(ctx, v1452.1);
                            let v1491 = constructor_x64_cmpp(ctx, v1463, v1464, v1465, &FcmpImm::UnorderedOrGreaterThan);
                            let v1492 = constructor_output_xmm(ctx, v1491);
                            let v1493 = Some(v1492);
                            // Rule at src/isa/x64/lower.isle line 2175.
                            return v1493;
                        }
                    }
                    &FloatCC::UnorderedOrGreaterThanOrEqual => {
                        let v1452 = C::unpack_value_array_2(ctx, v1450);
                        let v1455 = C::value_type(ctx, v1452.0);
                        let v1462 = C::ty_vec128(ctx, v1455);
                        if let Some(v1463) = v1462 {
                            let v1464 = constructor_put_in_xmm(ctx, v1452.0);
                            let v1465 = &C::put_in_xmm_mem_128(ctx, v1452.1);
                            let v1495 = constructor_x64_cmpp(ctx, v1463, v1464, v1465, &FcmpImm::UnorderedOrGreaterThanOrEqual);
                            let v1496 = constructor_output_xmm(ctx, v1495);
                            let v1497 = Some(v1496);
                            // Rule at src/isa/x64/lower.isle line 2177.
                            return v1497;
                        }
                    }
                    &FloatCC::UnorderedOrLessThan => {
                        let v1452 = C::unpack_value_array_2(ctx, v1450);
                        let v1455 = C::value_type(ctx, v1452.0);
                        let v1462 = C::ty_vec128(ctx, v1455);
                        if let Some(v1463) = v1462 {
                            let v1498 = constructor_put_in_xmm(ctx, v1452.1);
                            let v1499 = &C::put_in_xmm_mem_128(ctx, v1452.0);
                            let v1506 = constructor_x64_cmpp(ctx, v1463, v1498, v1499, &FcmpImm::UnorderedOrGreaterThan);
                            let v1507 = constructor_output_xmm(ctx, v1506);
                            let v1508 = Some(v1507);
                            // Rule at src/isa/x64/lower.isle line 2187.
                            return v1508;
                        }
                    }
                    &FloatCC::UnorderedOrLessThanOrEqual => {
                        let v1452 = C::unpack_value_array_2(ctx, v1450);
                        let v1455 = C::value_type(ctx, v1452.0);
                        let v1462 = C::ty_vec128(ctx, v1455);
                        if let Some(v1463) = v1462 {
                            let v1498 = constructor_put_in_xmm(ctx, v1452.1);
                            let v1499 = &C::put_in_xmm_mem_128(ctx, v1452.0);
                            let v1509 = constructor_x64_cmpp(ctx, v1463, v1498, v1499, &FcmpImm::UnorderedOrGreaterThanOrEqual);
                            let v1510 = constructor_output_xmm(ctx, v1509);
                            let v1511 = Some(v1510);
                            // Rule at src/isa/x64/lower.isle line 2189.
                            return v1511;
                        }
                    }
                    _ => {}
                }
                let v1452 = C::unpack_value_array_2(ctx, v1450);
                let v1455 = C::value_type(ctx, v1452.0);
                let v1456 = C::ty_scalar_float(ctx, v1455);
                if let Some(v1457) = v1456 {
                    let v1458 = &constructor_emit_fcmp(ctx, v1451, v1452.0, v1452.1);
                    let v1459 = constructor_lower_cond_bool(ctx, v1458);
                    let v1460 = constructor_output_gpr(ctx, v1459);
                    let v1461 = Some(v1460);
                    // Rule at src/isa/x64/lower.isle line 2156.
                    return v1461;
                }
            }
        }
        &InstructionData::FuncAddr {
            opcode: ref v2364,
            func_ref: v2365,
        } => {
            if let &Opcode::FuncAddr = v2364 {
                let v2366 = C::func_ref_data(ctx, v2365);
                let v2372 = constructor_load_ext_name(ctx, v2366.1, 0_i64, &v2366.2);
                let v2373 = constructor_output_gpr(ctx, v2372);
                let v2374 = Some(v2373);
                // Rule at src/isa/x64/lower.isle line 3431.
                return v2374;
            }
        }
        &InstructionData::IntAddTrap {
            opcode: ref v1252,
            args: ref v1253,
            code: ref v1254,
        } => {
            if let &Opcode::UaddOverflowTrap = v1252 {
                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 v1255 = C::unpack_value_array_2(ctx, v1253);
                        let v1273 = &C::sinkable_load(ctx, v1255.0);
                        if let Some(v1274) = v1273 {
                            let v1267 = constructor_put_in_gpr(ctx, v1255.1);
                            let v1275 = &constructor_sink_load_to_gpr_mem_imm(ctx, v1274);
                            let v1276 = &constructor_x64_add_with_flags_paired(ctx, v5, v1267, v1275);
                            let v1261 = &constructor_trap_if(ctx, &CC::B, v1254);
                            let v1277 = constructor_with_flags(ctx, v1276, v1261);
                            let v1278 = C::output(ctx, v1277);
                            let v1279 = Some(v1278);
                            // Rule at src/isa/x64/lower.isle line 1949.
                            return v1279;
                        }
                        let v1265 = &C::simm32_from_value(ctx, v1255.0);
                        if let Some(v1266) = v1265 {
                            let v1267 = constructor_put_in_gpr(ctx, v1255.1);
                            let v1268 = &constructor_x64_add_with_flags_paired(ctx, v5, v1267, v1266);
                            let v1269 = &constructor_trap_if(ctx, &CC::B, v1254);
                            let v1270 = constructor_with_flags(ctx, v1268, v1269);
                            let v1271 = C::output(ctx, v1270);
                            let v1272 = Some(v1271);
                            // Rule at src/isa/x64/lower.isle line 1943.
                            return v1272;
                        }
                        let v1258 = constructor_put_in_gpr(ctx, v1255.0);
                        let v1259 = &constructor_put_in_gpr_mem_imm(ctx, v1255.1);
                        let v1260 = &constructor_x64_add_with_flags_paired(ctx, v5, v1258, v1259);
                        let v1261 = &constructor_trap_if(ctx, &CC::B, v1254);
                        let v1262 = constructor_with_flags(ctx, v1260, v1261);
                        let v1263 = C::output(ctx, v1262);
                        let v1264 = Some(v1263);
                        // Rule at src/isa/x64/lower.isle line 1935.
                        return v1264;
                    }
                }
            }
        }
        &InstructionData::IntCompare {
            opcode: ref v1285,
            args: ref v1286,
            cond: ref v1287,
        } => {
            if let &Opcode::Icmp = v1285 {
                match v1287 {
                    &IntCC::Equal => {
                        let v1288 = C::unpack_value_array_2(ctx, v1286);
                        let v1291 = C::value_type(ctx, v1288.0);
                        let v1348 = C::ty_vec128(ctx, v1291);
                        if let Some(v1349) = v1348 {
                            let v1350 = constructor_put_in_xmm(ctx, v1288.0);
                            let v1351 = &C::put_in_xmm_mem_128(ctx, v1288.1);
                            let v1352 = constructor_x64_pcmpeq(ctx, v1349, v1350, v1351);
                            let v1353 = constructor_output_xmm(ctx, v1352);
                            let v1354 = Some(v1353);
                            // Rule at src/isa/x64/lower.isle line 2006.
                            return v1354;
                        }
                    }
                    &IntCC::NotEqual => {
                        let v1288 = C::unpack_value_array_2(ctx, v1286);
                        let v1291 = C::value_type(ctx, v1288.0);
                        let v1348 = C::ty_vec128(ctx, v1291);
                        if let Some(v1349) = v1348 {
                            let v1350 = constructor_put_in_xmm(ctx, v1288.0);
                            let v1351 = &C::put_in_xmm_mem_128(ctx, v1288.1);
                            let v1352 = constructor_x64_pcmpeq(ctx, v1349, v1350, v1351);
                            let v1355 = constructor_vector_all_ones(ctx);
                            let v1356 = &C::xmm_to_xmm_mem_128(ctx, v1355);
                            let v1357 = constructor_x64_pxor(ctx, v1352, v1356);
                            let v1358 = constructor_output_xmm(ctx, v1357);
                            let v1359 = Some(v1358);
                            // Rule at src/isa/x64/lower.isle line 2011.
                            return v1359;
                        }
                    }
                    &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 v1288 = C::unpack_value_array_2(ctx, v1286);
                                let v1311 = C::def_inst(ctx, v1288.0);
                                if let Some(v1312) = v1311 {
                                    let v1313 = C::inst_data_value(ctx, v1312);
                                    if let &InstructionData::UnaryImm {
                                        opcode: ref v1316,
                                        imm: v1317,
                                    } = &v1313.1 {
                                        if let &Opcode::Iconst = v1316 {
                                            let v1318 = C::u64_from_imm64(ctx, v1317);
                                            if v1318 == 0x0_u64 {
                                                let v1319 = C::value_type(ctx, v1288.1);
                                                match v1319 {
                                                    I32 => {
                                                        let v1320 = constructor_put_in_gpr(ctx, v1288.1);
                                                        let v1336 = constructor_x64_shrl_mi(ctx, v1320, 0x1f_u8);
                                                        let v1337 = constructor_output_gpr(ctx, v1336);
                                                        let v1338 = Some(v1337);
                                                        // Rule at src/isa/x64/lower.isle line 1990.
                                                        return v1338;
                                                    }
                                                    I64 => {
                                                        let v1320 = constructor_put_in_gpr(ctx, v1288.1);
                                                        let v1321 = constructor_x64_shrq_mi(ctx, v1320, 0x3f_u8);
                                                        let v1322 = constructor_output_gpr(ctx, v1321);
                                                        let v1323 = Some(v1322);
                                                        // Rule at src/isa/x64/lower.isle line 1974.
                                                        return v1323;
                                                    }
                                                    _ => {}
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                        let v1288 = C::unpack_value_array_2(ctx, v1286);
                        let v1291 = C::value_type(ctx, v1288.0);
                        let v1348 = C::ty_vec128(ctx, v1291);
                        if let Some(v1349) = v1348 {
                            let v1350 = constructor_put_in_xmm(ctx, v1288.0);
                            let v1351 = &C::put_in_xmm_mem_128(ctx, v1288.1);
                            let v1360 = constructor_x64_pcmpgt(ctx, v1349, v1350, v1351);
                            let v1361 = constructor_output_xmm(ctx, v1360);
                            let v1362 = Some(v1361);
                            // Rule at src/isa/x64/lower.isle line 2018.
                            return v1362;
                        }
                    }
                    &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 v1288 = C::unpack_value_array_2(ctx, v1286);
                                let v1291 = C::value_type(ctx, v1288.0);
                                match v1291 {
                                    I32 => {
                                        let v1298 = C::def_inst(ctx, v1288.1);
                                        if let Some(v1299) = v1298 {
                                            let v1300 = C::inst_data_value(ctx, v1299);
                                            if let &InstructionData::UnaryImm {
                                                opcode: ref v1303,
                                                imm: v1304,
                                            } = &v1300.1 {
                                                if let &Opcode::Iconst = v1303 {
                                                    let v1305 = C::u64_from_imm64(ctx, v1304);
                                                    if v1305 == 0x0_u64 {
                                                        let v1306 = constructor_put_in_gpr(ctx, v1288.0);
                                                        let v1344 = constructor_x64_not(ctx, I32, v1306);
                                                        let v1345 = constructor_x64_shrl_mi(ctx, v1344, 0x1f_u8);
                                                        let v1346 = constructor_output_gpr(ctx, v1345);
                                                        let v1347 = Some(v1346);
                                                        // Rule at src/isa/x64/lower.isle line 1998.
                                                        return v1347;
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    I64 => {
                                        let v1298 = C::def_inst(ctx, v1288.1);
                                        if let Some(v1299) = v1298 {
                                            let v1300 = C::inst_data_value(ctx, v1299);
                                            if let &InstructionData::UnaryImm {
                                                opcode: ref v1303,
                                                imm: v1304,
                                            } = &v1300.1 {
                                                if let &Opcode::Iconst = v1303 {
                                                    let v1305 = C::u64_from_imm64(ctx, v1304);
                                                    if v1305 == 0x0_u64 {
                                                        let v1306 = constructor_put_in_gpr(ctx, v1288.0);
                                                        let v1328 = constructor_x64_not(ctx, I64, v1306);
                                                        let v1329 = constructor_x64_shrq_mi(ctx, v1328, 0x3f_u8);
                                                        let v1330 = constructor_output_gpr(ctx, v1329);
                                                        let v1331 = Some(v1330);
                                                        // Rule at src/isa/x64/lower.isle line 1982.
                                                        return v1331;
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    _ => {}
                                }
                            }
                        }
                        let v1288 = C::unpack_value_array_2(ctx, v1286);
                        let v1291 = C::value_type(ctx, v1288.0);
                        let v1348 = C::ty_vec128(ctx, v1291);
                        if let Some(v1349) = v1348 {
                            let v1400 = constructor_has_pmaxs(ctx, v1349);
                            if v1400 == true {
                                let v1350 = constructor_put_in_xmm(ctx, v1288.0);
                                let v1380 = constructor_put_in_xmm(ctx, v1288.0);
                                let v1401 = &C::put_in_xmm_mem_128(ctx, v1288.1);
                                let v1402 = constructor_x64_pmaxs(ctx, v1349, v1380, v1401);
                                let v1403 = &C::xmm_to_xmm_mem_128(ctx, v1402);
                                let v1404 = constructor_x64_pcmpeq(ctx, v1349, v1350, v1403);
                                let v1405 = constructor_output_xmm(ctx, v1404);
                                let v1406 = Some(v1405);
                                // Rule at src/isa/x64/lower.isle line 2068.
                                return v1406;
                            }
                            let v1363 = constructor_put_in_xmm(ctx, v1288.1);
                            let v1364 = &C::put_in_xmm_mem_128(ctx, v1288.0);
                            let v1365 = constructor_x64_pcmpgt(ctx, v1349, v1363, v1364);
                            let v1355 = constructor_vector_all_ones(ctx);
                            let v1356 = &C::xmm_to_xmm_mem_128(ctx, v1355);
                            let v1407 = constructor_x64_pxor(ctx, v1365, v1356);
                            let v1408 = constructor_output_xmm(ctx, v1407);
                            let v1409 = Some(v1408);
                            // Rule at src/isa/x64/lower.isle line 2074.
                            return v1409;
                        }
                    }
                    &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 v1288 = C::unpack_value_array_2(ctx, v1286);
                                let v1291 = C::value_type(ctx, v1288.0);
                                match v1291 {
                                    I32 => {
                                        let v1298 = C::def_inst(ctx, v1288.1);
                                        if let Some(v1299) = v1298 {
                                            let v1300 = C::inst_data_value(ctx, v1299);
                                            if let &InstructionData::UnaryImm {
                                                opcode: ref v1303,
                                                imm: v1304,
                                            } = &v1300.1 {
                                                if let &Opcode::Iconst = v1303 {
                                                    let v1305 = C::u64_from_imm64(ctx, v1304);
                                                    if v1305 == 0x0_u64 {
                                                        let v1306 = constructor_put_in_gpr(ctx, v1288.0);
                                                        let v1333 = constructor_x64_shrl_mi(ctx, v1306, 0x1f_u8);
                                                        let v1334 = constructor_output_gpr(ctx, v1333);
                                                        let v1335 = Some(v1334);
                                                        // Rule at src/isa/x64/lower.isle line 1986.
                                                        return v1335;
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    I64 => {
                                        let v1298 = C::def_inst(ctx, v1288.1);
                                        if let Some(v1299) = v1298 {
                                            let v1300 = C::inst_data_value(ctx, v1299);
                                            if let &InstructionData::UnaryImm {
                                                opcode: ref v1303,
                                                imm: v1304,
                                            } = &v1300.1 {
                                                if let &Opcode::Iconst = v1303 {
                                                    let v1305 = C::u64_from_imm64(ctx, v1304);
                                                    if v1305 == 0x0_u64 {
                                                        let v1306 = constructor_put_in_gpr(ctx, v1288.0);
                                                        let v1308 = constructor_x64_shrq_mi(ctx, v1306, 0x3f_u8);
                                                        let v1309 = constructor_output_gpr(ctx, v1308);
                                                        let v1310 = Some(v1309);
                                                        // Rule at src/isa/x64/lower.isle line 1970.
                                                        return v1310;
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    _ => {}
                                }
                            }
                        }
                        let v1288 = C::unpack_value_array_2(ctx, v1286);
                        let v1291 = C::value_type(ctx, v1288.0);
                        let v1348 = C::ty_vec128(ctx, v1291);
                        if let Some(v1349) = v1348 {
                            let v1363 = constructor_put_in_xmm(ctx, v1288.1);
                            let v1364 = &C::put_in_xmm_mem_128(ctx, v1288.0);
                            let v1365 = constructor_x64_pcmpgt(ctx, v1349, v1363, v1364);
                            let v1366 = constructor_output_xmm(ctx, v1365);
                            let v1367 = Some(v1366);
                            // Rule at src/isa/x64/lower.isle line 2023.
                            return v1367;
                        }
                    }
                    &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 v1288 = C::unpack_value_array_2(ctx, v1286);
                                let v1311 = C::def_inst(ctx, v1288.0);
                                if let Some(v1312) = v1311 {
                                    let v1313 = C::inst_data_value(ctx, v1312);
                                    if let &InstructionData::UnaryImm {
                                        opcode: ref v1316,
                                        imm: v1317,
                                    } = &v1313.1 {
                                        if let &Opcode::Iconst = v1316 {
                                            let v1318 = C::u64_from_imm64(ctx, v1317);
                                            if v1318 == 0x0_u64 {
                                                let v1319 = C::value_type(ctx, v1288.1);
                                                match v1319 {
                                                    I32 => {
                                                        let v1320 = constructor_put_in_gpr(ctx, v1288.1);
                                                        let v1340 = constructor_x64_not(ctx, I32, v1320);
                                                        let v1341 = constructor_x64_shrl_mi(ctx, v1340, 0x1f_u8);
                                                        let v1342 = constructor_output_gpr(ctx, v1341);
                                                        let v1343 = Some(v1342);
                                                        // Rule at src/isa/x64/lower.isle line 1994.
                                                        return v1343;
                                                    }
                                                    I64 => {
                                                        let v1320 = constructor_put_in_gpr(ctx, v1288.1);
                                                        let v1324 = constructor_x64_not(ctx, I64, v1320);
                                                        let v1325 = constructor_x64_shrq_mi(ctx, v1324, 0x3f_u8);
                                                        let v1326 = constructor_output_gpr(ctx, v1325);
                                                        let v1327 = Some(v1326);
                                                        // Rule at src/isa/x64/lower.isle line 1978.
                                                        return v1327;
                                                    }
                                                    _ => {}
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                        let v1288 = C::unpack_value_array_2(ctx, v1286);
                        let v1291 = C::value_type(ctx, v1288.0);
                        let v1348 = C::ty_vec128(ctx, v1291);
                        if let Some(v1349) = v1348 {
                            let v1410 = constructor_has_pmins(ctx, v1349);
                            if v1410 == true {
                                let v1350 = constructor_put_in_xmm(ctx, v1288.0);
                                let v1380 = constructor_put_in_xmm(ctx, v1288.0);
                                let v1401 = &C::put_in_xmm_mem_128(ctx, v1288.1);
                                let v1411 = constructor_x64_pmins(ctx, v1349, v1380, v1401);
                                let v1412 = &C::xmm_to_xmm_mem_128(ctx, v1411);
                                let v1413 = constructor_x64_pcmpeq(ctx, v1349, v1350, v1412);
                                let v1414 = constructor_output_xmm(ctx, v1413);
                                let v1415 = Some(v1414);
                                // Rule at src/isa/x64/lower.isle line 2080.
                                return v1415;
                            }
                            let v1350 = constructor_put_in_xmm(ctx, v1288.0);
                            let v1351 = &C::put_in_xmm_mem_128(ctx, v1288.1);
                            let v1360 = constructor_x64_pcmpgt(ctx, v1349, v1350, v1351);
                            let v1355 = constructor_vector_all_ones(ctx);
                            let v1356 = &C::xmm_to_xmm_mem_128(ctx, v1355);
                            let v1416 = constructor_x64_pxor(ctx, v1360, v1356);
                            let v1417 = constructor_output_xmm(ctx, v1416);
                            let v1418 = Some(v1417);
                            // Rule at src/isa/x64/lower.isle line 2085.
                            return v1418;
                        }
                    }
                    &IntCC::UnsignedGreaterThan => {
                        let v1288 = C::unpack_value_array_2(ctx, v1286);
                        let v1291 = C::value_type(ctx, v1288.0);
                        let v1348 = C::ty_vec128(ctx, v1291);
                        if let Some(v1349) = v1348 {
                            let v1368 = constructor_has_pmaxu(ctx, v1349);
                            if v1368 == true {
                                let v1350 = constructor_put_in_xmm(ctx, v1288.0);
                                let v1369 = constructor_put_in_xmm(ctx, v1288.1);
                                let v1370 = &C::xmm_to_xmm_mem_128(ctx, v1369);
                                let v1371 = constructor_x64_pmaxu(ctx, v1349, v1350, v1370);
                                let v1372 = &C::xmm_to_xmm_mem_128(ctx, v1369);
                                let v1373 = constructor_x64_pcmpeq(ctx, v1349, v1371, v1372);
                                let v1374 = constructor_vector_all_ones(ctx);
                                let v1375 = &C::xmm_to_xmm_mem_128(ctx, v1374);
                                let v1376 = constructor_x64_pxor(ctx, v1373, v1375);
                                let v1377 = constructor_output_xmm(ctx, v1376);
                                let v1378 = Some(v1377);
                                // Rule at src/isa/x64/lower.isle line 2030.
                                return v1378;
                            }
                            let v1379 = constructor_flip_high_bit_mask(ctx, v1349);
                            let v1380 = constructor_put_in_xmm(ctx, v1288.0);
                            let v1381 = &C::xmm_to_xmm_mem_128(ctx, v1379);
                            let v1382 = constructor_x64_pxor(ctx, v1380, v1381);
                            let v1383 = constructor_put_in_xmm(ctx, v1288.1);
                            let v1384 = &C::xmm_to_xmm_mem_128(ctx, v1379);
                            let v1385 = constructor_x64_pxor(ctx, v1383, v1384);
                            let v1386 = &C::xmm_to_xmm_mem_128(ctx, v1385);
                            let v1387 = constructor_x64_pcmpgt(ctx, v1349, v1382, v1386);
                            let v1388 = constructor_output_xmm(ctx, v1387);
                            let v1389 = Some(v1388);
                            // Rule at src/isa/x64/lower.isle line 2040.
                            return v1389;
                        }
                    }
                    &IntCC::UnsignedGreaterThanOrEqual => {
                        let v1288 = C::unpack_value_array_2(ctx, v1286);
                        let v1291 = C::value_type(ctx, v1288.0);
                        let v1348 = C::ty_vec128(ctx, v1291);
                        if let Some(v1349) = v1348 {
                            let v1368 = constructor_has_pmaxu(ctx, v1349);
                            if v1368 == true {
                                let v1350 = constructor_put_in_xmm(ctx, v1288.0);
                                let v1380 = constructor_put_in_xmm(ctx, v1288.0);
                                let v1401 = &C::put_in_xmm_mem_128(ctx, v1288.1);
                                let v1419 = constructor_x64_pmaxu(ctx, v1349, v1380, v1401);
                                let v1420 = &C::xmm_to_xmm_mem_128(ctx, v1419);
                                let v1421 = constructor_x64_pcmpeq(ctx, v1349, v1350, v1420);
                                let v1422 = constructor_output_xmm(ctx, v1421);
                                let v1423 = Some(v1422);
                                // Rule at src/isa/x64/lower.isle line 2090.
                                return v1423;
                            }
                        }
                        if v1291 == I16X8 {
                            let v1363 = constructor_put_in_xmm(ctx, v1288.1);
                            let v1364 = &C::put_in_xmm_mem_128(ctx, v1288.0);
                            let v1424 = constructor_x64_psubusw(ctx, v1363, v1364);
                            let v1425 = constructor_xmm_zero(ctx, I16X8);
                            let v1426 = &C::xmm_to_xmm_mem_128(ctx, v1425);
                            let v1427 = constructor_x64_pcmpeqw(ctx, v1424, v1426);
                            let v1428 = constructor_output_xmm(ctx, v1427);
                            let v1429 = Some(v1428);
                            // Rule at src/isa/x64/lower.isle line 2096.
                            return v1429;
                        }
                        if let Some(v1349) = v1348 {
                            let v1379 = constructor_flip_high_bit_mask(ctx, v1349);
                            let v1380 = constructor_put_in_xmm(ctx, v1288.0);
                            let v1381 = &C::xmm_to_xmm_mem_128(ctx, v1379);
                            let v1382 = constructor_x64_pxor(ctx, v1380, v1381);
                            let v1383 = constructor_put_in_xmm(ctx, v1288.1);
                            let v1384 = &C::xmm_to_xmm_mem_128(ctx, v1379);
                            let v1385 = constructor_x64_pxor(ctx, v1383, v1384);
                            let v1396 = &C::xmm_to_xmm_mem_128(ctx, v1382);
                            let v1397 = constructor_x64_pcmpgt(ctx, v1349, v1385, v1396);
                            let v1430 = constructor_vector_all_ones(ctx);
                            let v1431 = &C::xmm_to_xmm_mem_128(ctx, v1430);
                            let v1432 = constructor_x64_pxor(ctx, v1397, v1431);
                            let v1433 = constructor_output_xmm(ctx, v1432);
                            let v1434 = Some(v1433);
                            // Rule at src/isa/x64/lower.isle line 2102.
                            return v1434;
                        }
                    }
                    &IntCC::UnsignedLessThan => {
                        let v1288 = C::unpack_value_array_2(ctx, v1286);
                        let v1291 = C::value_type(ctx, v1288.0);
                        let v1348 = C::ty_vec128(ctx, v1291);
                        if let Some(v1349) = v1348 {
                            let v1390 = constructor_has_pminu(ctx, v1349);
                            if v1390 == true {
                                let v1350 = constructor_put_in_xmm(ctx, v1288.0);
                                let v1369 = constructor_put_in_xmm(ctx, v1288.1);
                                let v1370 = &C::xmm_to_xmm_mem_128(ctx, v1369);
                                let v1391 = constructor_x64_pminu(ctx, v1349, v1350, v1370);
                                let v1372 = &C::xmm_to_xmm_mem_128(ctx, v1369);
                                let v1392 = constructor_x64_pcmpeq(ctx, v1349, v1391, v1372);
                                let v1374 = constructor_vector_all_ones(ctx);
                                let v1375 = &C::xmm_to_xmm_mem_128(ctx, v1374);
                                let v1393 = constructor_x64_pxor(ctx, v1392, v1375);
                                let v1394 = constructor_output_xmm(ctx, v1393);
                                let v1395 = Some(v1394);
                                // Rule at src/isa/x64/lower.isle line 2048.
                                return v1395;
                            }
                            let v1379 = constructor_flip_high_bit_mask(ctx, v1349);
                            let v1380 = constructor_put_in_xmm(ctx, v1288.0);
                            let v1381 = &C::xmm_to_xmm_mem_128(ctx, v1379);
                            let v1382 = constructor_x64_pxor(ctx, v1380, v1381);
                            let v1383 = constructor_put_in_xmm(ctx, v1288.1);
                            let v1384 = &C::xmm_to_xmm_mem_128(ctx, v1379);
                            let v1385 = constructor_x64_pxor(ctx, v1383, v1384);
                            let v1396 = &C::xmm_to_xmm_mem_128(ctx, v1382);
                            let v1397 = constructor_x64_pcmpgt(ctx, v1349, v1385, v1396);
                            let v1398 = constructor_output_xmm(ctx, v1397);
                            let v1399 = Some(v1398);
                            // Rule at src/isa/x64/lower.isle line 2059.
                            return v1399;
                        }
                    }
                    &IntCC::UnsignedLessThanOrEqual => {
                        let v1288 = C::unpack_value_array_2(ctx, v1286);
                        let v1291 = C::value_type(ctx, v1288.0);
                        let v1348 = C::ty_vec128(ctx, v1291);
                        if let Some(v1349) = v1348 {
                            let v1390 = constructor_has_pminu(ctx, v1349);
                            if v1390 == true {
                                let v1350 = constructor_put_in_xmm(ctx, v1288.0);
                                let v1380 = constructor_put_in_xmm(ctx, v1288.0);
                                let v1401 = &C::put_in_xmm_mem_128(ctx, v1288.1);
                                let v1435 = constructor_x64_pminu(ctx, v1349, v1380, v1401);
                                let v1436 = &C::xmm_to_xmm_mem_128(ctx, v1435);
                                let v1437 = constructor_x64_pcmpeq(ctx, v1349, v1350, v1436);
                                let v1438 = constructor_output_xmm(ctx, v1437);
                                let v1439 = Some(v1438);
                                // Rule at src/isa/x64/lower.isle line 2113.
                                return v1439;
                            }
                        }
                        if v1291 == I16X8 {
                            let v1350 = constructor_put_in_xmm(ctx, v1288.0);
                            let v1351 = &C::put_in_xmm_mem_128(ctx, v1288.1);
                            let v1440 = constructor_x64_psubusw(ctx, v1350, v1351);
                            let v1441 = constructor_xmm_zero(ctx, I8X16);
                            let v1442 = &C::xmm_to_xmm_mem_128(ctx, v1441);
                            let v1443 = constructor_x64_pcmpeqw(ctx, v1440, v1442);
                            let v1444 = constructor_output_xmm(ctx, v1443);
                            let v1445 = Some(v1444);
                            // Rule at src/isa/x64/lower.isle line 2120.
                            return v1445;
                        }
                        if let Some(v1349) = v1348 {
                            let v1379 = constructor_flip_high_bit_mask(ctx, v1349);
                            let v1380 = constructor_put_in_xmm(ctx, v1288.0);
                            let v1381 = &C::xmm_to_xmm_mem_128(ctx, v1379);
                            let v1382 = constructor_x64_pxor(ctx, v1380, v1381);
                            let v1383 = constructor_put_in_xmm(ctx, v1288.1);
                            let v1384 = &C::xmm_to_xmm_mem_128(ctx, v1379);
                            let v1385 = constructor_x64_pxor(ctx, v1383, v1384);
                            let v1386 = &C::xmm_to_xmm_mem_128(ctx, v1385);
                            let v1387 = constructor_x64_pcmpgt(ctx, v1349, v1382, v1386);
                            let v1430 = constructor_vector_all_ones(ctx);
                            let v1431 = &C::xmm_to_xmm_mem_128(ctx, v1430);
                            let v1446 = constructor_x64_pxor(ctx, v1387, v1431);
                            let v1447 = constructor_output_xmm(ctx, v1446);
                            let v1448 = Some(v1447);
                            // Rule at src/isa/x64/lower.isle line 2128.
                            return v1448;
                        }
                    }
                    _ => {}
                }
                let v1288 = C::unpack_value_array_2(ctx, v1286);
                let v1291 = C::value_type(ctx, v1288.0);
                if v1291 == I128 {
                    let v1294 = &constructor_emit_cmp(ctx, v1287, v1288.0, v1288.1);
                    let v1295 = constructor_lower_cond_bool(ctx, v1294);
                    let v1296 = constructor_output_gpr(ctx, v1295);
                    let v1297 = Some(v1296);
                    // Rule at src/isa/x64/lower.isle line 1966.
                    return v1297;
                }
                let v1292 = C::fits_in_64(ctx, v1291);
                if let Some(v1293) = v1292 {
                    let v1294 = &constructor_emit_cmp(ctx, v1287, v1288.0, v1288.1);
                    let v1295 = constructor_lower_cond_bool(ctx, v1294);
                    let v1296 = constructor_output_gpr(ctx, v1295);
                    let v1297 = Some(v1296);
                    // Rule at src/isa/x64/lower.isle line 1963.
                    return v1297;
                }
            }
        }
        &InstructionData::Load {
            opcode: ref v2070,
            arg: v2071,
            flags: v2072,
            offset: v2073,
        } => {
            match v2070 {
                &Opcode::Load => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v2074 = C::little_or_native_endian(ctx, v2072);
                        if let Some(v2075) = v2074 {
                            let v3 = C::value_type(ctx, v2);
                            let v2067 = &C::type_register_class(ctx, v3);
                            if let Some(v2068) = v2067 {
                                if let &RegisterClass::Xmm = v2068 {
                                    let v2111 = C::ty_16(ctx, v3);
                                    if let Some(v2112) = v2111 {
                                        let v2113 = constructor_xmm_uninit_value(ctx);
                                        let v2079 = &constructor_to_amode(ctx, v2075, v2071, v2073);
                                        let v2080 = &constructor_synthetic_amode_to_gpr_mem(ctx, v2079);
                                        let v2115 = constructor_x64_pinsrw(ctx, v2113, v2080, 0x0_u8);
                                        let v2116 = constructor_output_xmm(ctx, v2115);
                                        let v2117 = Some(v2116);
                                        // Rule at src/isa/x64/lower.isle line 3096.
                                        return v2117;
                                    }
                                    let v2118 = C::ty_32(ctx, v3);
                                    if let Some(v2119) = v2118 {
                                        let v2086 = &constructor_to_amode(ctx, v2075, v2071, v2073);
                                        let v2120 = constructor_x64_movss_load(ctx, v2086);
                                        let v2121 = constructor_output_xmm(ctx, v2120);
                                        let v2122 = Some(v2121);
                                        // Rule at src/isa/x64/lower.isle line 3098.
                                        return v2122;
                                    }
                                    let v2123 = C::ty_64(ctx, v3);
                                    if let Some(v2124) = v2123 {
                                        let v2086 = &constructor_to_amode(ctx, v2075, v2071, v2073);
                                        let v2125 = constructor_x64_movsd_load(ctx, v2086);
                                        let v2126 = constructor_output_xmm(ctx, v2125);
                                        let v2127 = Some(v2126);
                                        // Rule at src/isa/x64/lower.isle line 3100.
                                        return v2127;
                                    }
                                }
                            }
                            match v3 {
                                F32X4 => {
                                    let v2086 = &constructor_to_amode(ctx, v2075, v2071, v2073);
                                    let v2128 = constructor_x64_movups_load(ctx, v2086);
                                    let v2129 = constructor_output_xmm(ctx, v2128);
                                    let v2130 = Some(v2129);
                                    // Rule at src/isa/x64/lower.isle line 3102.
                                    return v2130;
                                }
                                F64X2 => {
                                    let v2086 = &constructor_to_amode(ctx, v2075, v2071, v2073);
                                    let v2131 = constructor_x64_movupd_load(ctx, v2086);
                                    let v2132 = constructor_output_xmm(ctx, v2131);
                                    let v2133 = Some(v2132);
                                    // Rule at src/isa/x64/lower.isle line 3104.
                                    return v2133;
                                }
                                _ => {}
                            }
                            if let Some(v2068) = v2067 {
                                if let &RegisterClass::Xmm = v2068 {
                                    let v2134 = C::ty_128(ctx, v3);
                                    if let Some(v2135) = v2134 {
                                        let v2086 = &constructor_to_amode(ctx, v2075, v2071, v2073);
                                        let v2136 = &C::synthetic_amode_to_xmm_mem_128(ctx, v2086);
                                        let v2137 = constructor_x64_movdqu_load(ctx, v2136);
                                        let v2138 = constructor_output_xmm(ctx, v2137);
                                        let v2139 = Some(v2138);
                                        // Rule at src/isa/x64/lower.isle line 3106.
                                        return v2139;
                                    }
                                }
                            }
                            let v2084 = C::ty_int_ref_64(ctx, v3);
                            if let Some(v2085) = v2084 {
                                let v2086 = &constructor_to_amode(ctx, v2075, v2071, v2073);
                                let v2087 = constructor_x64_mov(ctx, v2086);
                                let v2088 = constructor_output_reg(ctx, v2087);
                                let v2089 = Some(v2088);
                                // Rule at src/isa/x64/lower.isle line 3074.
                                return v2089;
                            }
                            if v3 == I128 {
                                let v2086 = &constructor_to_amode(ctx, v2075, v2071, v2073);
                                let v2141 = &constructor_amode_offset(ctx, v2086, v2075, 8_i32);
                                let v2142 = constructor_x64_mov(ctx, v2086);
                                let v2143 = constructor_x64_mov(ctx, v2141);
                                let v2144 = C::value_regs(ctx, v2142, v2143);
                                let v2145 = C::output(ctx, v2144);
                                let v2146 = Some(v2145);
                                // Rule at src/isa/x64/lower.isle line 3110.
                                return v2146;
                            }
                            if let Some(v2068) = v2067 {
                                if let &RegisterClass::Gpr {
                                    single_register: v2069,
                                } = v2068 {
                                    let v1769 = C::fits_in_32(ctx, v3);
                                    if let Some(v1770) = v1769 {
                                        let v2076 = C::ty_bits_u16(ctx, v1770);
                                        let v2078 = &C::ext_mode(ctx, v2076, 0x40_u16);
                                        let v2079 = &constructor_to_amode(ctx, v2075, v2071, v2073);
                                        let v2080 = &constructor_synthetic_amode_to_gpr_mem(ctx, v2079);
                                        let v2081 = constructor_x64_movzx(ctx, v2078, v2080);
                                        let v2082 = constructor_output_gpr(ctx, v2081);
                                        let v2083 = Some(v2082);
                                        // Rule at src/isa/x64/lower.isle line 3069.
                                        return v2083;
                                    }
                                }
                            }
                        }
                    }
                }
                &Opcode::Uload8 => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        let v2067 = &C::type_register_class(ctx, v3);
                        if let Some(v2068) = v2067 {
                            if let &RegisterClass::Gpr {
                                single_register: v2069,
                            } = v2068 {
                                let v2074 = C::little_or_native_endian(ctx, v2072);
                                if let Some(v2075) = v2074 {
                                    let v2086 = &constructor_to_amode(ctx, v2075, v2071, v2073);
                                    let v2090 = &constructor_synthetic_amode_to_gpr_mem(ctx, v2086);
                                    let v2091 = constructor_x64_movzx(ctx, &ExtMode::BQ, v2090);
                                    let v2092 = constructor_output_gpr(ctx, v2091);
                                    let v2093 = Some(v2092);
                                    // Rule at src/isa/x64/lower.isle line 3079.
                                    return v2093;
                                }
                            }
                        }
                    }
                }
                &Opcode::Sload8 => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        let v2067 = &C::type_register_class(ctx, v3);
                        if let Some(v2068) = v2067 {
                            if let &RegisterClass::Gpr {
                                single_register: v2069,
                            } = v2068 {
                                let v2074 = C::little_or_native_endian(ctx, v2072);
                                if let Some(v2075) = v2074 {
                                    let v2086 = &constructor_to_amode(ctx, v2075, v2071, v2073);
                                    let v2090 = &constructor_synthetic_amode_to_gpr_mem(ctx, v2086);
                                    let v2094 = constructor_x64_movsx(ctx, &ExtMode::BQ, v2090);
                                    let v2095 = constructor_output_gpr(ctx, v2094);
                                    let v2096 = Some(v2095);
                                    // Rule at src/isa/x64/lower.isle line 3081.
                                    return v2096;
                                }
                            }
                        }
                    }
                }
                &Opcode::Uload16 => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        let v2067 = &C::type_register_class(ctx, v3);
                        if let Some(v2068) = v2067 {
                            if let &RegisterClass::Gpr {
                                single_register: v2069,
                            } = v2068 {
                                let v2074 = C::little_or_native_endian(ctx, v2072);
                                if let Some(v2075) = v2074 {
                                    let v2086 = &constructor_to_amode(ctx, v2075, v2071, v2073);
                                    let v2090 = &constructor_synthetic_amode_to_gpr_mem(ctx, v2086);
                                    let v2098 = constructor_x64_movzx(ctx, &ExtMode::WQ, v2090);
                                    let v2099 = constructor_output_gpr(ctx, v2098);
                                    let v2100 = Some(v2099);
                                    // Rule at src/isa/x64/lower.isle line 3083.
                                    return v2100;
                                }
                            }
                        }
                    }
                }
                &Opcode::Sload16 => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        let v2067 = &C::type_register_class(ctx, v3);
                        if let Some(v2068) = v2067 {
                            if let &RegisterClass::Gpr {
                                single_register: v2069,
                            } = v2068 {
                                let v2074 = C::little_or_native_endian(ctx, v2072);
                                if let Some(v2075) = v2074 {
                                    let v2086 = &constructor_to_amode(ctx, v2075, v2071, v2073);
                                    let v2090 = &constructor_synthetic_amode_to_gpr_mem(ctx, v2086);
                                    let v2101 = constructor_x64_movsx(ctx, &ExtMode::WQ, v2090);
                                    let v2102 = constructor_output_gpr(ctx, v2101);
                                    let v2103 = Some(v2102);
                                    // Rule at src/isa/x64/lower.isle line 3085.
                                    return v2103;
                                }
                            }
                        }
                    }
                }
                &Opcode::Uload32 => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        let v2067 = &C::type_register_class(ctx, v3);
                        if let Some(v2068) = v2067 {
                            if let &RegisterClass::Gpr {
                                single_register: v2069,
                            } = v2068 {
                                let v2074 = C::little_or_native_endian(ctx, v2072);
                                if let Some(v2075) = v2074 {
                                    let v2086 = &constructor_to_amode(ctx, v2075, v2071, v2073);
                                    let v2090 = &constructor_synthetic_amode_to_gpr_mem(ctx, v2086);
                                    let v2105 = constructor_x64_movzx(ctx, &ExtMode::LQ, v2090);
                                    let v2106 = constructor_output_gpr(ctx, v2105);
                                    let v2107 = Some(v2106);
                                    // Rule at src/isa/x64/lower.isle line 3087.
                                    return v2107;
                                }
                            }
                        }
                    }
                }
                &Opcode::Sload32 => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        let v2067 = &C::type_register_class(ctx, v3);
                        if let Some(v2068) = v2067 {
                            if let &RegisterClass::Gpr {
                                single_register: v2069,
                            } = v2068 {
                                let v2074 = C::little_or_native_endian(ctx, v2072);
                                if let Some(v2075) = v2074 {
                                    let v2086 = &constructor_to_amode(ctx, v2075, v2071, v2073);
                                    let v2090 = &constructor_synthetic_amode_to_gpr_mem(ctx, v2086);
                                    let v2108 = constructor_x64_movsx(ctx, &ExtMode::LQ, v2090);
                                    let v2109 = constructor_output_gpr(ctx, v2108);
                                    let v2110 = Some(v2109);
                                    // Rule at src/isa/x64/lower.isle line 3089.
                                    return v2110;
                                }
                            }
                        }
                    }
                }
                &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 v2074 = C::little_or_native_endian(ctx, v2072);
                            if let Some(v2075) = v2074 {
                                let v692 = C::has_sse41(ctx);
                                if v692 == true {
                                    let v2086 = &constructor_to_amode(ctx, v2075, v2071, v2073);
                                    let v2147 = &C::synthetic_amode_to_xmm_mem_64(ctx, v2086);
                                    let v2151 = constructor_x64_pmovzxbw(ctx, v2147);
                                    let v2152 = constructor_output_xmm(ctx, v2151);
                                    let v2153 = Some(v2152);
                                    // Rule at src/isa/x64/lower.isle line 3123.
                                    return v2153;
                                }
                                let v2086 = &constructor_to_amode(ctx, v2075, v2071, v2073);
                                let v2166 = &C::synthetic_amode_to_gpr_mem_64(ctx, v2086);
                                let v2167 = constructor_x64_movq_to_xmm(ctx, v2166);
                                let v2171 = constructor_lower_uwiden_low(ctx, I16X8, v2167);
                                let v2172 = constructor_output_xmm(ctx, v2171);
                                let v2173 = Some(v2172);
                                // Rule at src/isa/x64/lower.isle line 3141.
                                return v2173;
                            }
                        }
                    }
                }
                &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 v2074 = C::little_or_native_endian(ctx, v2072);
                            if let Some(v2075) = v2074 {
                                let v692 = C::has_sse41(ctx);
                                if v692 == true {
                                    let v2086 = &constructor_to_amode(ctx, v2075, v2071, v2073);
                                    let v2147 = &C::synthetic_amode_to_xmm_mem_64(ctx, v2086);
                                    let v2148 = constructor_x64_pmovsxbw(ctx, v2147);
                                    let v2149 = constructor_output_xmm(ctx, v2148);
                                    let v2150 = Some(v2149);
                                    // Rule at src/isa/x64/lower.isle line 3120.
                                    return v2150;
                                }
                                let v2086 = &constructor_to_amode(ctx, v2075, v2071, v2073);
                                let v2166 = &C::synthetic_amode_to_gpr_mem_64(ctx, v2086);
                                let v2167 = constructor_x64_movq_to_xmm(ctx, v2166);
                                let v2168 = constructor_lower_swiden_low(ctx, I16X8, v2167);
                                let v2169 = constructor_output_xmm(ctx, v2168);
                                let v2170 = Some(v2169);
                                // Rule at src/isa/x64/lower.isle line 3139.
                                return v2170;
                            }
                        }
                    }
                }
                &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 v2074 = C::little_or_native_endian(ctx, v2072);
                            if let Some(v2075) = v2074 {
                                let v692 = C::has_sse41(ctx);
                                if v692 == true {
                                    let v2086 = &constructor_to_amode(ctx, v2075, v2071, v2073);
                                    let v2147 = &C::synthetic_amode_to_xmm_mem_64(ctx, v2086);
                                    let v2157 = constructor_x64_pmovzxwd(ctx, v2147);
                                    let v2158 = constructor_output_xmm(ctx, v2157);
                                    let v2159 = Some(v2158);
                                    // Rule at src/isa/x64/lower.isle line 3129.
                                    return v2159;
                                }
                                let v2086 = &constructor_to_amode(ctx, v2075, v2071, v2073);
                                let v2166 = &C::synthetic_amode_to_gpr_mem_64(ctx, v2086);
                                let v2167 = constructor_x64_movq_to_xmm(ctx, v2166);
                                let v2177 = constructor_lower_uwiden_low(ctx, I32X4, v2167);
                                let v2178 = constructor_output_xmm(ctx, v2177);
                                let v2179 = Some(v2178);
                                // Rule at src/isa/x64/lower.isle line 3145.
                                return v2179;
                            }
                        }
                    }
                }
                &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 v2074 = C::little_or_native_endian(ctx, v2072);
                            if let Some(v2075) = v2074 {
                                let v692 = C::has_sse41(ctx);
                                if v692 == true {
                                    let v2086 = &constructor_to_amode(ctx, v2075, v2071, v2073);
                                    let v2147 = &C::synthetic_amode_to_xmm_mem_64(ctx, v2086);
                                    let v2154 = constructor_x64_pmovsxwd(ctx, v2147);
                                    let v2155 = constructor_output_xmm(ctx, v2154);
                                    let v2156 = Some(v2155);
                                    // Rule at src/isa/x64/lower.isle line 3126.
                                    return v2156;
                                }
                                let v2086 = &constructor_to_amode(ctx, v2075, v2071, v2073);
                                let v2166 = &C::synthetic_amode_to_gpr_mem_64(ctx, v2086);
                                let v2167 = constructor_x64_movq_to_xmm(ctx, v2166);
                                let v2174 = constructor_lower_swiden_low(ctx, I32X4, v2167);
                                let v2175 = constructor_output_xmm(ctx, v2174);
                                let v2176 = Some(v2175);
                                // Rule at src/isa/x64/lower.isle line 3143.
                                return v2176;
                            }
                        }
                    }
                }
                &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 v2074 = C::little_or_native_endian(ctx, v2072);
                            if let Some(v2075) = v2074 {
                                let v692 = C::has_sse41(ctx);
                                if v692 == true {
                                    let v2086 = &constructor_to_amode(ctx, v2075, v2071, v2073);
                                    let v2147 = &C::synthetic_amode_to_xmm_mem_64(ctx, v2086);
                                    let v2163 = constructor_x64_pmovzxdq(ctx, v2147);
                                    let v2164 = constructor_output_xmm(ctx, v2163);
                                    let v2165 = Some(v2164);
                                    // Rule at src/isa/x64/lower.isle line 3135.
                                    return v2165;
                                }
                                let v2086 = &constructor_to_amode(ctx, v2075, v2071, v2073);
                                let v2166 = &C::synthetic_amode_to_gpr_mem_64(ctx, v2086);
                                let v2167 = constructor_x64_movq_to_xmm(ctx, v2166);
                                let v2183 = constructor_lower_uwiden_low(ctx, I64X2, v2167);
                                let v2184 = constructor_output_xmm(ctx, v2183);
                                let v2185 = Some(v2184);
                                // Rule at src/isa/x64/lower.isle line 3149.
                                return v2185;
                            }
                        }
                    }
                }
                &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 v2074 = C::little_or_native_endian(ctx, v2072);
                            if let Some(v2075) = v2074 {
                                let v692 = C::has_sse41(ctx);
                                if v692 == true {
                                    let v2086 = &constructor_to_amode(ctx, v2075, v2071, v2073);
                                    let v2147 = &C::synthetic_amode_to_xmm_mem_64(ctx, v2086);
                                    let v2160 = constructor_x64_pmovsxdq(ctx, v2147);
                                    let v2161 = constructor_output_xmm(ctx, v2160);
                                    let v2162 = Some(v2161);
                                    // Rule at src/isa/x64/lower.isle line 3132.
                                    return v2162;
                                }
                                let v2086 = &constructor_to_amode(ctx, v2075, v2071, v2073);
                                let v2166 = &C::synthetic_amode_to_gpr_mem_64(ctx, v2086);
                                let v2167 = constructor_x64_movq_to_xmm(ctx, v2166);
                                let v2180 = constructor_lower_swiden_low(ctx, I64X2, v2167);
                                let v2181 = constructor_output_xmm(ctx, v2180);
                                let v2182 = Some(v2181);
                                // Rule at src/isa/x64/lower.isle line 3147.
                                return v2182;
                            }
                        }
                    }
                }
                _ => {}
            }
        }
        &InstructionData::LoadNoOffset {
            opcode: ref v2385,
            arg: v2386,
            flags: v2387,
        } => {
            match v2385 {
                &Opcode::Bitcast => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        let v2067 = &C::type_register_class(ctx, v3);
                        if let Some(v2068) = v2067 {
                            match v2068 {
                                &RegisterClass::Gpr {
                                    single_register: v2069,
                                } => {
                                    let v2990 = C::value_type(ctx, v2386);
                                    let v2991 = &C::type_register_class(ctx, v2990);
                                    if let Some(v2992) = v2991 {
                                        if let &RegisterClass::Gpr {
                                            single_register: v2998,
                                        } = v2992 {
                                            let v3010 = constructor_output_value(ctx, v2386);
                                            let v3011 = Some(v3010);
                                            // Rule at src/isa/x64/lower.isle line 4311.
                                            return v3011;
                                        }
                                    }
                                }
                                &RegisterClass::Xmm => {
                                    let v2990 = C::value_type(ctx, v2386);
                                    let v2991 = &C::type_register_class(ctx, v2990);
                                    if let Some(v2992) = v2991 {
                                        if let &RegisterClass::Xmm = v2992 {
                                            let v3010 = constructor_output_value(ctx, v2386);
                                            let v3011 = Some(v3010);
                                            // Rule at src/isa/x64/lower.isle line 4316.
                                            return v3011;
                                        }
                                    }
                                    if v2990 == I128 {
                                        let v3006 = C::put_in_regs(ctx, v2386);
                                        let v3007 = constructor_bitcast_gprs_to_xmm(ctx, v3006);
                                        let v3008 = constructor_output_xmm(ctx, v3007);
                                        let v3009 = Some(v3008);
                                        // Rule at src/isa/x64/lower.isle line 4307.
                                        return v3009;
                                    }
                                }
                                _ => {}
                            }
                        }
                        let v2990 = C::value_type(ctx, v2386);
                        let v2991 = &C::type_register_class(ctx, v2990);
                        if let Some(v2992) = v2991 {
                            match v2992 {
                                &RegisterClass::Gpr {
                                    single_register: v2998,
                                } => {
                                    if let Some(v2068) = v2067 {
                                        if let &RegisterClass::Xmm = v2068 {
                                            let v4 = C::fits_in_64(ctx, v3);
                                            if let Some(v5) = v4 {
                                                let v2999 = constructor_put_in_gpr(ctx, v2386);
                                                let v2993 = C::ty_bits(ctx, v5);
                                                let v3000 = constructor_bitcast_gpr_to_xmm(ctx, v2993, v2999);
                                                let v3001 = constructor_output_xmm(ctx, v3000);
                                                let v3002 = Some(v3001);
                                                // Rule at src/isa/x64/lower.isle line 4301.
                                                return v3002;
                                            }
                                        }
                                    }
                                }
                                &RegisterClass::Xmm => {
                                    if v3 == I128 {
                                        let v2994 = constructor_put_in_xmm(ctx, v2386);
                                        let v3003 = constructor_bitcast_xmm_to_gprs(ctx, v2994);
                                        let v3004 = C::output(ctx, v3003);
                                        let v3005 = Some(v3004);
                                        // Rule at src/isa/x64/lower.isle line 4304.
                                        return v3005;
                                    }
                                    if let Some(v2068) = v2067 {
                                        if let &RegisterClass::Gpr {
                                            single_register: v2069,
                                        } = v2068 {
                                            let v4 = C::fits_in_64(ctx, v3);
                                            if let Some(v5) = v4 {
                                                let v2994 = constructor_put_in_xmm(ctx, v2386);
                                                let v2993 = C::ty_bits(ctx, v5);
                                                let v2995 = constructor_bitcast_xmm_to_gpr(ctx, v2993, v2994);
                                                let v2996 = constructor_output_gpr(ctx, v2995);
                                                let v2997 = Some(v2996);
                                                // Rule at src/isa/x64/lower.isle line 4298.
                                                return v2997;
                                            }
                                        }
                                    }
                                }
                                _ => {}
                            }
                        }
                    }
                }
                &Opcode::AtomicLoad => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v2388 = C::little_or_native_endian(ctx, v2387);
                        if let Some(v2389) = v2388 {
                            let v3 = C::value_type(ctx, v2);
                            match v3 {
                                I64 => {
                                    let v72 = C::zero_offset(ctx);
                                    let v2390 = &constructor_to_amode(ctx, v2389, v2386, v72);
                                    let v2391 = constructor_x64_mov(ctx, v2390);
                                    let v2392 = constructor_output_reg(ctx, v2391);
                                    let v2393 = Some(v2392);
                                    // Rule at src/isa/x64/lower.isle line 3447.
                                    return v2393;
                                }
                                I128 => {
                                    let v2402 = C::has_cmpxchg16b(ctx);
                                    if v2402 == true {
                                        let v2403 = constructor_imm(ctx, I64, 0x0_u64);
                                        let v18 = constructor_imm(ctx, I64, 0x0_u64);
                                        let v2404 = C::value_regs(ctx, v2403, v18);
                                        let v2405 = constructor_imm(ctx, I64, 0x0_u64);
                                        let v599 = constructor_imm(ctx, I64, 0x0_u64);
                                        let v2406 = C::value_regs(ctx, v2405, v599);
                                        let v2407 = C::zero_offset(ctx);
                                        let v2408 = &constructor_to_amode(ctx, v2389, v2386, v2407);
                                        let v2409 = constructor_x64_cmpxchg16b(ctx, v2404, v2406, v2408);
                                        let v2410 = C::output(ctx, v2409);
                                        let v2411 = Some(v2410);
                                        // Rule at src/isa/x64/lower.isle line 3452.
                                        return v2411;
                                    }
                                }
                                _ => {}
                            }
                            let v1769 = C::fits_in_32(ctx, v3);
                            if let Some(v1770) = v1769 {
                                let v2394 = C::ty_int(ctx, v3);
                                if let Some(v2395) = v2394 {
                                    let v2076 = C::ty_bits_u16(ctx, v1770);
                                    let v2078 = &C::ext_mode(ctx, v2076, 0x40_u16);
                                    let v2396 = C::zero_offset(ctx);
                                    let v2397 = &constructor_to_amode(ctx, v2389, v2386, v2396);
                                    let v2398 = &constructor_synthetic_amode_to_gpr_mem(ctx, v2397);
                                    let v2399 = constructor_x64_movzx(ctx, v2078, v2398);
                                    let v2400 = constructor_output_gpr(ctx, v2399);
                                    let v2401 = Some(v2400);
                                    // Rule at src/isa/x64/lower.isle line 3449.
                                    return v2401;
                                }
                            }
                        }
                    }
                }
                _ => {}
            }
        }
        &InstructionData::MultiAry {
            opcode: ref v1280,
            args: v1281,
        } => {
            if let &Opcode::Return = v1280 {
                let v1282 = C::value_list_slice(ctx, v1281);
                let v1283 = constructor_lower_return(ctx, v1282);
                let v1284 = Some(v1283);
                // Rule at src/isa/x64/lower.isle line 1958.
                return v1284;
            }
        }
        &InstructionData::NullAry {
            opcode: ref v1788,
        } => {
            match v1788 {
                &Opcode::Debugtrap => {
                    let v1789 = &constructor_x64_int3_zo(ctx);
                    let v1790 = constructor_side_effect(ctx, v1789);
                    let v1791 = Some(v1790);
                    // Rule at src/isa/x64/lower.isle line 2677.
                    return v1791;
                }
                &Opcode::GetPinnedReg => {
                    let v3137 = constructor_read_pinned_gpr(ctx);
                    let v3138 = constructor_output_gpr(ctx, v3137);
                    let v3139 = Some(v3138);
                    // Rule at src/isa/x64/lower.isle line 4582.
                    return v3139;
                }
                &Opcode::GetFramePointer => {
                    let v2588 = constructor_x64_rbp(ctx);
                    let v2589 = constructor_output_reg(ctx, v2588);
                    let v2590 = Some(v2589);
                    // Rule at src/isa/x64/lower.isle line 3636.
                    return v2590;
                }
                &Opcode::GetStackPointer => {
                    let v2591 = constructor_x64_rsp(ctx);
                    let v2592 = constructor_output_reg(ctx, v2591);
                    let v2593 = Some(v2592);
                    // Rule at src/isa/x64/lower.isle line 3639.
                    return v2593;
                }
                &Opcode::GetReturnAddress => {
                    let v2588 = constructor_x64_rbp(ctx);
                    let v71 = C::mem_flags_trusted_data(ctx);
                    let v2594 = Amode::ImmReg {
                        simm32: 8_i32,
                        base: v2588,
                        flags: v71,
                    };
                    let v2595 = &constructor_amode_to_gpr_mem_64(ctx, &v2594);
                    let v2596 = constructor_x64_movq_rm(ctx, v2595);
                    let v2597 = constructor_output_gpr(ctx, v2596);
                    let v2598 = Some(v2597);
                    // Rule at src/isa/x64/lower.isle line 3642.
                    return v2598;
                }
                &Opcode::Nop => {
                    let v3563 = C::invalid_reg(ctx);
                    let v3564 = constructor_output_reg(ctx, v3563);
                    let v3565 = Some(v3564);
                    // Rule at src/isa/x64/lower.isle line 5192.
                    return v3565;
                }
                &Opcode::Fence => {
                    let v2361 = &constructor_x64_mfence_zo(ctx);
                    let v2362 = constructor_side_effect(ctx, v2361);
                    let v2363 = Some(v2362);
                    // Rule at src/isa/x64/lower.isle line 3426.
                    return v2363;
                }
                &Opcode::SequencePoint => {
                    let v3566 = &constructor_x64_sequence_point(ctx);
                    let v3567 = constructor_side_effect(ctx, v3566);
                    let v3568 = Some(v3567);
                    // Rule at src/isa/x64/lower.isle line 5197.
                    return v3568;
                }
                _ => {}
            }
        }
        &InstructionData::Shuffle {
            opcode: ref v3152,
            args: ref v3153,
            imm: v3154,
        } => {
            if let &Opcode::Shuffle = v3152 {
                let v692 = C::has_sse41(ctx);
                if v692 == true {
                    let v3158 = C::pblendw_imm(ctx, v3154);
                    if let Some(v3159) = v3158 {
                        let v3155 = C::unpack_value_array_2(ctx, v3153);
                        let v3160 = constructor_put_in_xmm(ctx, v3155.0);
                        let v3161 = &C::put_in_xmm_mem_128(ctx, v3155.1);
                        let v3162 = constructor_x64_pblendw(ctx, v3160, v3161, v3159);
                        let v3163 = constructor_output_xmm(ctx, v3162);
                        let v3164 = Some(v3163);
                        // Rule at src/isa/x64/lower.isle line 4606.
                        return v3164;
                    }
                }
                let v785 = C::has_ssse3(ctx);
                if v785 == true {
                    let v3165 = C::palignr_imm_from_immediate(ctx, v3154);
                    if let Some(v3166) = v3165 {
                        let v3155 = C::unpack_value_array_2(ctx, v3153);
                        let v3167 = constructor_put_in_xmm(ctx, v3155.1);
                        let v3168 = &C::put_in_xmm_mem_128(ctx, v3155.0);
                        let v3169 = constructor_x64_palignr(ctx, v3167, v3168, v3166);
                        let v3170 = constructor_output_xmm(ctx, v3169);
                        let v3171 = Some(v3170);
                        // Rule at src/isa/x64/lower.isle line 4617.
                        return v3171;
                    }
                }
                let v3172 = C::pshuflw_lhs_imm(ctx, v3154);
                if let Some(v3173) = v3172 {
                    let v3155 = C::unpack_value_array_2(ctx, v3153);
                    let v3174 = &C::put_in_xmm_mem_128(ctx, v3155.0);
                    let v3175 = constructor_x64_pshuflw(ctx, v3174, v3173);
                    let v3176 = constructor_output_xmm(ctx, v3175);
                    let v3177 = Some(v3176);
                    // Rule at src/isa/x64/lower.isle line 4629.
                    return v3177;
                }
                let v3178 = C::pshuflw_rhs_imm(ctx, v3154);
                if let Some(v3179) = v3178 {
                    let v3155 = C::unpack_value_array_2(ctx, v3153);
                    let v3180 = &C::put_in_xmm_mem_128(ctx, v3155.1);
                    let v3181 = constructor_x64_pshuflw(ctx, v3180, v3179);
                    let v3182 = constructor_output_xmm(ctx, v3181);
                    let v3183 = Some(v3182);
                    // Rule at src/isa/x64/lower.isle line 4631.
                    return v3183;
                }
                let v3184 = C::pshufhw_lhs_imm(ctx, v3154);
                if let Some(v3185) = v3184 {
                    let v3155 = C::unpack_value_array_2(ctx, v3153);
                    let v3174 = &C::put_in_xmm_mem_128(ctx, v3155.0);
                    let v3186 = constructor_x64_pshufhw(ctx, v3174, v3185);
                    let v3187 = constructor_output_xmm(ctx, v3186);
                    let v3188 = Some(v3187);
                    // Rule at src/isa/x64/lower.isle line 4633.
                    return v3188;
                }
                let v3189 = C::pshufhw_rhs_imm(ctx, v3154);
                if let Some(v3190) = v3189 {
                    let v3155 = C::unpack_value_array_2(ctx, v3153);
                    let v3180 = &C::put_in_xmm_mem_128(ctx, v3155.1);
                    let v3191 = constructor_x64_pshufhw(ctx, v3180, v3190);
                    let v3192 = constructor_output_xmm(ctx, v3191);
                    let v3193 = Some(v3192);
                    // Rule at src/isa/x64/lower.isle line 4635.
                    return v3193;
                }
                let v3194 = C::pshufd_lhs_imm(ctx, v3154);
                if let Some(v3195) = v3194 {
                    let v3155 = C::unpack_value_array_2(ctx, v3153);
                    let v3174 = &C::put_in_xmm_mem_128(ctx, v3155.0);
                    let v3196 = constructor_x64_pshufd(ctx, v3174, v3195);
                    let v3197 = constructor_output_xmm(ctx, v3196);
                    let v3198 = Some(v3197);
                    // Rule at src/isa/x64/lower.isle line 4652.
                    return v3198;
                }
                let v3199 = C::pshufd_rhs_imm(ctx, v3154);
                if let Some(v3200) = v3199 {
                    let v3155 = C::unpack_value_array_2(ctx, v3153);
                    let v3180 = &C::put_in_xmm_mem_128(ctx, v3155.1);
                    let v3201 = constructor_x64_pshufd(ctx, v3180, v3200);
                    let v3202 = constructor_output_xmm(ctx, v3201);
                    let v3203 = Some(v3202);
                    // Rule at src/isa/x64/lower.isle line 4654.
                    return v3203;
                }
                let v3204 = C::u128_from_immediate(ctx, v3154);
                if let Some(v3205) = v3204 {
                    match v3205 {
                        0x0_u128 => {
                            if v785 == true {
                                let v3155 = C::unpack_value_array_2(ctx, v3153);
                                let v3160 = constructor_put_in_xmm(ctx, v3155.0);
                                let v791 = constructor_xmm_zero(ctx, I8X16);
                                let v2939 = &C::xmm_to_xmm_mem_128(ctx, v791);
                                let v3230 = constructor_x64_pshufb(ctx, v3160, v2939);
                                let v3231 = constructor_output_xmm(ctx, v3230);
                                let v3232 = Some(v3231);
                                // Rule at src/isa/x64/lower.isle line 4691.
                                return v3232;
                            }
                        }
                        0x17071606150514041303120211011000_u128 => {
                            let v3155 = C::unpack_value_array_2(ctx, v3153);
                            let v3160 = constructor_put_in_xmm(ctx, v3155.0);
                            let v3161 = &C::put_in_xmm_mem_128(ctx, v3155.1);
                            let v3209 = constructor_x64_punpcklbw(ctx, v3160, v3161);
                            let v3210 = constructor_output_xmm(ctx, v3209);
                            let v3211 = Some(v3210);
                            // Rule at src/isa/x64/lower.isle line 4665.
                            return v3211;
                        }
                        0x17160706151405041312030211100100_u128 => {
                            let v3155 = C::unpack_value_array_2(ctx, v3153);
                            let v3160 = constructor_put_in_xmm(ctx, v3155.0);
                            let v3161 = &C::put_in_xmm_mem_128(ctx, v3155.1);
                            let v3215 = constructor_x64_punpcklwd(ctx, v3160, v3161);
                            let v3216 = constructor_output_xmm(ctx, v3215);
                            let v3217 = Some(v3216);
                            // Rule at src/isa/x64/lower.isle line 4671.
                            return v3217;
                        }
                        0x17161514070605041312111003020100_u128 => {
                            let v3155 = C::unpack_value_array_2(ctx, v3153);
                            let v3160 = constructor_put_in_xmm(ctx, v3155.0);
                            let v3161 = &C::put_in_xmm_mem_128(ctx, v3155.1);
                            let v3221 = constructor_x64_punpckldq(ctx, v3160, v3161);
                            let v3222 = constructor_output_xmm(ctx, v3221);
                            let v3223 = Some(v3222);
                            // Rule at src/isa/x64/lower.isle line 4677.
                            return v3223;
                        }
                        0x17161514131211100706050403020100_u128 => {
                            let v3155 = C::unpack_value_array_2(ctx, v3153);
                            let v3160 = constructor_put_in_xmm(ctx, v3155.0);
                            let v3161 = &C::put_in_xmm_mem_128(ctx, v3155.1);
                            let v3227 = constructor_x64_punpcklqdq(ctx, v3160, v3161);
                            let v3228 = constructor_output_xmm(ctx, v3227);
                            let v3229 = Some(v3228);
                            // Rule at src/isa/x64/lower.isle line 4683.
                            return v3229;
                        }
                        0x1f0f1e0e1d0d1c0c1b0b1a0a19091808_u128 => {
                            let v3155 = C::unpack_value_array_2(ctx, v3153);
                            let v3160 = constructor_put_in_xmm(ctx, v3155.0);
                            let v3161 = &C::put_in_xmm_mem_128(ctx, v3155.1);
                            let v3206 = constructor_x64_punpckhbw(ctx, v3160, v3161);
                            let v3207 = constructor_output_xmm(ctx, v3206);
                            let v3208 = Some(v3207);
                            // Rule at src/isa/x64/lower.isle line 4663.
                            return v3208;
                        }
                        0x1f1e0f0e1d1c0d0c1b1a0b0a19180908_u128 => {
                            let v3155 = C::unpack_value_array_2(ctx, v3153);
                            let v3160 = constructor_put_in_xmm(ctx, v3155.0);
                            let v3161 = &C::put_in_xmm_mem_128(ctx, v3155.1);
                            let v3212 = constructor_x64_punpckhwd(ctx, v3160, v3161);
                            let v3213 = constructor_output_xmm(ctx, v3212);
                            let v3214 = Some(v3213);
                            // Rule at src/isa/x64/lower.isle line 4669.
                            return v3214;
                        }
                        0x1f1e1d1c0f0e0d0c1b1a19180b0a0908_u128 => {
                            let v3155 = C::unpack_value_array_2(ctx, v3153);
                            let v3160 = constructor_put_in_xmm(ctx, v3155.0);
                            let v3161 = &C::put_in_xmm_mem_128(ctx, v3155.1);
                            let v3218 = constructor_x64_punpckhdq(ctx, v3160, v3161);
                            let v3219 = constructor_output_xmm(ctx, v3218);
                            let v3220 = Some(v3219);
                            // Rule at src/isa/x64/lower.isle line 4675.
                            return v3220;
                        }
                        0x1f1e1d1c1b1a19180f0e0d0c0b0a0908_u128 => {
                            let v3155 = C::unpack_value_array_2(ctx, v3153);
                            let v3160 = constructor_put_in_xmm(ctx, v3155.0);
                            let v3161 = &C::put_in_xmm_mem_128(ctx, v3155.1);
                            let v3224 = constructor_x64_punpckhqdq(ctx, v3160, v3161);
                            let v3225 = constructor_output_xmm(ctx, v3224);
                            let v3226 = Some(v3225);
                            // Rule at src/isa/x64/lower.isle line 4681.
                            return v3226;
                        }
                        _ => {}
                    }
                }
                let v3233 = C::shufps_imm(ctx, v3154);
                if let Some(v3234) = v3233 {
                    let v3155 = C::unpack_value_array_2(ctx, v3153);
                    let v3160 = constructor_put_in_xmm(ctx, v3155.0);
                    let v3161 = &C::put_in_xmm_mem_128(ctx, v3155.1);
                    let v3235 = constructor_x64_shufps(ctx, v3160, v3161, v3234);
                    let v3236 = constructor_output_xmm(ctx, v3235);
                    let v3237 = Some(v3236);
                    // Rule at src/isa/x64/lower.isle line 4705.
                    return v3237;
                }
                let v3238 = C::shufps_rev_imm(ctx, v3154);
                if let Some(v3239) = v3238 {
                    let v3155 = C::unpack_value_array_2(ctx, v3153);
                    let v3167 = constructor_put_in_xmm(ctx, v3155.1);
                    let v3168 = &C::put_in_xmm_mem_128(ctx, v3155.0);
                    let v3240 = constructor_x64_shufps(ctx, v3167, v3168, v3239);
                    let v3241 = constructor_output_xmm(ctx, v3240);
                    let v3242 = Some(v3241);
                    // Rule at src/isa/x64/lower.isle line 4707.
                    return v3242;
                }
                let v3243 = &C::vec_mask_from_immediate(ctx, v3154);
                if let Some(v3244) = v3243 {
                    if v785 == true {
                        let v3155 = C::unpack_value_array_2(ctx, v3153);
                        if v3155.0 == v3155.1 {
                            let v3160 = constructor_put_in_xmm(ctx, v3155.0);
                            let v3245 = C::shuffle_0_31_mask(ctx, v3244);
                            let v3246 = &C::const_to_xmm_mem_128(ctx, v3245);
                            let v3247 = constructor_x64_pshufb(ctx, v3160, v3246);
                            let v3248 = constructor_output_xmm(ctx, v3247);
                            let v3249 = Some(v3248);
                            // Rule at src/isa/x64/lower.isle line 4720.
                            return v3249;
                        }
                    }
                    let v533 = C::has_avx512vl(ctx);
                    if v533 == true {
                        let v3254 = C::has_avx512vbmi(ctx);
                        if v3254 == true {
                            let v3250 = C::perm_from_mask_with_zeros(ctx, v3244);
                            if let Some(v3251) = v3250 {
                                let v3255 = constructor_x64_xmm_load_const(ctx, I8X16, v3251.0);
                                let v3155 = C::unpack_value_array_2(ctx, v3153);
                                let v3256 = constructor_put_in_xmm(ctx, v3155.0);
                                let v3257 = &C::put_in_xmm_mem_128(ctx, v3155.1);
                                let v3258 = constructor_x64_vpermi2b(ctx, v3255, v3256, v3257);
                                let v3259 = &C::const_to_xmm_mem_128(ctx, v3251.1);
                                let v3260 = constructor_x64_andps(ctx, v3258, v3259);
                                let v3261 = constructor_output_xmm(ctx, v3260);
                                let v3262 = Some(v3261);
                                // Rule at src/isa/x64/lower.isle line 4727.
                                return v3262;
                            }
                            let v3263 = C::perm_from_mask(ctx, v3244);
                            let v3264 = constructor_x64_xmm_load_const(ctx, I8X16, v3263);
                            let v3155 = C::unpack_value_array_2(ctx, v3153);
                            let v3265 = constructor_put_in_xmm(ctx, v3155.0);
                            let v3266 = &C::put_in_xmm_mem_128(ctx, v3155.1);
                            let v3267 = constructor_x64_vpermi2b(ctx, v3264, v3265, v3266);
                            let v3268 = constructor_output_xmm(ctx, v3267);
                            let v3269 = Some(v3268);
                            // Rule at src/isa/x64/lower.isle line 4734.
                            return v3269;
                        }
                    }
                    let v3155 = C::unpack_value_array_2(ctx, v3153);
                    let v3160 = constructor_put_in_xmm(ctx, v3155.0);
                    let v3270 = C::shuffle_0_15_mask(ctx, v3244);
                    let v3271 = &C::const_to_xmm_mem_128(ctx, v3270);
                    let v3272 = constructor_lower_pshufb(ctx, v3160, v3271);
                    let v3273 = constructor_put_in_xmm(ctx, v3155.1);
                    let v3274 = C::shuffle_16_31_mask(ctx, v3244);
                    let v3275 = &C::const_to_xmm_mem_128(ctx, v3274);
                    let v3276 = constructor_lower_pshufb(ctx, v3273, v3275);
                    let v3277 = &C::xmm_to_xmm_mem_128(ctx, v3276);
                    let v3278 = constructor_x64_por(ctx, v3272, v3277);
                    let v3279 = constructor_output_xmm(ctx, v3278);
                    let v3280 = Some(v3279);
                    // Rule at src/isa/x64/lower.isle line 4742.
                    return v3280;
                }
            }
        }
        &InstructionData::StackLoad {
            opcode: ref v3047,
            stack_slot: v3048,
            offset: v3049,
        } => {
            if let &Opcode::StackAddr = v3047 {
                let v3050 = constructor_stack_addr_impl(ctx, v3048, v3049);
                let v3051 = constructor_output_gpr(ctx, v3050);
                let v3052 = Some(v3051);
                // Rule at src/isa/x64/lower.isle line 4433.
                return v3052;
            }
        }
        &InstructionData::Store {
            opcode: ref v2186,
            args: ref v2187,
            flags: v2188,
            offset: v2189,
        } => {
            match v2186 {
                &Opcode::Store => {
                    let v2197 = C::little_or_native_endian(ctx, v2188);
                    if let Some(v2198) = v2197 {
                        let v2190 = C::unpack_value_array_2(ctx, v2187);
                        let v2193 = C::value_type(ctx, v2190.0);
                        let v2215 = C::fits_in_64(ctx, v2193);
                        if let Some(v2216) = v2215 {
                            let v2217 = C::i64_from_iconst(ctx, v2190.0);
                            if let Some(v2218) = v2217 {
                                let v2219 = C::i64_from_i32(ctx, v2218);
                                if let Some(v2220) = v2219 {
                                    let v2199 = &constructor_to_amode(ctx, v2198, v2190.1, v2189);
                                    let v2221 = &constructor_x64_movimm_m(ctx, v2216, v2199, v2220);
                                    let v2222 = constructor_side_effect(ctx, v2221);
                                    let v2223 = Some(v2222);
                                    // Rule at src/isa/x64/lower.isle line 3174.
                                    return v2223;
                                }
                            }
                        }
                        let v2266 = C::def_inst(ctx, v2190.0);
                        if let Some(v2267) = v2266 {
                            let v2268 = C::first_result(ctx, v2267);
                            if let Some(v2269) = v2268 {
                                let v2271 = C::inst_data_value(ctx, v2267);
                                match &v2271.1 {
                                    &InstructionData::Binary {
                                        opcode: ref v2299,
                                        args: ref v2300,
                                    } => {
                                        match v2299 {
                                            &Opcode::Iadd => {
                                                let v2270 = C::value_type(ctx, v2269);
                                                let v2297 = C::ty_32_or_64(ctx, v2270);
                                                if let Some(v2298) = v2297 {
                                                    let v2301 = C::unpack_value_array_2(ctx, v2300);
                                                    let v2304 = &C::sinkable_load(ctx, v2301.0);
                                                    if let Some(v2305) = v2304 {
                                                        let v2306 = C::def_inst(ctx, v2301.0);
                                                        if let Some(v2307) = v2306 {
                                                            let v2308 = C::inst_data_value(ctx, v2307);
                                                            if let &InstructionData::Load {
                                                                opcode: ref v2311,
                                                                arg: v2312,
                                                                flags: v2313,
                                                                offset: v2314,
                                                            } = &v2308.1 {
                                                                if let &Opcode::Load = v2311 {
                                                                    if v2189 == v2314 {
                                                                        let v2315 = C::mem_flags_data(ctx, v2313);
                                                                        if let Some(v2316) = v2315 {
                                                                            if v2198 == v2316 {
                                                                                if v2190.1 == v2312 {
                                                                                    let v2317 = &constructor_sink_load_to_reg_mem_imm(ctx, v2305);
                                                                                    let v2318 = &constructor_to_amode(ctx, v2316, v2312, v2314);
                                                                                    let v2319 = &constructor_x64_add_mem(ctx, v2298, v2318, v2301.1);
                                                                                    let v2320 = constructor_side_effect(ctx, v2319);
                                                                                    let v2321 = Some(v2320);
                                                                                    // Rule at src/isa/x64/lower.isle line 3299.
                                                                                    return v2321;
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                    let v2322 = &C::sinkable_load(ctx, v2301.1);
                                                    if let Some(v2323) = v2322 {
                                                        let v2324 = C::def_inst(ctx, v2301.1);
                                                        if let Some(v2325) = v2324 {
                                                            let v2326 = C::inst_data_value(ctx, v2325);
                                                            if let &InstructionData::Load {
                                                                opcode: ref v2329,
                                                                arg: v2330,
                                                                flags: v2331,
                                                                offset: v2332,
                                                            } = &v2326.1 {
                                                                if let &Opcode::Load = v2329 {
                                                                    if v2189 == v2332 {
                                                                        let v2333 = C::mem_flags_data(ctx, v2331);
                                                                        if let Some(v2334) = v2333 {
                                                                            if v2198 == v2334 {
                                                                                if v2190.1 == v2330 {
                                                                                    let v2335 = &constructor_sink_load_to_reg_mem_imm(ctx, v2323);
                                                                                    let v2336 = &constructor_to_amode(ctx, v2334, v2330, v2332);
                                                                                    let v2337 = &constructor_x64_add_mem(ctx, v2298, v2336, v2301.0);
                                                                                    let v2338 = constructor_side_effect(ctx, v2337);
                                                                                    let v2339 = Some(v2338);
                                                                                    // Rule at src/isa/x64/lower.isle line 3313.
                                                                                    return v2339;
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                            &Opcode::Isub => {
                                                let v2270 = C::value_type(ctx, v2269);
                                                let v2297 = C::ty_32_or_64(ctx, v2270);
                                                if let Some(v2298) = v2297 {
                                                    let v2301 = C::unpack_value_array_2(ctx, v2300);
                                                    let v2304 = &C::sinkable_load(ctx, v2301.0);
                                                    if let Some(v2305) = v2304 {
                                                        let v2306 = C::def_inst(ctx, v2301.0);
                                                        if let Some(v2307) = v2306 {
                                                            let v2308 = C::inst_data_value(ctx, v2307);
                                                            if let &InstructionData::Load {
                                                                opcode: ref v2311,
                                                                arg: v2312,
                                                                flags: v2313,
                                                                offset: v2314,
                                                            } = &v2308.1 {
                                                                if let &Opcode::Load = v2311 {
                                                                    if v2189 == v2314 {
                                                                        let v2315 = C::mem_flags_data(ctx, v2313);
                                                                        if let Some(v2316) = v2315 {
                                                                            if v2198 == v2316 {
                                                                                if v2190.1 == v2312 {
                                                                                    let v2317 = &constructor_sink_load_to_reg_mem_imm(ctx, v2305);
                                                                                    let v2318 = &constructor_to_amode(ctx, v2316, v2312, v2314);
                                                                                    let v2340 = &constructor_x64_sub_mem(ctx, v2298, v2318, v2301.1);
                                                                                    let v2341 = constructor_side_effect(ctx, v2340);
                                                                                    let v2342 = Some(v2341);
                                                                                    // Rule at src/isa/x64/lower.isle line 3327.
                                                                                    return v2342;
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                            &Opcode::Band => {
                                                let v2270 = C::value_type(ctx, v2269);
                                                let v2297 = C::ty_32_or_64(ctx, v2270);
                                                if let Some(v2298) = v2297 {
                                                    let v2301 = C::unpack_value_array_2(ctx, v2300);
                                                    let v2304 = &C::sinkable_load(ctx, v2301.0);
                                                    if let Some(v2305) = v2304 {
                                                        let v2306 = C::def_inst(ctx, v2301.0);
                                                        if let Some(v2307) = v2306 {
                                                            let v2308 = C::inst_data_value(ctx, v2307);
                                                            if let &InstructionData::Load {
                                                                opcode: ref v2311,
                                                                arg: v2312,
                                                                flags: v2313,
                                                                offset: v2314,
                                                            } = &v2308.1 {
                                                                if let &Opcode::Load = v2311 {
                                                                    if v2189 == v2314 {
                                                                        let v2315 = C::mem_flags_data(ctx, v2313);
                                                                        if let Some(v2316) = v2315 {
                                                                            if v2198 == v2316 {
                                                                                if v2190.1 == v2312 {
                                                                                    let v2317 = &constructor_sink_load_to_reg_mem_imm(ctx, v2305);
                                                                                    let v2318 = &constructor_to_amode(ctx, v2316, v2312, v2314);
                                                                                    let v2343 = &constructor_x64_and_mem(ctx, v2298, v2318, v2301.1);
                                                                                    let v2344 = constructor_side_effect(ctx, v2343);
                                                                                    let v2345 = Some(v2344);
                                                                                    // Rule at src/isa/x64/lower.isle line 3341.
                                                                                    return v2345;
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                    let v2322 = &C::sinkable_load(ctx, v2301.1);
                                                    if let Some(v2323) = v2322 {
                                                        let v2324 = C::def_inst(ctx, v2301.1);
                                                        if let Some(v2325) = v2324 {
                                                            let v2326 = C::inst_data_value(ctx, v2325);
                                                            if let &InstructionData::Load {
                                                                opcode: ref v2329,
                                                                arg: v2330,
                                                                flags: v2331,
                                                                offset: v2332,
                                                            } = &v2326.1 {
                                                                if let &Opcode::Load = v2329 {
                                                                    if v2189 == v2332 {
                                                                        let v2333 = C::mem_flags_data(ctx, v2331);
                                                                        if let Some(v2334) = v2333 {
                                                                            if v2198 == v2334 {
                                                                                if v2190.1 == v2330 {
                                                                                    let v2335 = &constructor_sink_load_to_reg_mem_imm(ctx, v2323);
                                                                                    let v2336 = &constructor_to_amode(ctx, v2334, v2330, v2332);
                                                                                    let v2346 = &constructor_x64_and_mem(ctx, v2298, v2336, v2301.0);
                                                                                    let v2347 = constructor_side_effect(ctx, v2346);
                                                                                    let v2348 = Some(v2347);
                                                                                    // Rule at src/isa/x64/lower.isle line 3355.
                                                                                    return v2348;
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                            &Opcode::Bor => {
                                                let v2270 = C::value_type(ctx, v2269);
                                                let v2297 = C::ty_32_or_64(ctx, v2270);
                                                if let Some(v2298) = v2297 {
                                                    let v2301 = C::unpack_value_array_2(ctx, v2300);
                                                    let v2304 = &C::sinkable_load(ctx, v2301.0);
                                                    if let Some(v2305) = v2304 {
                                                        let v2306 = C::def_inst(ctx, v2301.0);
                                                        if let Some(v2307) = v2306 {
                                                            let v2308 = C::inst_data_value(ctx, v2307);
                                                            if let &InstructionData::Load {
                                                                opcode: ref v2311,
                                                                arg: v2312,
                                                                flags: v2313,
                                                                offset: v2314,
                                                            } = &v2308.1 {
                                                                if let &Opcode::Load = v2311 {
                                                                    if v2189 == v2314 {
                                                                        let v2315 = C::mem_flags_data(ctx, v2313);
                                                                        if let Some(v2316) = v2315 {
                                                                            if v2198 == v2316 {
                                                                                if v2190.1 == v2312 {
                                                                                    let v2317 = &constructor_sink_load_to_reg_mem_imm(ctx, v2305);
                                                                                    let v2318 = &constructor_to_amode(ctx, v2316, v2312, v2314);
                                                                                    let v2349 = &constructor_x64_or_mem(ctx, v2298, v2318, v2301.1);
                                                                                    let v2350 = constructor_side_effect(ctx, v2349);
                                                                                    let v2351 = Some(v2350);
                                                                                    // Rule at src/isa/x64/lower.isle line 3369.
                                                                                    return v2351;
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                    let v2322 = &C::sinkable_load(ctx, v2301.1);
                                                    if let Some(v2323) = v2322 {
                                                        let v2324 = C::def_inst(ctx, v2301.1);
                                                        if let Some(v2325) = v2324 {
                                                            let v2326 = C::inst_data_value(ctx, v2325);
                                                            if let &InstructionData::Load {
                                                                opcode: ref v2329,
                                                                arg: v2330,
                                                                flags: v2331,
                                                                offset: v2332,
                                                            } = &v2326.1 {
                                                                if let &Opcode::Load = v2329 {
                                                                    if v2189 == v2332 {
                                                                        let v2333 = C::mem_flags_data(ctx, v2331);
                                                                        if let Some(v2334) = v2333 {
                                                                            if v2198 == v2334 {
                                                                                if v2190.1 == v2330 {
                                                                                    let v2335 = &constructor_sink_load_to_reg_mem_imm(ctx, v2323);
                                                                                    let v2336 = &constructor_to_amode(ctx, v2334, v2330, v2332);
                                                                                    let v2352 = &constructor_x64_or_mem(ctx, v2298, v2336, v2301.0);
                                                                                    let v2353 = constructor_side_effect(ctx, v2352);
                                                                                    let v2354 = Some(v2353);
                                                                                    // Rule at src/isa/x64/lower.isle line 3383.
                                                                                    return v2354;
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                            &Opcode::Bxor => {
                                                let v2270 = C::value_type(ctx, v2269);
                                                let v2297 = C::ty_32_or_64(ctx, v2270);
                                                if let Some(v2298) = v2297 {
                                                    let v2301 = C::unpack_value_array_2(ctx, v2300);
                                                    let v2304 = &C::sinkable_load(ctx, v2301.0);
                                                    if let Some(v2305) = v2304 {
                                                        let v2306 = C::def_inst(ctx, v2301.0);
                                                        if let Some(v2307) = v2306 {
                                                            let v2308 = C::inst_data_value(ctx, v2307);
                                                            if let &InstructionData::Load {
                                                                opcode: ref v2311,
                                                                arg: v2312,
                                                                flags: v2313,
                                                                offset: v2314,
                                                            } = &v2308.1 {
                                                                if let &Opcode::Load = v2311 {
                                                                    if v2189 == v2314 {
                                                                        let v2315 = C::mem_flags_data(ctx, v2313);
                                                                        if let Some(v2316) = v2315 {
                                                                            if v2198 == v2316 {
                                                                                if v2190.1 == v2312 {
                                                                                    let v2317 = &constructor_sink_load_to_reg_mem_imm(ctx, v2305);
                                                                                    let v2318 = &constructor_to_amode(ctx, v2316, v2312, v2314);
                                                                                    let v2355 = &constructor_x64_xor_mem(ctx, v2298, v2318, v2301.1);
                                                                                    let v2356 = constructor_side_effect(ctx, v2355);
                                                                                    let v2357 = Some(v2356);
                                                                                    // Rule at src/isa/x64/lower.isle line 3397.
                                                                                    return v2357;
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                    let v2322 = &C::sinkable_load(ctx, v2301.1);
                                                    if let Some(v2323) = v2322 {
                                                        let v2324 = C::def_inst(ctx, v2301.1);
                                                        if let Some(v2325) = v2324 {
                                                            let v2326 = C::inst_data_value(ctx, v2325);
                                                            if let &InstructionData::Load {
                                                                opcode: ref v2329,
                                                                arg: v2330,
                                                                flags: v2331,
                                                                offset: v2332,
                                                            } = &v2326.1 {
                                                                if let &Opcode::Load = v2329 {
                                                                    if v2189 == v2332 {
                                                                        let v2333 = C::mem_flags_data(ctx, v2331);
                                                                        if let Some(v2334) = v2333 {
                                                                            if v2198 == v2334 {
                                                                                if v2190.1 == v2330 {
                                                                                    let v2335 = &constructor_sink_load_to_reg_mem_imm(ctx, v2323);
                                                                                    let v2336 = &constructor_to_amode(ctx, v2334, v2330, v2332);
                                                                                    let v2358 = &constructor_x64_xor_mem(ctx, v2298, v2336, v2301.0);
                                                                                    let v2359 = constructor_side_effect(ctx, v2358);
                                                                                    let v2360 = Some(v2359);
                                                                                    // Rule at src/isa/x64/lower.isle line 3411.
                                                                                    return v2360;
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                            _ => {}
                                        }
                                    }
                                    &InstructionData::BinaryImm8 {
                                        opcode: ref v2274,
                                        arg: v2275,
                                        imm: v2276,
                                    } => {
                                        if let &Opcode::Extractlane = v2274 {
                                            let v2270 = C::value_type(ctx, v2269);
                                            match v2270 {
                                                I8 => {
                                                    let v692 = C::has_sse41(ctx);
                                                    if v692 == true {
                                                        let v2199 = &constructor_to_amode(ctx, v2198, v2190.1, v2189);
                                                        let v2278 = constructor_put_in_xmm(ctx, v2275);
                                                        let v2277 = C::u8_from_uimm8(ctx, v2276);
                                                        let v2285 = &constructor_x64_pextrb_store(ctx, v2199, v2278, v2277);
                                                        let v2286 = constructor_side_effect(ctx, v2285);
                                                        let v2287 = Some(v2286);
                                                        // Rule at src/isa/x64/lower.isle line 3267.
                                                        return v2287;
                                                    }
                                                }
                                                I16 => {
                                                    let v692 = C::has_sse41(ctx);
                                                    if v692 == true {
                                                        let v2199 = &constructor_to_amode(ctx, v2198, v2190.1, v2189);
                                                        let v2278 = constructor_put_in_xmm(ctx, v2275);
                                                        let v2277 = C::u8_from_uimm8(ctx, v2276);
                                                        let v2288 = &constructor_x64_pextrw_store(ctx, v2199, v2278, v2277);
                                                        let v2289 = constructor_side_effect(ctx, v2288);
                                                        let v2290 = Some(v2289);
                                                        // Rule at src/isa/x64/lower.isle line 3274.
                                                        return v2290;
                                                    }
                                                }
                                                I32 => {
                                                    let v692 = C::has_sse41(ctx);
                                                    if v692 == true {
                                                        let v2199 = &constructor_to_amode(ctx, v2198, v2190.1, v2189);
                                                        let v2278 = constructor_put_in_xmm(ctx, v2275);
                                                        let v2277 = C::u8_from_uimm8(ctx, v2276);
                                                        let v2291 = &constructor_x64_pextrd_store(ctx, v2199, v2278, v2277);
                                                        let v2292 = constructor_side_effect(ctx, v2291);
                                                        let v2293 = Some(v2292);
                                                        // Rule at src/isa/x64/lower.isle line 3281.
                                                        return v2293;
                                                    }
                                                }
                                                I64 => {
                                                    let v692 = C::has_sse41(ctx);
                                                    if v692 == true {
                                                        let v2199 = &constructor_to_amode(ctx, v2198, v2190.1, v2189);
                                                        let v2278 = constructor_put_in_xmm(ctx, v2275);
                                                        let v2277 = C::u8_from_uimm8(ctx, v2276);
                                                        let v2294 = &constructor_x64_pextrq_store(ctx, v2199, v2278, v2277);
                                                        let v2295 = constructor_side_effect(ctx, v2294);
                                                        let v2296 = Some(v2295);
                                                        // Rule at src/isa/x64/lower.isle line 3288.
                                                        return v2296;
                                                    }
                                                }
                                                F32 => {
                                                    let v2277 = C::u8_from_uimm8(ctx, v2276);
                                                    if v2277 == 0x0_u8 {
                                                        let v2199 = &constructor_to_amode(ctx, v2198, v2190.1, v2189);
                                                        let v2278 = constructor_put_in_xmm(ctx, v2275);
                                                        let v2279 = &constructor_x64_movss_store(ctx, v2199, v2278);
                                                        let v2280 = constructor_side_effect(ctx, v2279);
                                                        let v2281 = Some(v2280);
                                                        // Rule at src/isa/x64/lower.isle line 3255.
                                                        return v2281;
                                                    }
                                                }
                                                F64 => {
                                                    let v2277 = C::u8_from_uimm8(ctx, v2276);
                                                    if v2277 == 0x0_u8 {
                                                        let v2199 = &constructor_to_amode(ctx, v2198, v2190.1, v2189);
                                                        let v2278 = constructor_put_in_xmm(ctx, v2275);
                                                        let v2282 = &constructor_x64_movsd_store(ctx, v2199, v2278);
                                                        let v2283 = constructor_side_effect(ctx, v2282);
                                                        let v2284 = Some(v2283);
                                                        // Rule at src/isa/x64/lower.isle line 3261.
                                                        return v2284;
                                                    }
                                                }
                                                _ => {}
                                            }
                                        }
                                    }
                                    _ => {}
                                }
                            }
                        }
                        match v2193 {
                            I128 => {
                                let v2256 = C::put_in_regs(ctx, v2190.0);
                                let v2257 = constructor_value_regs_get_gpr(ctx, v2256, 0x0_usize);
                                let v2258 = constructor_value_regs_get_gpr(ctx, v2256, 0x1_usize);
                                let v2259 = &constructor_to_amode(ctx, v2198, v2190.1, v2189);
                                let v2260 = &constructor_amode_offset(ctx, v2259, v2198, 8_i32);
                                let v2261 = &constructor_x64_movrm(ctx, I64, v2259, v2257);
                                let v2262 = &constructor_x64_movrm(ctx, I64, v2260, v2258);
                                let v2263 = &constructor_side_effect_concat(ctx, v2261, v2262);
                                let v2264 = constructor_side_effect(ctx, v2263);
                                let v2265 = Some(v2264);
                                // Rule at src/isa/x64/lower.isle line 3236.
                                return v2265;
                            }
                            F32X4 => {
                                let v2199 = &constructor_to_amode(ctx, v2198, v2190.1, v2189);
                                let v2227 = constructor_put_in_xmm(ctx, v2190.0);
                                let v2245 = &constructor_x64_movups_store(ctx, v2199, v2227);
                                let v2246 = constructor_side_effect(ctx, v2245);
                                let v2247 = Some(v2246);
                                // Rule at src/isa/x64/lower.isle line 3212.
                                return v2247;
                            }
                            F64X2 => {
                                let v2199 = &constructor_to_amode(ctx, v2198, v2190.1, v2189);
                                let v2227 = constructor_put_in_xmm(ctx, v2190.0);
                                let v2248 = &constructor_x64_movupd_store(ctx, v2199, v2227);
                                let v2249 = constructor_side_effect(ctx, v2248);
                                let v2250 = Some(v2249);
                                // Rule at src/isa/x64/lower.isle line 3220.
                                return v2250;
                            }
                            _ => {}
                        }
                        let v2194 = &C::type_register_class(ctx, v2193);
                        if let Some(v2195) = v2194 {
                            match v2195 {
                                &RegisterClass::Gpr {
                                    single_register: v2196,
                                } => {
                                    let v2199 = &constructor_to_amode(ctx, v2198, v2190.1, v2189);
                                    let v2200 = constructor_put_in_gpr(ctx, v2190.0);
                                    let v2201 = &constructor_x64_movrm(ctx, v2193, v2199, v2200);
                                    let v2202 = constructor_side_effect(ctx, v2201);
                                    let v2203 = Some(v2202);
                                    // Rule at src/isa/x64/lower.isle line 3155.
                                    return v2203;
                                }
                                &RegisterClass::Xmm => {
                                    let v2224 = C::ty_16(ctx, v2193);
                                    if let Some(v2225) = v2224 {
                                        let v692 = C::has_sse41(ctx);
                                        if v692 == true {
                                            let v2199 = &constructor_to_amode(ctx, v2198, v2190.1, v2189);
                                            let v2227 = constructor_put_in_xmm(ctx, v2190.0);
                                            let v2232 = &constructor_x64_pextrw_store(ctx, v2199, v2227, 0x0_u8);
                                            let v2233 = constructor_side_effect(ctx, v2232);
                                            let v2234 = Some(v2233);
                                            // Rule at src/isa/x64/lower.isle line 3187.
                                            return v2234;
                                        }
                                        let v2199 = &constructor_to_amode(ctx, v2198, v2190.1, v2189);
                                        let v2227 = constructor_put_in_xmm(ctx, v2190.0);
                                        let v2228 = constructor_bitcast_xmm_to_gpr(ctx, 0x10_u8, v2227);
                                        let v2229 = &constructor_x64_movrm(ctx, I16, v2199, v2228);
                                        let v2230 = constructor_side_effect(ctx, v2229);
                                        let v2231 = Some(v2230);
                                        // Rule at src/isa/x64/lower.isle line 3180.
                                        return v2231;
                                    }
                                    let v2235 = C::ty_32(ctx, v2193);
                                    if let Some(v2236) = v2235 {
                                        let v2199 = &constructor_to_amode(ctx, v2198, v2190.1, v2189);
                                        let v2227 = constructor_put_in_xmm(ctx, v2190.0);
                                        let v2237 = &constructor_x64_movss_store(ctx, v2199, v2227);
                                        let v2238 = constructor_side_effect(ctx, v2237);
                                        let v2239 = Some(v2238);
                                        // Rule at src/isa/x64/lower.isle line 3196.
                                        return v2239;
                                    }
                                    let v2240 = C::ty_64(ctx, v2193);
                                    if let Some(v2241) = v2240 {
                                        let v2199 = &constructor_to_amode(ctx, v2198, v2190.1, v2189);
                                        let v2227 = constructor_put_in_xmm(ctx, v2190.0);
                                        let v2242 = &constructor_x64_movsd_store(ctx, v2199, v2227);
                                        let v2243 = constructor_side_effect(ctx, v2242);
                                        let v2244 = Some(v2243);
                                        // Rule at src/isa/x64/lower.isle line 3204.
                                        return v2244;
                                    }
                                    let v2251 = C::ty_128(ctx, v2193);
                                    if let Some(v2252) = v2251 {
                                        let v2199 = &constructor_to_amode(ctx, v2198, v2190.1, v2189);
                                        let v2227 = constructor_put_in_xmm(ctx, v2190.0);
                                        let v2253 = &constructor_x64_movdqu_store(ctx, v2199, v2227);
                                        let v2254 = constructor_side_effect(ctx, v2253);
                                        let v2255 = Some(v2254);
                                        // Rule at src/isa/x64/lower.isle line 3228.
                                        return v2255;
                                    }
                                }
                                _ => {}
                            }
                        }
                    }
                }
                &Opcode::Istore8 => {
                    let v2197 = C::little_or_native_endian(ctx, v2188);
                    if let Some(v2198) = v2197 {
                        let v2190 = C::unpack_value_array_2(ctx, v2187);
                        let v2199 = &constructor_to_amode(ctx, v2198, v2190.1, v2189);
                        let v2200 = constructor_put_in_gpr(ctx, v2190.0);
                        let v2205 = &constructor_x64_movrm(ctx, I8, v2199, v2200);
                        let v2206 = constructor_side_effect(ctx, v2205);
                        let v2207 = Some(v2206);
                        // Rule at src/isa/x64/lower.isle line 3163.
                        return v2207;
                    }
                }
                &Opcode::Istore16 => {
                    let v2197 = C::little_or_native_endian(ctx, v2188);
                    if let Some(v2198) = v2197 {
                        let v2190 = C::unpack_value_array_2(ctx, v2187);
                        let v2199 = &constructor_to_amode(ctx, v2198, v2190.1, v2189);
                        let v2200 = constructor_put_in_gpr(ctx, v2190.0);
                        let v2209 = &constructor_x64_movrm(ctx, I16, v2199, v2200);
                        let v2210 = constructor_side_effect(ctx, v2209);
                        let v2211 = Some(v2210);
                        // Rule at src/isa/x64/lower.isle line 3166.
                        return v2211;
                    }
                }
                &Opcode::Istore32 => {
                    let v2197 = C::little_or_native_endian(ctx, v2188);
                    if let Some(v2198) = v2197 {
                        let v2190 = C::unpack_value_array_2(ctx, v2187);
                        let v2199 = &constructor_to_amode(ctx, v2198, v2190.1, v2189);
                        let v2200 = constructor_put_in_gpr(ctx, v2190.0);
                        let v2212 = &constructor_x64_movrm(ctx, I32, v2199, v2200);
                        let v2213 = constructor_side_effect(ctx, v2212);
                        let v2214 = Some(v2213);
                        // Rule at src/isa/x64/lower.isle line 3169.
                        return v2214;
                    }
                }
                _ => {}
            }
        }
        &InstructionData::StoreNoOffset {
            opcode: ref v2412,
            args: ref v2413,
            flags: v2414,
        } => {
            if let &Opcode::AtomicStore = v2412 {
                let v2423 = C::little_or_native_endian(ctx, v2414);
                if let Some(v2424) = v2423 {
                    let v2402 = C::has_cmpxchg16b(ctx);
                    if v2402 == true {
                        let v2415 = C::unpack_value_array_2(ctx, v2413);
                        let v2418 = C::value_type(ctx, v2415.0);
                        if v2418 == I128 {
                            let v72 = C::zero_offset(ctx);
                            let v2425 = &constructor_to_amode(ctx, v2424, v2415.1, v72);
                            let v2432 = C::put_in_regs(ctx, v2415.0);
                            let v2433 = &constructor_x64_atomic_128_store_seq(ctx, v2425, v2424, v2432);
                            let v2434 = constructor_side_effect(ctx, v2433);
                            let v2435 = Some(v2434);
                            // Rule at src/isa/x64/lower.isle line 3467.
                            return v2435;
                        }
                    }
                    let v2415 = C::unpack_value_array_2(ctx, v2413);
                    let v2418 = C::value_type(ctx, v2415.0);
                    let v2419 = C::fits_in_64(ctx, v2418);
                    if let Some(v2420) = v2419 {
                        let v2421 = C::ty_int(ctx, v2418);
                        if let Some(v2422) = v2421 {
                            let v72 = C::zero_offset(ctx);
                            let v2425 = &constructor_to_amode(ctx, v2424, v2415.1, v72);
                            let v2426 = constructor_put_in_gpr(ctx, v2415.0);
                            let v2427 = &constructor_x64_movrm(ctx, v2420, v2425, v2426);
                            let v2428 = &constructor_x64_mfence_zo(ctx);
                            let v2429 = &constructor_side_effect_concat(ctx, v2427, v2428);
                            let v2430 = constructor_side_effect(ctx, v2429);
                            let v2431 = Some(v2430);
                            // Rule at src/isa/x64/lower.isle line 3460.
                            return v2431;
                        }
                    }
                }
            }
        }
        &InstructionData::Ternary {
            opcode: ref v940,
            args: ref v941,
        } => {
            match v940 {
                &Opcode::StackSwitch => {
                    let v2581 = &C::stack_switch_model(ctx);
                    if let Some(v2582) = v2581 {
                        if let &StackSwitchModel::Basic = v2582 {
                            let v942 = C::unpack_value_array_3(ctx, v941);
                            let v1010 = constructor_put_in_gpr(ctx, v942.0);
                            let v2583 = constructor_put_in_gpr(ctx, v942.1);
                            let v2584 = constructor_put_in_gpr(ctx, v942.2);
                            let v2585 = constructor_x64_stack_switch_basic(ctx, v1010, v2583, v2584);
                            let v2586 = constructor_output_gpr(ctx, v2585);
                            let v2587 = Some(v2586);
                            // Rule at src/isa/x64/lower.isle line 3627.
                            return v2587;
                        }
                    }
                }
                &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 v942 = C::unpack_value_array_3(ctx, v941);
                                let v1515 = C::maybe_uextend(ctx, v942.0);
                                if let Some(v1516) = v1515 {
                                    let v1517 = C::def_inst(ctx, v1516);
                                    if let Some(v1518) = v1517 {
                                        let v1519 = C::inst_data_value(ctx, v1518);
                                        if let &InstructionData::FloatCompare {
                                            opcode: ref v1522,
                                            args: ref v1523,
                                            cond: ref v1524,
                                        } = &v1519.1 {
                                            if let &Opcode::Fcmp = v1522 {
                                                if let &FloatCC::LessThan = v1524 {
                                                    let v1525 = C::unpack_value_array_2(ctx, v1523);
                                                    if v942.1 == v1525.1 {
                                                        if v942.2 == v1525.0 {
                                                            let v1537 = constructor_put_in_xmm(ctx, v1525.1);
                                                            let v1538 = &C::put_in_xmm_mem_32(ctx, v1525.0);
                                                            let v1539 = constructor_x64_maxss(ctx, v1537, v1538);
                                                            let v1540 = constructor_output_xmm(ctx, v1539);
                                                            let v1541 = Some(v1540);
                                                            // Rule at src/isa/x64/lower.isle line 2270.
                                                            return v1541;
                                                        }
                                                    }
                                                    if v942.1 == v1525.0 {
                                                        if v942.2 == v1525.1 {
                                                            let v1528 = constructor_put_in_xmm(ctx, v1525.0);
                                                            let v1529 = &C::put_in_xmm_mem_32(ctx, v1525.1);
                                                            let v1530 = constructor_x64_minss(ctx, v1528, v1529);
                                                            let v1531 = constructor_output_xmm(ctx, v1530);
                                                            let v1532 = Some(v1531);
                                                            // Rule at src/isa/x64/lower.isle line 2266.
                                                            return v1532;
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            F64 => {
                                let v942 = C::unpack_value_array_3(ctx, v941);
                                let v1515 = C::maybe_uextend(ctx, v942.0);
                                if let Some(v1516) = v1515 {
                                    let v1517 = C::def_inst(ctx, v1516);
                                    if let Some(v1518) = v1517 {
                                        let v1519 = C::inst_data_value(ctx, v1518);
                                        if let &InstructionData::FloatCompare {
                                            opcode: ref v1522,
                                            args: ref v1523,
                                            cond: ref v1524,
                                        } = &v1519.1 {
                                            if let &Opcode::Fcmp = v1522 {
                                                if let &FloatCC::LessThan = v1524 {
                                                    let v1525 = C::unpack_value_array_2(ctx, v1523);
                                                    if v942.1 == v1525.1 {
                                                        if v942.2 == v1525.0 {
                                                            let v1537 = constructor_put_in_xmm(ctx, v1525.1);
                                                            let v1542 = &C::put_in_xmm_mem_64(ctx, v1525.0);
                                                            let v1543 = constructor_x64_maxsd(ctx, v1537, v1542);
                                                            let v1544 = constructor_output_xmm(ctx, v1543);
                                                            let v1545 = Some(v1544);
                                                            // Rule at src/isa/x64/lower.isle line 2272.
                                                            return v1545;
                                                        }
                                                    }
                                                    if v942.1 == v1525.0 {
                                                        if v942.2 == v1525.1 {
                                                            let v1528 = constructor_put_in_xmm(ctx, v1525.0);
                                                            let v1533 = &C::put_in_xmm_mem_64(ctx, v1525.1);
                                                            let v1534 = constructor_x64_minsd(ctx, v1528, v1533);
                                                            let v1535 = constructor_output_xmm(ctx, v1534);
                                                            let v1536 = Some(v1535);
                                                            // Rule at src/isa/x64/lower.isle line 2268.
                                                            return v1536;
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            _ => {}
                        }
                    }
                    let v942 = C::unpack_value_array_3(ctx, v941);
                    let v1512 = &constructor_is_nonzero_cmp(ctx, v942.0);
                    let v1513 = constructor_lower_select(ctx, v1512, v942.1, v942.2);
                    let v1514 = Some(v1513);
                    // Rule at src/isa/x64/lower.isle line 2198.
                    return v1514;
                }
                &Opcode::SelectSpectreGuard => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        let v2067 = &C::type_register_class(ctx, v3);
                        if let Some(v2068) = v2067 {
                            if let &RegisterClass::Gpr {
                                single_register: v2069,
                            } = v2068 {
                                if v2069 == true {
                                    let v942 = C::unpack_value_array_3(ctx, v941);
                                    let v1512 = &constructor_is_nonzero_cmp(ctx, v942.0);
                                    let v2583 = constructor_put_in_gpr(ctx, v942.1);
                                    let v2584 = constructor_put_in_gpr(ctx, v942.2);
                                    let v2599 = constructor_lower_select_spectre_gpr(ctx, v3, v1512, v2583, v2584);
                                    let v2600 = constructor_output_gpr(ctx, v2599);
                                    let v2601 = Some(v2600);
                                    // Rule at src/isa/x64/lower.isle line 3674.
                                    return v2601;
                                }
                            }
                        }
                    }
                    let v942 = C::unpack_value_array_3(ctx, v941);
                    let v1512 = &constructor_is_nonzero_cmp(ctx, v942.0);
                    let v1513 = constructor_lower_select(ctx, v1512, v942.1, v942.2);
                    let v1514 = Some(v1513);
                    // Rule at src/isa/x64/lower.isle line 3668.
                    return v1514;
                }
                &Opcode::Bitselect => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        let v275 = C::ty_scalar_float(ctx, v3);
                        if let Some(v276) = v275 {
                            let v942 = C::unpack_value_array_3(ctx, v941);
                            let v946 = constructor_put_in_xmm(ctx, v942.0);
                            let v947 = constructor_put_in_xmm(ctx, v942.1);
                            let v1021 = constructor_put_in_xmm(ctx, v942.2);
                            let v1022 = &C::xmm_to_xmm_mem_128(ctx, v947);
                            let v1023 = constructor_sse_and(ctx, v276, v946, v1022);
                            let v1024 = constructor_vector_all_ones(ctx);
                            let v1025 = &C::xmm_to_xmm_mem_128(ctx, v1024);
                            let v1026 = constructor_x64_xor_vector(ctx, v276, v946, v1025);
                            let v1027 = &C::xmm_to_xmm_mem_128(ctx, v1021);
                            let v1028 = constructor_sse_and(ctx, v276, v1026, v1027);
                            let v1029 = &C::xmm_to_xmm_mem_128(ctx, v1028);
                            let v1030 = constructor_sse_or(ctx, v276, v1023, v1029);
                            let v1031 = constructor_output_xmm(ctx, v1030);
                            let v1032 = Some(v1031);
                            // Rule at src/isa/x64/lower.isle line 1571.
                            return v1032;
                        }
                        let v1008 = C::ty_int_ref_scalar_64_extract(ctx, v3);
                        if let Some(v1009) = v1008 {
                            let v942 = C::unpack_value_array_3(ctx, v941);
                            let v1010 = constructor_put_in_gpr(ctx, v942.0);
                            let v1011 = &constructor_put_in_gpr_mem_imm(ctx, v942.1);
                            let v1012 = constructor_x64_and(ctx, v1009, v1010, v1011);
                            let v1013 = constructor_put_in_gpr(ctx, v942.0);
                            let v1014 = constructor_x64_not(ctx, v1009, v1013);
                            let v1015 = &constructor_put_in_gpr_mem_imm(ctx, v942.2);
                            let v1016 = constructor_x64_and(ctx, v1009, v1014, v1015);
                            let v1017 = &C::gpr_to_gpr_mem_imm(ctx, v1016);
                            let v1018 = constructor_x64_or(ctx, v1009, v1012, v1017);
                            let v1019 = constructor_output_gpr(ctx, v1018);
                            let v1020 = Some(v1019);
                            // Rule at src/isa/x64/lower.isle line 1566.
                            return v1020;
                        }
                        match v3 {
                            I128 => {
                                let v942 = C::unpack_value_array_3(ctx, v941);
                                let v999 = C::put_in_regs(ctx, v942.0);
                                let v1000 = C::put_in_regs(ctx, v942.1);
                                let v1001 = constructor_and_i128(ctx, v999, v1000);
                                let v1002 = constructor_not_i128(ctx, v942.0);
                                let v1003 = C::put_in_regs(ctx, v942.2);
                                let v1004 = constructor_and_i128(ctx, v1002, v1003);
                                let v1005 = constructor_or_i128(ctx, v1001, v1004);
                                let v1006 = C::output(ctx, v1005);
                                let v1007 = Some(v1006);
                                // Rule at src/isa/x64/lower.isle line 1561.
                                return v1007;
                            }
                            F32X4 => {
                                let v942 = C::unpack_value_array_3(ctx, v941);
                                let v964 = C::def_inst(ctx, v942.0);
                                if let Some(v965) = v964 {
                                    let v966 = C::inst_data_value(ctx, v965);
                                    if let &InstructionData::LoadNoOffset {
                                        opcode: ref v969,
                                        arg: v970,
                                        flags: v971,
                                    } = &v966.1 {
                                        if let &Opcode::Bitcast = v969 {
                                            let v972 = C::def_inst(ctx, v970);
                                            if let Some(v973) = v972 {
                                                let v974 = C::inst_data_value(ctx, v973);
                                                if let &InstructionData::FloatCompare {
                                                    opcode: ref v977,
                                                    args: ref v978,
                                                    cond: ref v979,
                                                } = &v974.1 {
                                                    if let &Opcode::Fcmp = v977 {
                                                        if let &FloatCC::LessThan = v979 {
                                                            let v980 = C::unpack_value_array_2(ctx, v978);
                                                            if v942.1 == v980.1 {
                                                                if v942.2 == v980.0 {
                                                                    let v991 = constructor_put_in_xmm(ctx, v980.1);
                                                                    let v992 = &C::put_in_xmm_mem_128(ctx, v980.0);
                                                                    let v993 = constructor_x64_maxps(ctx, v991, v992);
                                                                    let v994 = constructor_output_xmm(ctx, v993);
                                                                    let v995 = Some(v994);
                                                                    // Rule at src/isa/x64/lower.isle line 1554.
                                                                    return v995;
                                                                }
                                                            }
                                                            if v942.1 == v980.0 {
                                                                if v942.2 == v980.1 {
                                                                    let v983 = constructor_put_in_xmm(ctx, v980.0);
                                                                    let v984 = &C::put_in_xmm_mem_128(ctx, v980.1);
                                                                    let v985 = constructor_x64_minps(ctx, v983, v984);
                                                                    let v986 = constructor_output_xmm(ctx, v985);
                                                                    let v987 = Some(v986);
                                                                    // Rule at src/isa/x64/lower.isle line 1549.
                                                                    return v987;
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            F64X2 => {
                                let v942 = C::unpack_value_array_3(ctx, v941);
                                let v964 = C::def_inst(ctx, v942.0);
                                if let Some(v965) = v964 {
                                    let v966 = C::inst_data_value(ctx, v965);
                                    if let &InstructionData::LoadNoOffset {
                                        opcode: ref v969,
                                        arg: v970,
                                        flags: v971,
                                    } = &v966.1 {
                                        if let &Opcode::Bitcast = v969 {
                                            let v972 = C::def_inst(ctx, v970);
                                            if let Some(v973) = v972 {
                                                let v974 = C::inst_data_value(ctx, v973);
                                                if let &InstructionData::FloatCompare {
                                                    opcode: ref v977,
                                                    args: ref v978,
                                                    cond: ref v979,
                                                } = &v974.1 {
                                                    if let &Opcode::Fcmp = v977 {
                                                        if let &FloatCC::LessThan = v979 {
                                                            let v980 = C::unpack_value_array_2(ctx, v978);
                                                            if v942.1 == v980.1 {
                                                                if v942.2 == v980.0 {
                                                                    let v991 = constructor_put_in_xmm(ctx, v980.1);
                                                                    let v992 = &C::put_in_xmm_mem_128(ctx, v980.0);
                                                                    let v996 = constructor_x64_maxpd(ctx, v991, v992);
                                                                    let v997 = constructor_output_xmm(ctx, v996);
                                                                    let v998 = Some(v997);
                                                                    // Rule at src/isa/x64/lower.isle line 1556.
                                                                    return v998;
                                                                }
                                                            }
                                                            if v942.1 == v980.0 {
                                                                if v942.2 == v980.1 {
                                                                    let v983 = constructor_put_in_xmm(ctx, v980.0);
                                                                    let v984 = &C::put_in_xmm_mem_128(ctx, v980.1);
                                                                    let v988 = constructor_x64_minpd(ctx, v983, v984);
                                                                    let v989 = constructor_output_xmm(ctx, v988);
                                                                    let v990 = Some(v989);
                                                                    // Rule at src/isa/x64/lower.isle line 1551.
                                                                    return v990;
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            _ => {}
                        }
                        let v91 = C::multi_lane(ctx, v3);
                        if let Some(v92) = v91 {
                            let v692 = C::has_sse41(ctx);
                            if v692 == true {
                                let v942 = C::unpack_value_array_3(ctx, v941);
                                let v956 = constructor_all_ones_or_all_zeros(ctx, v942.0);
                                if let Some(v957) = v956 {
                                    let v958 = constructor_put_in_xmm(ctx, v942.2);
                                    let v959 = &C::put_in_xmm_mem_128(ctx, v942.1);
                                    let v960 = constructor_put_in_xmm(ctx, v942.0);
                                    let v961 = constructor_x64_pblendvb(ctx, v958, v959, v960);
                                    let v962 = constructor_output_xmm(ctx, v961);
                                    let v963 = Some(v962);
                                    // Rule at src/isa/x64/lower.isle line 1527.
                                    return v963;
                                }
                            }
                            let v942 = C::unpack_value_array_3(ctx, v941);
                            let v946 = constructor_put_in_xmm(ctx, v942.0);
                            let v947 = constructor_put_in_xmm(ctx, v942.1);
                            let v948 = &C::xmm_to_xmm_mem_128(ctx, v946);
                            let v949 = constructor_sse_and(ctx, v3, v947, v948);
                            let v950 = &C::put_in_xmm_mem_128(ctx, v942.2);
                            let v951 = constructor_sse_and_not(ctx, v3, v946, v950);
                            let v952 = &C::xmm_to_xmm_mem_128(ctx, v949);
                            let v953 = constructor_sse_or(ctx, v3, v951, v952);
                            let v954 = constructor_output_xmm(ctx, v953);
                            let v955 = Some(v954);
                            // Rule at src/isa/x64/lower.isle line 1513.
                            return v955;
                        }
                    }
                }
                &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 v692 = C::has_sse41(ctx);
                                if v692 == true {
                                    let v942 = C::unpack_value_array_3(ctx, v941);
                                    let v958 = constructor_put_in_xmm(ctx, v942.2);
                                    let v959 = &C::put_in_xmm_mem_128(ctx, v942.1);
                                    let v960 = constructor_put_in_xmm(ctx, v942.0);
                                    let v961 = constructor_x64_pblendvb(ctx, v958, v959, v960);
                                    let v962 = constructor_output_xmm(ctx, v961);
                                    let v963 = Some(v962);
                                    // Rule at src/isa/x64/lower.isle line 1586.
                                    return v963;
                                }
                            }
                            I32X4 => {
                                let v692 = C::has_sse41(ctx);
                                if v692 == true {
                                    let v942 = C::unpack_value_array_3(ctx, v941);
                                    let v958 = constructor_put_in_xmm(ctx, v942.2);
                                    let v959 = &C::put_in_xmm_mem_128(ctx, v942.1);
                                    let v960 = constructor_put_in_xmm(ctx, v942.0);
                                    let v1033 = constructor_x64_blendvps(ctx, v958, v959, v960);
                                    let v1034 = constructor_output_xmm(ctx, v1033);
                                    let v1035 = Some(v1034);
                                    // Rule at src/isa/x64/lower.isle line 1591.
                                    return v1035;
                                }
                            }
                            I64X2 => {
                                let v692 = C::has_sse41(ctx);
                                if v692 == true {
                                    let v942 = C::unpack_value_array_3(ctx, v941);
                                    let v958 = constructor_put_in_xmm(ctx, v942.2);
                                    let v959 = &C::put_in_xmm_mem_128(ctx, v942.1);
                                    let v960 = constructor_put_in_xmm(ctx, v942.0);
                                    let v1036 = constructor_x64_blendvpd(ctx, v958, v959, v960);
                                    let v1037 = constructor_output_xmm(ctx, v1036);
                                    let v1038 = Some(v1037);
                                    // Rule at src/isa/x64/lower.isle line 1596.
                                    return v1038;
                                }
                            }
                            _ => {}
                        }
                    }
                }
                &Opcode::Fma => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v2053 = C::use_fma(ctx);
                        if v2053 == true {
                            let v942 = C::unpack_value_array_3(ctx, v941);
                            let v2057 = C::def_inst(ctx, v942.2);
                            if let Some(v2058) = v2057 {
                                let v2059 = C::inst_data_value(ctx, v2058);
                                if let &InstructionData::Unary {
                                    opcode: ref v2062,
                                    arg: v2063,
                                } = &v2059.1 {
                                    if let &Opcode::Fneg = v2062 {
                                        let v3 = C::value_type(ctx, v2);
                                        let v2064 = constructor_fmsub(ctx, v3, v942.0, v942.1, v2063);
                                        let v2065 = constructor_output_xmm(ctx, v2064);
                                        let v2066 = Some(v2065);
                                        // Rule at src/isa/x64/lower.isle line 3034.
                                        return v2066;
                                    }
                                }
                            }
                            let v3 = C::value_type(ctx, v2);
                            let v2054 = constructor_fmadd(ctx, v3, v942.0, v942.1, v942.2);
                            let v2055 = constructor_output_xmm(ctx, v2054);
                            let v2056 = Some(v2055);
                            // Rule at src/isa/x64/lower.isle line 3005.
                            return v2056;
                        }
                        let v3 = C::value_type(ctx, v2);
                        match v3 {
                            F32 => {
                                let v942 = C::unpack_value_array_3(ctx, v941);
                                let v1985 = C::put_in_reg(ctx, v942.0);
                                let v1986 = C::put_in_reg(ctx, v942.1);
                                let v1987 = C::put_in_reg(ctx, v942.2);
                                let v1988 = C::libcall_3(ctx, &LibCall::FmaF32, v1985, v1986, v1987);
                                let v1989 = constructor_output_reg(ctx, v1988);
                                let v1990 = Some(v1989);
                                // Rule at src/isa/x64/lower.isle line 2960.
                                return v1990;
                            }
                            F64 => {
                                let v942 = C::unpack_value_array_3(ctx, v941);
                                let v1985 = C::put_in_reg(ctx, v942.0);
                                let v1986 = C::put_in_reg(ctx, v942.1);
                                let v1987 = C::put_in_reg(ctx, v942.2);
                                let v1992 = C::libcall_3(ctx, &LibCall::FmaF64, v1985, v1986, v1987);
                                let v1993 = constructor_output_reg(ctx, v1992);
                                let v1994 = Some(v1993);
                                // Rule at src/isa/x64/lower.isle line 2962.
                                return v1994;
                            }
                            F32X4 => {
                                let v942 = C::unpack_value_array_3(ctx, v941);
                                let v946 = constructor_put_in_xmm(ctx, v942.0);
                                let v947 = constructor_put_in_xmm(ctx, v942.1);
                                let v1021 = constructor_put_in_xmm(ctx, v942.2);
                                let v1995 = C::xmm_to_reg(ctx, v946);
                                let v1996 = C::xmm_to_reg(ctx, v947);
                                let v1997 = C::xmm_to_reg(ctx, v1021);
                                let v1998 = C::libcall_3(ctx, &LibCall::FmaF32, v1995, v1996, v1997);
                                let v1999 = C::xmm_new(ctx, v1998);
                                let v2000 = &C::xmm_to_xmm_mem_128(ctx, v946);
                                let v2001 = constructor_x64_pshufd(ctx, v2000, 0x1_u8);
                                let v2002 = C::xmm_to_reg(ctx, v2001);
                                let v2003 = &C::xmm_to_xmm_mem_128(ctx, v947);
                                let v2004 = constructor_x64_pshufd(ctx, v2003, 0x1_u8);
                                let v2005 = C::xmm_to_reg(ctx, v2004);
                                let v2006 = &C::xmm_to_xmm_mem_128(ctx, v1021);
                                let v2007 = constructor_x64_pshufd(ctx, v2006, 0x1_u8);
                                let v2008 = C::xmm_to_reg(ctx, v2007);
                                let v2009 = C::libcall_3(ctx, &LibCall::FmaF32, v2002, v2005, v2008);
                                let v2010 = C::xmm_new(ctx, v2009);
                                let v2011 = &C::xmm_to_xmm_mem_128(ctx, v946);
                                let v2013 = constructor_x64_pshufd(ctx, v2011, 0x2_u8);
                                let v2014 = C::xmm_to_reg(ctx, v2013);
                                let v2015 = &C::xmm_to_xmm_mem_128(ctx, v947);
                                let v2016 = constructor_x64_pshufd(ctx, v2015, 0x2_u8);
                                let v2017 = C::xmm_to_reg(ctx, v2016);
                                let v2018 = &C::xmm_to_xmm_mem_128(ctx, v1021);
                                let v2019 = constructor_x64_pshufd(ctx, v2018, 0x2_u8);
                                let v2020 = C::xmm_to_reg(ctx, v2019);
                                let v2021 = C::libcall_3(ctx, &LibCall::FmaF32, v2014, v2017, v2020);
                                let v2022 = C::xmm_new(ctx, v2021);
                                let v2023 = &C::xmm_to_xmm_mem_128(ctx, v946);
                                let v2024 = constructor_x64_pshufd(ctx, v2023, 0x3_u8);
                                let v2025 = C::xmm_to_reg(ctx, v2024);
                                let v2026 = &C::xmm_to_xmm_mem_128(ctx, v947);
                                let v2027 = constructor_x64_pshufd(ctx, v2026, 0x3_u8);
                                let v2028 = C::xmm_to_reg(ctx, v2027);
                                let v2029 = &C::xmm_to_xmm_mem_128(ctx, v1021);
                                let v2030 = constructor_x64_pshufd(ctx, v2029, 0x3_u8);
                                let v2031 = C::xmm_to_reg(ctx, v2030);
                                let v2032 = C::libcall_3(ctx, &LibCall::FmaF32, v2025, v2028, v2031);
                                let v2033 = C::xmm_new(ctx, v2032);
                                let v2034 = constructor_f32x4_insertlane(ctx, v1999, v2010, 0x1_u8);
                                let v2035 = constructor_f32x4_insertlane(ctx, v2034, v2022, 0x2_u8);
                                let v2036 = constructor_f32x4_insertlane(ctx, v2035, v2033, 0x3_u8);
                                let v2037 = constructor_output_xmm(ctx, v2036);
                                let v2038 = Some(v2037);
                                // Rule at src/isa/x64/lower.isle line 2965.
                                return v2038;
                            }
                            F64X2 => {
                                let v942 = C::unpack_value_array_3(ctx, v941);
                                let v946 = constructor_put_in_xmm(ctx, v942.0);
                                let v947 = constructor_put_in_xmm(ctx, v942.1);
                                let v1021 = constructor_put_in_xmm(ctx, v942.2);
                                let v1995 = C::xmm_to_reg(ctx, v946);
                                let v1996 = C::xmm_to_reg(ctx, v947);
                                let v1997 = C::xmm_to_reg(ctx, v1021);
                                let v2039 = C::libcall_3(ctx, &LibCall::FmaF64, v1995, v1996, v1997);
                                let v2040 = C::xmm_new(ctx, v2039);
                                let v2000 = &C::xmm_to_xmm_mem_128(ctx, v946);
                                let v2042 = constructor_x64_pshufd(ctx, v2000, 0xee_u8);
                                let v2043 = C::xmm_to_reg(ctx, v2042);
                                let v2003 = &C::xmm_to_xmm_mem_128(ctx, v947);
                                let v2044 = constructor_x64_pshufd(ctx, v2003, 0xee_u8);
                                let v2045 = C::xmm_to_reg(ctx, v2044);
                                let v2006 = &C::xmm_to_xmm_mem_128(ctx, v1021);
                                let v2046 = constructor_x64_pshufd(ctx, v2006, 0xee_u8);
                                let v2047 = C::xmm_to_reg(ctx, v2046);
                                let v2048 = C::libcall_3(ctx, &LibCall::FmaF64, v2043, v2045, v2047);
                                let v2049 = C::xmm_new(ctx, v2048);
                                let v2050 = constructor_x64_movlhps(ctx, v2040, v2049);
                                let v2051 = constructor_output_xmm(ctx, v2050);
                                let v2052 = Some(v2051);
                                // Rule at src/isa/x64/lower.isle line 2989.
                                return v2052;
                            }
                            _ => {}
                        }
                    }
                }
                _ => {}
            }
        }
        &InstructionData::TernaryImm8 {
            opcode: ref v1039,
            args: ref v1040,
            imm: v1041,
        } => {
            if let &Opcode::Insertlane = v1039 {
                let v692 = C::has_sse41(ctx);
                if v692 == true {
                    let v1046 = C::u8_from_uimm8(ctx, v1041);
                    if v1046 == 0x1_u8 {
                        let v1042 = C::unpack_value_array_2(ctx, v1040);
                        let v1130 = C::def_inst(ctx, v1042.0);
                        if let Some(v1131) = v1130 {
                            let v1132 = C::first_result(ctx, v1131);
                            if let Some(v1133) = v1132 {
                                let v1134 = C::value_type(ctx, v1133);
                                if v1134 == I64X2 {
                                    let v1135 = C::inst_data_value(ctx, v1131);
                                    if let &InstructionData::Unary {
                                        opcode: ref v1138,
                                        arg: v1139,
                                    } = &v1135.1 {
                                        if let &Opcode::Splat = v1138 {
                                            let v1141 = constructor_put_in_gpr(ctx, v1139);
                                            let v1142 = constructor_bitcast_gpr_to_xmm(ctx, 0x40_u8, v1141);
                                            let v1143 = &constructor_put_in_gpr_mem(ctx, v1042.1);
                                            let v1145 = constructor_x64_pinsrq(ctx, v1142, v1143, 0x1_u8);
                                            let v1146 = constructor_output_xmm(ctx, v1145);
                                            let v1147 = Some(v1146);
                                            // Rule at src/isa/x64/lower.isle line 1698.
                                            return v1147;
                                        }
                                    }
                                }
                            }
                        }
                    }
                    let v1042 = C::unpack_value_array_2(ctx, v1040);
                    let v1045 = C::value_type(ctx, v1042.0);
                    match v1045 {
                        I8X16 => {
                            let v1052 = &C::sinkable_load_exact(ctx, v1042.1);
                            if let Some(v1053) = v1052 {
                                let v1047 = constructor_put_in_xmm(ctx, v1042.0);
                                let v1054 = &constructor_sink_load_to_gpr_mem(ctx, v1053);
                                let v1055 = constructor_x64_pinsrb(ctx, v1047, v1054, v1046);
                                let v1056 = constructor_output_xmm(ctx, v1055);
                                let v1057 = Some(v1056);
                                // Rule at src/isa/x64/lower.isle line 1606.
                                return v1057;
                            }
                            let v1047 = constructor_put_in_xmm(ctx, v1042.0);
                            let v1048 = &constructor_put_in_gpr_mem(ctx, v1042.1);
                            let v1049 = constructor_x64_pinsrb(ctx, v1047, v1048, v1046);
                            let v1050 = constructor_output_xmm(ctx, v1049);
                            let v1051 = Some(v1050);
                            // Rule at src/isa/x64/lower.isle line 1603.
                            return v1051;
                        }
                        I32X4 => {
                            let v1047 = constructor_put_in_xmm(ctx, v1042.0);
                            let v1048 = &constructor_put_in_gpr_mem(ctx, v1042.1);
                            let v1086 = constructor_x64_pinsrd(ctx, v1047, v1048, v1046);
                            let v1087 = constructor_output_xmm(ctx, v1086);
                            let v1088 = Some(v1087);
                            // Rule at src/isa/x64/lower.isle line 1658.
                            return v1088;
                        }
                        I64X2 => {
                            let v1047 = constructor_put_in_xmm(ctx, v1042.0);
                            let v1048 = &constructor_put_in_gpr_mem(ctx, v1042.1);
                            let v1118 = constructor_x64_pinsrq(ctx, v1047, v1048, v1046);
                            let v1119 = constructor_output_xmm(ctx, v1118);
                            let v1120 = Some(v1119);
                            // Rule at src/isa/x64/lower.isle line 1687.
                            return v1120;
                        }
                        F32X4 => {
                            let v1148 = &C::sinkable_load_32(ctx, v1042.1);
                            if let Some(v1149) = v1148 {
                                let v1047 = constructor_put_in_xmm(ctx, v1042.0);
                                let v1150 = &C::sink_load_32_to_xmm_mem_32(ctx, v1149);
                                let v1151 = C::sse_insertps_lane_imm(ctx, v1046);
                                let v1152 = constructor_x64_insertps(ctx, v1047, v1150, v1151);
                                let v1153 = constructor_output_xmm(ctx, v1152);
                                let v1154 = Some(v1153);
                                // Rule at src/isa/x64/lower.isle line 1704.
                                return v1154;
                            }
                        }
                        _ => {}
                    }
                }
                let v1042 = C::unpack_value_array_2(ctx, v1040);
                let v1045 = C::value_type(ctx, v1042.0);
                match v1045 {
                    I8X16 => {
                        let v1047 = constructor_put_in_xmm(ctx, v1042.0);
                        let v1046 = C::u8_from_uimm8(ctx, v1041);
                        let v1058 = C::insert_i8x16_lane_hole(ctx, v1046);
                        let v1059 = &C::const_to_xmm_mem_128(ctx, v1058);
                        let v1060 = constructor_x64_pand(ctx, v1047, v1059);
                        let v1062 = &constructor_put_in_gpr_mem(ctx, v1042.1);
                        let v1063 = constructor_x64_movzx(ctx, &ExtMode::BL, v1062);
                        let v1065 = C::u8_and(ctx, v1046, 0x3_u8);
                        let v1067 = C::u8_wrapping_shl(ctx, v1065, 0x3_u32);
                        let v1068 = constructor_x64_shll_mi(ctx, v1063, v1067);
                        let v1069 = &C::gpr_to_gpr_mem_32(ctx, v1068);
                        let v1070 = constructor_x64_movd_to_xmm(ctx, v1069);
                        let v1071 = &C::xmm_to_xmm_mem_128(ctx, v1070);
                        let v1073 = C::u8_wrapping_shr(ctx, v1046, 0x2_u32);
                        let v1074 = constructor_insert_i8x16_lane_pshufd_imm(ctx, v1073);
                        let v1075 = constructor_x64_pshufd(ctx, v1071, v1074);
                        let v1076 = &C::xmm_to_xmm_mem_128(ctx, v1075);
                        let v1077 = constructor_x64_por(ctx, v1060, v1076);
                        let v1078 = constructor_output_xmm(ctx, v1077);
                        let v1079 = Some(v1078);
                        // Rule at src/isa/x64/lower.isle line 1634.
                        return v1079;
                    }
                    I16X8 => {
                        let v1052 = &C::sinkable_load_exact(ctx, v1042.1);
                        if let Some(v1053) = v1052 {
                            let v1047 = constructor_put_in_xmm(ctx, v1042.0);
                            let v1054 = &constructor_sink_load_to_gpr_mem(ctx, v1053);
                            let v1046 = C::u8_from_uimm8(ctx, v1041);
                            let v1083 = constructor_x64_pinsrw(ctx, v1047, v1054, v1046);
                            let v1084 = constructor_output_xmm(ctx, v1083);
                            let v1085 = Some(v1084);
                            // Rule at src/isa/x64/lower.isle line 1654.
                            return v1085;
                        }
                        let v1047 = constructor_put_in_xmm(ctx, v1042.0);
                        let v1048 = &constructor_put_in_gpr_mem(ctx, v1042.1);
                        let v1046 = C::u8_from_uimm8(ctx, v1041);
                        let v1080 = constructor_x64_pinsrw(ctx, v1047, v1048, v1046);
                        let v1081 = constructor_output_xmm(ctx, v1080);
                        let v1082 = Some(v1081);
                        // Rule at src/isa/x64/lower.isle line 1652.
                        return v1082;
                    }
                    I32X4 => {
                        let v1046 = C::u8_from_uimm8(ctx, v1041);
                        match v1046 {
                            0x0_u8 => {
                                let v1047 = constructor_put_in_xmm(ctx, v1042.0);
                                let v1089 = &C::put_in_gpr_mem_32(ctx, v1042.1);
                                let v1090 = constructor_x64_movd_to_xmm(ctx, v1089);
                                let v1091 = constructor_x64_movss_regmove(ctx, v1047, v1090);
                                let v1092 = constructor_output_xmm(ctx, v1091);
                                let v1093 = Some(v1092);
                                // Rule at src/isa/x64/lower.isle line 1662.
                                return v1093;
                            }
                            0x1_u8 => {
                                let v1094 = &C::put_in_gpr_mem_32(ctx, v1042.1);
                                let v1095 = constructor_x64_movd_to_xmm(ctx, v1094);
                                let v1096 = constructor_put_in_xmm(ctx, v1042.0);
                                let v1097 = &C::xmm_to_xmm_mem_128(ctx, v1096);
                                let v1098 = constructor_x64_punpcklqdq(ctx, v1095, v1097);
                                let v1099 = &C::xmm_to_xmm_mem_128(ctx, v1096);
                                let v1101 = constructor_x64_shufps(ctx, v1098, v1099, 0xe2_u8);
                                let v1102 = constructor_output_xmm(ctx, v1101);
                                let v1103 = Some(v1102);
                                // Rule at src/isa/x64/lower.isle line 1667.
                                return v1103;
                            }
                            0x2_u8 => {
                                let v1094 = &C::put_in_gpr_mem_32(ctx, v1042.1);
                                let v1095 = constructor_x64_movd_to_xmm(ctx, v1094);
                                let v1096 = constructor_put_in_xmm(ctx, v1042.0);
                                let v1097 = &C::xmm_to_xmm_mem_128(ctx, v1096);
                                let v1105 = constructor_x64_shufps(ctx, v1095, v1097, 0x30_u8);
                                let v1106 = &C::xmm_to_xmm_mem_128(ctx, v1105);
                                let v1108 = constructor_x64_shufps(ctx, v1096, v1106, 0x84_u8);
                                let v1109 = constructor_output_xmm(ctx, v1108);
                                let v1110 = Some(v1109);
                                // Rule at src/isa/x64/lower.isle line 1674.
                                return v1110;
                            }
                            0x3_u8 => {
                                let v1094 = &C::put_in_gpr_mem_32(ctx, v1042.1);
                                let v1095 = constructor_x64_movd_to_xmm(ctx, v1094);
                                let v1096 = constructor_put_in_xmm(ctx, v1042.0);
                                let v1097 = &C::xmm_to_xmm_mem_128(ctx, v1096);
                                let v1112 = constructor_x64_shufps(ctx, v1095, v1097, 0xe4_u8);
                                let v1113 = &C::xmm_to_xmm_mem_128(ctx, v1112);
                                let v1115 = constructor_x64_shufps(ctx, v1096, v1113, 0x24_u8);
                                let v1116 = constructor_output_xmm(ctx, v1115);
                                let v1117 = Some(v1116);
                                // Rule at src/isa/x64/lower.isle line 1681.
                                return v1117;
                            }
                            _ => {}
                        }
                    }
                    I64X2 => {
                        let v1046 = C::u8_from_uimm8(ctx, v1041);
                        match v1046 {
                            0x0_u8 => {
                                let v1047 = constructor_put_in_xmm(ctx, v1042.0);
                                let v1121 = &C::put_in_gpr_mem_64(ctx, v1042.1);
                                let v1122 = constructor_x64_movq_to_xmm(ctx, v1121);
                                let v1123 = constructor_x64_movsd_regmove(ctx, v1047, v1122);
                                let v1124 = constructor_output_xmm(ctx, v1123);
                                let v1125 = Some(v1124);
                                // Rule at src/isa/x64/lower.isle line 1690.
                                return v1125;
                            }
                            0x1_u8 => {
                                let v1047 = constructor_put_in_xmm(ctx, v1042.0);
                                let v1121 = &C::put_in_gpr_mem_64(ctx, v1042.1);
                                let v1122 = constructor_x64_movq_to_xmm(ctx, v1121);
                                let v1126 = &C::xmm_to_xmm_mem_128(ctx, v1122);
                                let v1127 = constructor_x64_punpcklqdq(ctx, v1047, v1126);
                                let v1128 = constructor_output_xmm(ctx, v1127);
                                let v1129 = Some(v1128);
                                // Rule at src/isa/x64/lower.isle line 1692.
                                return v1129;
                            }
                            _ => {}
                        }
                    }
                    F32X4 => {
                        let v1047 = constructor_put_in_xmm(ctx, v1042.0);
                        let v1155 = constructor_put_in_xmm(ctx, v1042.1);
                        let v1046 = C::u8_from_uimm8(ctx, v1041);
                        let v1156 = constructor_f32x4_insertlane(ctx, v1047, v1155, v1046);
                        let v1157 = constructor_output_xmm(ctx, v1156);
                        let v1158 = Some(v1157);
                        // Rule at src/isa/x64/lower.isle line 1707.
                        return v1158;
                    }
                    F64X2 => {
                        let v1046 = C::u8_from_uimm8(ctx, v1041);
                        match v1046 {
                            0x0_u8 => {
                                let v1047 = constructor_put_in_xmm(ctx, v1042.0);
                                let v1155 = constructor_put_in_xmm(ctx, v1042.1);
                                let v1159 = constructor_x64_movsd_regmove(ctx, v1047, v1155);
                                let v1160 = constructor_output_xmm(ctx, v1159);
                                let v1161 = Some(v1160);
                                // Rule at src/isa/x64/lower.isle line 1752.
                                return v1161;
                            }
                            0x1_u8 => {
                                let v1047 = constructor_put_in_xmm(ctx, v1042.0);
                                let v1155 = constructor_put_in_xmm(ctx, v1042.1);
                                let v1162 = constructor_x64_movlhps(ctx, v1047, v1155);
                                let v1163 = constructor_output_xmm(ctx, v1162);
                                let v1164 = Some(v1163);
                                // Rule at src/isa/x64/lower.isle line 1760.
                                return v1164;
                            }
                            _ => {}
                        }
                    }
                    _ => {}
                }
            }
        }
        &InstructionData::Trap {
            opcode: ref v1236,
            code: ref v1237,
        } => {
            if let &Opcode::Trap = v1236 {
                let v1238 = &constructor_x64_ud2_zo(ctx, v1237);
                let v1239 = constructor_side_effect(ctx, v1238);
                let v1240 = Some(v1239);
                // Rule at src/isa/x64/lower.isle line 1912.
                return v1240;
            }
        }
        &InstructionData::Unary {
            opcode: ref v589,
            arg: v590,
        } => {
            match v589 {
                &Opcode::Splat => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        let v91 = C::multi_lane(ctx, v3);
                        if let Some(v92) = v91 {
                            match v92.0 {
                                0x20_u32 => {
                                    if v92.1 == 0x4_u32 {
                                        let v3439 = &C::sinkable_load_32(ctx, v590);
                                        if let Some(v3440) = v3439 {
                                            let v3441 = C::has_avx(ctx);
                                            if v3441 == true {
                                                let v3442 = &C::sink_load_32_to_xmm_mem_32(ctx, v3440);
                                                let v3443 = constructor_x64_vbroadcastss(ctx, v3442);
                                                let v3444 = constructor_output_xmm(ctx, v3443);
                                                let v3445 = Some(v3444);
                                                // Rule at src/isa/x64/lower.isle line 4940.
                                                return v3445;
                                            }
                                        }
                                        let v3350 = &C::sinkable_load(ctx, v590);
                                        if let Some(v3351) = v3350 {
                                            let v3354 = &C::sink_load(ctx, v3351);
                                            let v3355 = constructor_x64_movss_load(ctx, v3354);
                                            let v3435 = &C::xmm_to_xmm_mem_128(ctx, v3355);
                                            let v3436 = constructor_x64_shufps(ctx, v3355, v3435, 0x0_u8);
                                            let v3437 = constructor_output_xmm(ctx, v3436);
                                            let v3438 = Some(v3437);
                                            // Rule at src/isa/x64/lower.isle line 4937.
                                            return v3438;
                                        }
                                    }
                                }
                                0x40_u32 => {
                                    if v92.1 == 0x2_u32 {
                                        let v3455 = &C::sinkable_load_64(ctx, v590);
                                        if let Some(v3456) = v3455 {
                                            let v3457 = C::has_sse3(ctx);
                                            if v3457 == true {
                                                let v3458 = &C::sink_load_64_to_xmm_mem_64(ctx, v3456);
                                                let v3459 = constructor_x64_movddup(ctx, v3458);
                                                let v3460 = constructor_output_xmm(ctx, v3459);
                                                let v3461 = Some(v3460);
                                                // Rule at src/isa/x64/lower.isle line 4951.
                                                return v3461;
                                            }
                                        }
                                    }
                                }
                                _ => {}
                            }
                        }
                        match v3 {
                            I8X16 => {
                                let v3380 = C::use_avx2(ctx);
                                if v3380 == true {
                                    let v3392 = &C::sinkable_load_8(ctx, v590);
                                    if let Some(v3393) = v3392 {
                                        let v3394 = &C::sink_load_8_to_xmm_mem_8(ctx, v3393);
                                        let v3395 = constructor_x64_vpbroadcastb(ctx, v3394);
                                        let v3396 = constructor_output_xmm(ctx, v3395);
                                        let v3397 = Some(v3396);
                                        // Rule at src/isa/x64/lower.isle line 4888.
                                        return v3397;
                                    }
                                }
                                let v692 = C::has_sse41(ctx);
                                if v692 == true {
                                    let v785 = C::has_ssse3(ctx);
                                    if v785 == true {
                                        let v3385 = &C::sinkable_load_exact(ctx, v590);
                                        if let Some(v3386) = v3385 {
                                            let v2113 = constructor_xmm_uninit_value(ctx);
                                            let v3387 = &constructor_sink_load_to_gpr_mem(ctx, v3386);
                                            let v3388 = constructor_x64_pinsrb(ctx, v2113, v3387, 0x0_u8);
                                            let v1441 = constructor_xmm_zero(ctx, I8X16);
                                            let v1442 = &C::xmm_to_xmm_mem_128(ctx, v1441);
                                            let v3389 = constructor_x64_pshufb(ctx, v3388, v1442);
                                            let v3390 = constructor_output_xmm(ctx, v3389);
                                            let v3391 = Some(v3390);
                                            // Rule at src/isa/x64/lower.isle line 4884.
                                            return v3391;
                                        }
                                    }
                                }
                                if v3380 == true {
                                    let v591 = constructor_put_in_gpr(ctx, v590);
                                    let v3374 = constructor_bitcast_gpr_to_xmm(ctx, 0x20_u8, v591);
                                    let v3381 = &C::xmm_to_xmm_mem_8(ctx, v3374);
                                    let v3382 = constructor_x64_vpbroadcastb(ctx, v3381);
                                    let v3383 = constructor_output_xmm(ctx, v3382);
                                    let v3384 = Some(v3383);
                                    // Rule at src/isa/x64/lower.isle line 4881.
                                    return v3384;
                                }
                                let v785 = C::has_ssse3(ctx);
                                if v785 == true {
                                    let v591 = constructor_put_in_gpr(ctx, v590);
                                    let v3374 = constructor_bitcast_gpr_to_xmm(ctx, 0x20_u8, v591);
                                    let v3375 = constructor_xmm_zero(ctx, I8X16);
                                    let v3376 = &C::xmm_to_xmm_mem_128(ctx, v3375);
                                    let v3377 = constructor_x64_pshufb(ctx, v3374, v3376);
                                    let v3378 = constructor_output_xmm(ctx, v3377);
                                    let v3379 = Some(v3378);
                                    // Rule at src/isa/x64/lower.isle line 4878.
                                    return v3379;
                                }
                                let v591 = constructor_put_in_gpr(ctx, v590);
                                let v3363 = &C::gpr_to_gpr_mem_32(ctx, v591);
                                let v3364 = constructor_x64_movd_to_xmm(ctx, v3363);
                                let v3365 = &C::xmm_to_xmm_mem_128(ctx, v3364);
                                let v3366 = constructor_x64_punpcklbw(ctx, v3364, v3365);
                                let v3367 = &C::xmm_to_xmm_mem_128(ctx, v3366);
                                let v3368 = constructor_x64_pshuflw(ctx, v3367, 0x0_u8);
                                let v3369 = &C::xmm_to_xmm_mem_128(ctx, v3368);
                                let v3370 = constructor_x64_pshufd(ctx, v3369, 0x0_u8);
                                let v3371 = constructor_output_xmm(ctx, v3370);
                                let v3372 = Some(v3371);
                                // Rule at src/isa/x64/lower.isle line 4874.
                                return v3372;
                            }
                            I16X8 => {
                                let v3380 = C::use_avx2(ctx);
                                if v3380 == true {
                                    let v3415 = &C::sinkable_load_16(ctx, v590);
                                    if let Some(v3416) = v3415 {
                                        let v3417 = &C::sink_load_16_to_xmm_mem_16(ctx, v3416);
                                        let v3418 = constructor_x64_vpbroadcastw(ctx, v3417);
                                        let v3419 = constructor_output_xmm(ctx, v3418);
                                        let v3420 = Some(v3419);
                                        // Rule at src/isa/x64/lower.isle line 4904.
                                        return v3420;
                                    }
                                }
                                let v3385 = &C::sinkable_load_exact(ctx, v590);
                                if let Some(v3386) = v3385 {
                                    let v2113 = constructor_xmm_uninit_value(ctx);
                                    let v3387 = &constructor_sink_load_to_gpr_mem(ctx, v3386);
                                    let v3408 = constructor_x64_pinsrw(ctx, v2113, v3387, 0x0_u8);
                                    let v3409 = &C::xmm_to_xmm_mem_128(ctx, v3408);
                                    let v3410 = constructor_x64_pshuflw(ctx, v3409, 0x0_u8);
                                    let v3411 = &C::xmm_to_xmm_mem_128(ctx, v3410);
                                    let v3412 = constructor_x64_pshufd(ctx, v3411, 0x0_u8);
                                    let v3413 = constructor_output_xmm(ctx, v3412);
                                    let v3414 = Some(v3413);
                                    // Rule at src/isa/x64/lower.isle line 4902.
                                    return v3414;
                                }
                                if v3380 == true {
                                    let v591 = constructor_put_in_gpr(ctx, v590);
                                    let v3374 = constructor_bitcast_gpr_to_xmm(ctx, 0x20_u8, v591);
                                    let v3404 = &C::xmm_to_xmm_mem_16(ctx, v3374);
                                    let v3405 = constructor_x64_vpbroadcastw(ctx, v3404);
                                    let v3406 = constructor_output_xmm(ctx, v3405);
                                    let v3407 = Some(v3406);
                                    // Rule at src/isa/x64/lower.isle line 4899.
                                    return v3407;
                                }
                                let v591 = constructor_put_in_gpr(ctx, v590);
                                let v3374 = constructor_bitcast_gpr_to_xmm(ctx, 0x20_u8, v591);
                                let v3398 = &C::xmm_to_xmm_mem_128(ctx, v3374);
                                let v3399 = constructor_x64_pshuflw(ctx, v3398, 0x0_u8);
                                let v3400 = &C::xmm_to_xmm_mem_128(ctx, v3399);
                                let v3401 = constructor_x64_pshufd(ctx, v3400, 0x0_u8);
                                let v3402 = constructor_output_xmm(ctx, v3401);
                                let v3403 = Some(v3402);
                                // Rule at src/isa/x64/lower.isle line 4897.
                                return v3403;
                            }
                            I32X4 => {
                                let v3380 = C::use_avx2(ctx);
                                if v3380 == true {
                                    let v591 = constructor_put_in_gpr(ctx, v590);
                                    let v3374 = constructor_bitcast_gpr_to_xmm(ctx, 0x20_u8, v591);
                                    let v3424 = &C::xmm_to_xmm_mem_32(ctx, v3374);
                                    let v3425 = constructor_x64_vpbroadcastd(ctx, v3424);
                                    let v3426 = constructor_output_xmm(ctx, v3425);
                                    let v3427 = Some(v3426);
                                    // Rule at src/isa/x64/lower.isle line 4914.
                                    return v3427;
                                }
                                let v591 = constructor_put_in_gpr(ctx, v590);
                                let v3374 = constructor_bitcast_gpr_to_xmm(ctx, 0x20_u8, v591);
                                let v3398 = &C::xmm_to_xmm_mem_128(ctx, v3374);
                                let v3421 = constructor_x64_pshufd(ctx, v3398, 0x0_u8);
                                let v3422 = constructor_output_xmm(ctx, v3421);
                                let v3423 = Some(v3422);
                                // Rule at src/isa/x64/lower.isle line 4912.
                                return v3423;
                            }
                            I64X2 => {
                                let v591 = constructor_put_in_gpr(ctx, v590);
                                let v3446 = constructor_bitcast_gpr_to_xmm(ctx, 0x40_u8, v591);
                                let v3447 = &C::xmm_to_xmm_mem_128(ctx, v3446);
                                let v3449 = constructor_x64_pshufd(ctx, v3447, 0x44_u8);
                                let v3450 = constructor_output_xmm(ctx, v3449);
                                let v3451 = Some(v3450);
                                // Rule at src/isa/x64/lower.isle line 4947.
                                return v3451;
                            }
                            F32X4 => {
                                let v3380 = C::use_avx2(ctx);
                                if v3380 == true {
                                    let v3431 = &C::put_in_xmm_mem_32(ctx, v590);
                                    let v3432 = constructor_x64_vbroadcastss(ctx, v3431);
                                    let v3433 = constructor_output_xmm(ctx, v3432);
                                    let v3434 = Some(v3433);
                                    // Rule at src/isa/x64/lower.isle line 4924.
                                    return v3434;
                                }
                                let v790 = constructor_put_in_xmm(ctx, v590);
                                let v2728 = &C::xmm_to_xmm_mem_128(ctx, v790);
                                let v3428 = constructor_x64_shufps(ctx, v790, v2728, 0x0_u8);
                                let v3429 = constructor_output_xmm(ctx, v3428);
                                let v3430 = Some(v3429);
                                // Rule at src/isa/x64/lower.isle line 4921.
                                return v3430;
                            }
                            F64X2 => {
                                let v790 = constructor_put_in_xmm(ctx, v590);
                                let v2728 = &C::xmm_to_xmm_mem_128(ctx, v790);
                                let v3452 = constructor_x64_pshufd(ctx, v2728, 0x44_u8);
                                let v3453 = constructor_output_xmm(ctx, v3452);
                                let v3454 = Some(v3453);
                                // Rule at src/isa/x64/lower.isle line 4949.
                                return v3454;
                            }
                            _ => {}
                        }
                    }
                }
                &Opcode::SetPinnedReg => {
                    let v591 = constructor_put_in_gpr(ctx, v590);
                    let v3140 = &constructor_write_pinned_gpr(ctx, v591);
                    let v3141 = constructor_side_effect(ctx, v3140);
                    let v3142 = Some(v3141);
                    // Rule at src/isa/x64/lower.isle line 4587.
                    return v3142;
                }
                &Opcode::VanyTrue => {
                    let v3462 = &constructor_is_vany_true(ctx, v590);
                    let v3463 = constructor_lower_cond_bool(ctx, v3462);
                    let v3464 = constructor_output_gpr(ctx, v3463);
                    let v3465 = Some(v3464);
                    // Rule at src/isa/x64/lower.isle line 4957.
                    return v3465;
                }
                &Opcode::VallTrue => {
                    let v3466 = &constructor_is_vall_true(ctx, v590);
                    let v3467 = constructor_lower_cond_bool(ctx, v3466);
                    let v3468 = constructor_output_gpr(ctx, v3467);
                    let v3469 = Some(v3468);
                    // Rule at src/isa/x64/lower.isle line 5008.
                    return v3469;
                }
                &Opcode::VhighBits => {
                    let v923 = C::value_type(ctx, v590);
                    let v3470 = C::multi_lane(ctx, v923);
                    if let Some(v3471) = v3470 {
                        match v3471.0 {
                            0x8_u32 => {
                                if v3471.1 == 0x10_u32 {
                                    let v790 = constructor_put_in_xmm(ctx, v590);
                                    let v3474 = constructor_x64_pmovmskb(ctx, v790);
                                    let v3475 = constructor_output_gpr(ctx, v3474);
                                    let v3476 = Some(v3475);
                                    // Rule at src/isa/x64/lower.isle line 5051.
                                    return v3476;
                                }
                            }
                            0x10_u32 => {
                                if v3471.1 == 0x8_u32 {
                                    let v790 = constructor_put_in_xmm(ctx, v590);
                                    let v2728 = &C::xmm_to_xmm_mem_128(ctx, v790);
                                    let v3483 = constructor_x64_packsswb(ctx, v790, v2728);
                                    let v3484 = constructor_x64_pmovmskb(ctx, v3483);
                                    let v3485 = constructor_x64_shrq_mi(ctx, v3484, 0x8_u8);
                                    let v3486 = constructor_output_gpr(ctx, v3485);
                                    let v3487 = Some(v3486);
                                    // Rule at src/isa/x64/lower.isle line 5066.
                                    return v3487;
                                }
                            }
                            0x20_u32 => {
                                if v3471.1 == 0x4_u32 {
                                    let v790 = constructor_put_in_xmm(ctx, v590);
                                    let v3477 = constructor_x64_movmskps(ctx, v790);
                                    let v3478 = constructor_output_gpr(ctx, v3477);
                                    let v3479 = Some(v3478);
                                    // Rule at src/isa/x64/lower.isle line 5054.
                                    return v3479;
                                }
                            }
                            0x40_u32 => {
                                if v3471.1 == 0x2_u32 {
                                    let v790 = constructor_put_in_xmm(ctx, v590);
                                    let v3480 = constructor_x64_movmskpd(ctx, v790);
                                    let v3481 = constructor_output_gpr(ctx, v3480);
                                    let v3482 = Some(v3481);
                                    // Rule at src/isa/x64/lower.isle line 5057.
                                    return v3482;
                                }
                            }
                            _ => {}
                        }
                    }
                }
                &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 v607 = constructor_imm(ctx, I8X16, 0x0_u64);
                                let v608 = C::xmm_new(ctx, v607);
                                let v609 = &C::put_in_xmm_mem_128(ctx, v590);
                                let v610 = constructor_x64_psubb(ctx, v608, v609);
                                let v611 = constructor_output_xmm(ctx, v610);
                                let v612 = Some(v611);
                                // Rule at src/isa/x64/lower.isle line 1020.
                                return v612;
                            }
                            I16X8 => {
                                let v614 = constructor_imm(ctx, I16X8, 0x0_u64);
                                let v615 = C::xmm_new(ctx, v614);
                                let v609 = &C::put_in_xmm_mem_128(ctx, v590);
                                let v616 = constructor_x64_psubw(ctx, v615, v609);
                                let v617 = constructor_output_xmm(ctx, v616);
                                let v618 = Some(v617);
                                // Rule at src/isa/x64/lower.isle line 1023.
                                return v618;
                            }
                            I32X4 => {
                                let v620 = constructor_imm(ctx, I32X4, 0x0_u64);
                                let v621 = C::xmm_new(ctx, v620);
                                let v609 = &C::put_in_xmm_mem_128(ctx, v590);
                                let v622 = constructor_x64_psubd(ctx, v621, v609);
                                let v623 = constructor_output_xmm(ctx, v622);
                                let v624 = Some(v623);
                                // Rule at src/isa/x64/lower.isle line 1026.
                                return v624;
                            }
                            I64X2 => {
                                let v626 = constructor_imm(ctx, I64X2, 0x0_u64);
                                let v627 = C::xmm_new(ctx, v626);
                                let v609 = &C::put_in_xmm_mem_128(ctx, v590);
                                let v628 = constructor_x64_psubq(ctx, v627, v609);
                                let v629 = constructor_output_xmm(ctx, v628);
                                let v630 = Some(v629);
                                // Rule at src/isa/x64/lower.isle line 1029.
                                return v630;
                            }
                            _ => {}
                        }
                        let v4 = C::fits_in_64(ctx, v3);
                        if let Some(v5) = v4 {
                            let v591 = constructor_put_in_gpr(ctx, v590);
                            let v592 = constructor_x64_neg(ctx, v5, v591);
                            let v593 = constructor_output_gpr(ctx, v592);
                            let v594 = Some(v593);
                            // Rule at src/isa/x64/lower.isle line 1006.
                            return v594;
                        }
                        if v3 == I128 {
                            let v595 = C::put_in_regs(ctx, v590);
                            let v596 = constructor_value_regs_get_gpr(ctx, v595, 0x0_usize);
                            let v597 = constructor_value_regs_get_gpr(ctx, v595, 0x1_usize);
                            let v598 = &constructor_x64_neg_paired(ctx, I64, v596);
                            let v599 = constructor_imm(ctx, I64, 0x0_u64);
                            let v600 = C::gpr_new(ctx, v599);
                            let v601 = &C::gpr_to_gpr_mem_imm(ctx, v597);
                            let v602 = &constructor_x64_sbb_paired(ctx, I64, v600, v601);
                            let v603 = constructor_with_flags(ctx, v598, v602);
                            let v604 = C::output(ctx, v603);
                            let v605 = Some(v604);
                            // Rule at src/isa/x64/lower.isle line 1009.
                            return v605;
                        }
                    }
                }
                &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 v595 = C::put_in_regs(ctx, v590);
                                let v596 = constructor_value_regs_get_gpr(ctx, v595, 0x0_usize);
                                let v597 = constructor_value_regs_get_gpr(ctx, v595, 0x1_usize);
                                let v598 = &constructor_x64_neg_paired(ctx, I64, v596);
                                let v599 = constructor_imm(ctx, I64, 0x0_u64);
                                let v852 = &constructor_reg_to_gpr_mem_imm(ctx, v599);
                                let v853 = &constructor_x64_adc_paired(ctx, I64, v597, v852);
                                let v854 = constructor_with_flags(ctx, v598, v853);
                                let v855 = C::value_regs_get(ctx, v854, 0x1_usize);
                                let v856 = C::gpr_new(ctx, v855);
                                let v857 = &constructor_x64_neg_paired(ctx, I64, v856);
                                let v858 = &constructor_produces_flags_ignore(ctx, v857);
                                let v859 = &C::gpr_to_gpr_mem(ctx, v596);
                                let v860 = C::value_regs_get(ctx, v854, 0x0_usize);
                                let v861 = C::gpr_new(ctx, v860);
                                let v862 = &constructor_cmove(ctx, I64, &CC::S, v859, v861);
                                let v863 = &C::gpr_to_gpr_mem(ctx, v597);
                                let v864 = constructor_produces_flags_get_reg(ctx, v857);
                                let v865 = C::gpr_new(ctx, v864);
                                let v866 = &constructor_cmove(ctx, I64, &CC::S, v863, v865);
                                let v867 = &constructor_consumes_flags_concat(ctx, v862, v866);
                                let v868 = constructor_with_flags(ctx, v858, v867);
                                let v869 = C::output(ctx, v868);
                                let v870 = Some(v869);
                                // Rule at src/isa/x64/lower.isle line 1380.
                                return v870;
                            }
                            I8X16 => {
                                let v785 = C::has_ssse3(ctx);
                                if v785 == true {
                                    let v786 = &C::put_in_xmm_mem_128(ctx, v590);
                                    let v787 = constructor_x64_pabsb_a_or_avx(ctx, v786);
                                    let v788 = constructor_output_xmm(ctx, v787);
                                    let v789 = Some(v788);
                                    // Rule at src/isa/x64/lower.isle line 1296.
                                    return v789;
                                }
                                let v790 = constructor_put_in_xmm(ctx, v590);
                                let v791 = constructor_xmm_zero(ctx, I8X16);
                                let v792 = &C::xmm_to_xmm_mem_128(ctx, v790);
                                let v793 = constructor_x64_psubb(ctx, v791, v792);
                                let v794 = &C::xmm_to_xmm_mem_aligned_128(ctx, v793);
                                let v795 = constructor_x64_pminub_a(ctx, v790, v794);
                                let v796 = constructor_output_xmm(ctx, v795);
                                let v797 = Some(v796);
                                // Rule at src/isa/x64/lower.isle line 1303.
                                return v797;
                            }
                            I16X8 => {
                                let v785 = C::has_ssse3(ctx);
                                if v785 == true {
                                    let v786 = &C::put_in_xmm_mem_128(ctx, v590);
                                    let v798 = constructor_x64_pabsw_a_or_avx(ctx, v786);
                                    let v799 = constructor_output_xmm(ctx, v798);
                                    let v800 = Some(v799);
                                    // Rule at src/isa/x64/lower.isle line 1310.
                                    return v800;
                                }
                                let v790 = constructor_put_in_xmm(ctx, v590);
                                let v801 = constructor_xmm_zero(ctx, I16X8);
                                let v792 = &C::xmm_to_xmm_mem_128(ctx, v790);
                                let v802 = constructor_x64_psubw(ctx, v801, v792);
                                let v803 = &C::xmm_to_xmm_mem_aligned_128(ctx, v802);
                                let v804 = constructor_x64_pmaxsw_a(ctx, v790, v803);
                                let v805 = constructor_output_xmm(ctx, v804);
                                let v806 = Some(v805);
                                // Rule at src/isa/x64/lower.isle line 1314.
                                return v806;
                            }
                            I32X4 => {
                                let v785 = C::has_ssse3(ctx);
                                if v785 == true {
                                    let v786 = &C::put_in_xmm_mem_128(ctx, v590);
                                    let v807 = constructor_x64_pabsd_a_or_avx(ctx, v786);
                                    let v808 = constructor_output_xmm(ctx, v807);
                                    let v809 = Some(v808);
                                    // Rule at src/isa/x64/lower.isle line 1321.
                                    return v809;
                                }
                                let v790 = constructor_put_in_xmm(ctx, v590);
                                let v811 = &C::xmi_imm(ctx, 0x1f_u32);
                                let v812 = constructor_x64_psrad(ctx, v790, v811);
                                let v813 = &C::xmm_to_xmm_mem_128(ctx, v812);
                                let v814 = constructor_x64_pxor(ctx, v790, v813);
                                let v815 = &C::xmm_to_xmm_mem_128(ctx, v812);
                                let v816 = constructor_x64_psubd(ctx, v814, v815);
                                let v817 = constructor_output_xmm(ctx, v816);
                                let v818 = Some(v817);
                                // Rule at src/isa/x64/lower.isle line 1331.
                                return v818;
                            }
                            I64X2 => {
                                let v533 = C::has_avx512vl(ctx);
                                if v533 == true {
                                    let v534 = C::has_avx512f(ctx);
                                    if v534 == true {
                                        let v786 = &C::put_in_xmm_mem_128(ctx, v590);
                                        let v819 = constructor_x64_vpabsq(ctx, v786);
                                        let v820 = constructor_output_xmm(ctx, v819);
                                        let v821 = Some(v820);
                                        // Rule at src/isa/x64/lower.isle line 1340.
                                        return v821;
                                    }
                                }
                                let v692 = C::has_sse41(ctx);
                                if v692 == true {
                                    let v790 = constructor_put_in_xmm(ctx, v590);
                                    let v822 = constructor_imm(ctx, I64X2, 0x0_u64);
                                    let v823 = C::xmm_new(ctx, v822);
                                    let v824 = &C::xmm_to_xmm_mem_128(ctx, v790);
                                    let v825 = constructor_x64_psubq(ctx, v823, v824);
                                    let v826 = &C::xmm_to_xmm_mem_128(ctx, v790);
                                    let v827 = constructor_x64_blendvpd(ctx, v825, v826, v825);
                                    let v828 = constructor_output_xmm(ctx, v827);
                                    let v829 = Some(v828);
                                    // Rule at src/isa/x64/lower.isle line 1349.
                                    return v829;
                                }
                                let v790 = constructor_put_in_xmm(ctx, v590);
                                let v830 = RegMemImm::Imm {
                                    simm32: 0x1f_u32,
                                };
                                let v831 = &C::xmm_mem_imm_new(ctx, &v830);
                                let v832 = constructor_x64_psrad(ctx, v790, v831);
                                let v833 = &C::xmm_to_xmm_mem_128(ctx, v832);
                                let v835 = constructor_x64_pshufd(ctx, v833, 0xf5_u8);
                                let v836 = &C::xmm_to_xmm_mem_128(ctx, v835);
                                let v837 = constructor_x64_pxor(ctx, v790, v836);
                                let v838 = &C::xmm_to_xmm_mem_128(ctx, v835);
                                let v839 = constructor_x64_psubq(ctx, v837, v838);
                                let v840 = constructor_output_xmm(ctx, v839);
                                let v841 = Some(v840);
                                // Rule at src/isa/x64/lower.isle line 1358.
                                return v841;
                            }
                            _ => {}
                        }
                        let v4 = C::fits_in_64(ctx, v3);
                        if let Some(v5) = v4 {
                            let v591 = constructor_put_in_gpr(ctx, v590);
                            let v842 = &constructor_x64_neg_paired(ctx, v5, v591);
                            let v843 = constructor_produces_flags_get_reg(ctx, v842);
                            let v844 = C::gpr_new(ctx, v843);
                            let v846 = &C::gpr_to_gpr_mem(ctx, v591);
                            let v847 = &constructor_cmove(ctx, v5, &CC::S, v846, v844);
                            let v848 = &constructor_produces_flags_ignore(ctx, v842);
                            let v849 = constructor_with_flags_reg(ctx, v848, v847);
                            let v850 = constructor_output_reg(ctx, v849);
                            let v851 = Some(v850);
                            // Rule at src/isa/x64/lower.isle line 1367.
                            return v851;
                        }
                    }
                }
                &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 v930 = constructor_not_i128(ctx, v590);
                            let v931 = C::output(ctx, v930);
                            let v932 = Some(v931);
                            // Rule at src/isa/x64/lower.isle line 1498.
                            return v932;
                        }
                        let v91 = C::multi_lane(ctx, v3);
                        if let Some(v92) = v91 {
                            let v790 = constructor_put_in_xmm(ctx, v590);
                            let v885 = constructor_vector_all_ones(ctx);
                            let v933 = &C::xmm_to_xmm_mem_128(ctx, v885);
                            let v937 = constructor_x64_xor_vector(ctx, v3, v790, v933);
                            let v938 = constructor_output_xmm(ctx, v937);
                            let v939 = Some(v938);
                            // Rule at src/isa/x64/lower.isle line 1508.
                            return v939;
                        }
                        let v262 = C::ty_int_ref_scalar_64(ctx, v3);
                        if let Some(v263) = v262 {
                            let v591 = constructor_put_in_gpr(ctx, v590);
                            let v927 = constructor_x64_not(ctx, v3, v591);
                            let v928 = constructor_output_gpr(ctx, v927);
                            let v929 = Some(v928);
                            // Rule at src/isa/x64/lower.isle line 1483.
                            return v929;
                        }
                        let v275 = C::ty_scalar_float(ctx, v3);
                        if let Some(v276) = v275 {
                            let v790 = constructor_put_in_xmm(ctx, v590);
                            let v885 = constructor_vector_all_ones(ctx);
                            let v933 = &C::xmm_to_xmm_mem_128(ctx, v885);
                            let v934 = constructor_x64_xor_vector(ctx, v276, v790, v933);
                            let v935 = constructor_output_xmm(ctx, v934);
                            let v936 = Some(v935);
                            // Rule at src/isa/x64/lower.isle line 1503.
                            return v936;
                        }
                    }
                }
                &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 v591 = constructor_put_in_gpr(ctx, v590);
                                let v1726 = constructor_do_bitrev8(ctx, I32, v591);
                                let v1727 = constructor_output_gpr(ctx, v1726);
                                let v1728 = Some(v1727);
                                // Rule at src/isa/x64/lower.isle line 2535.
                                return v1728;
                            }
                            I16 => {
                                let v591 = constructor_put_in_gpr(ctx, v590);
                                let v1729 = constructor_do_bitrev16(ctx, I32, v591);
                                let v1730 = constructor_output_gpr(ctx, v1729);
                                let v1731 = Some(v1730);
                                // Rule at src/isa/x64/lower.isle line 2538.
                                return v1731;
                            }
                            I32 => {
                                let v591 = constructor_put_in_gpr(ctx, v590);
                                let v1732 = constructor_do_bitrev32(ctx, I32, v591);
                                let v1733 = constructor_output_gpr(ctx, v1732);
                                let v1734 = Some(v1733);
                                // Rule at src/isa/x64/lower.isle line 2541.
                                return v1734;
                            }
                            I64 => {
                                let v591 = constructor_put_in_gpr(ctx, v590);
                                let v1735 = constructor_do_bitrev64(ctx, I64, v591);
                                let v1736 = constructor_output_gpr(ctx, v1735);
                                let v1737 = Some(v1736);
                                // Rule at src/isa/x64/lower.isle line 2544.
                                return v1737;
                            }
                            I128 => {
                                let v595 = C::put_in_regs(ctx, v590);
                                let v1562 = constructor_value_regs_get_gpr(ctx, v595, 0x1_usize);
                                let v1738 = constructor_do_bitrev64(ctx, I64, v1562);
                                let v1739 = C::gpr_to_reg(ctx, v1738);
                                let v1652 = C::put_in_regs(ctx, v590);
                                let v1740 = constructor_value_regs_get_gpr(ctx, v1652, 0x0_usize);
                                let v1741 = constructor_do_bitrev64(ctx, I64, v1740);
                                let v1742 = C::gpr_to_reg(ctx, v1741);
                                let v1743 = C::value_regs(ctx, v1739, v1742);
                                let v1744 = C::output(ctx, v1743);
                                let v1745 = Some(v1744);
                                // Rule at src/isa/x64/lower.isle line 2547.
                                return v1745;
                            }
                            _ => {}
                        }
                    }
                }
                &Opcode::Clz => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        let v69 = C::ty_32_or_64(ctx, v3);
                        if let Some(v70) = v69 {
                            let v591 = constructor_put_in_gpr(ctx, v590);
                            let v1546 = constructor_do_clz(ctx, v70, v70, v591);
                            let v1547 = constructor_output_gpr(ctx, v1546);
                            let v1548 = Some(v1547);
                            // Rule at src/isa/x64/lower.isle line 2277.
                            return v1548;
                        }
                        let v1549 = C::ty_8_or_16(ctx, v3);
                        if let Some(v1550) = v1549 {
                            let v1551 = constructor_extend_to_gpr(ctx, v590, I64, &ExtendKind::Zero);
                            let v1552 = constructor_do_clz(ctx, I64, I64, v1551);
                            let v1554 = C::ty_bits(ctx, v1550);
                            let v1555 = C::u8_into_u32(ctx, v1554);
                            let v1556 = C::u32_wrapping_sub(ctx, 0x40_u32, v1555);
                            let v1557 = RegMemImm::Imm {
                                simm32: v1556,
                            };
                            let v1558 = &C::gpr_mem_imm_new(ctx, &v1557);
                            let v1559 = constructor_x64_sub(ctx, I64, v1552, v1558);
                            let v1560 = constructor_output_gpr(ctx, v1559);
                            let v1561 = Some(v1560);
                            // Rule at src/isa/x64/lower.isle line 2280.
                            return v1561;
                        }
                        if v3 == I128 {
                            let v595 = C::put_in_regs(ctx, v590);
                            let v1562 = constructor_value_regs_get_gpr(ctx, v595, 0x1_usize);
                            let v1563 = constructor_do_clz(ctx, I64, I64, v1562);
                            let v1564 = C::put_in_regs(ctx, v590);
                            let v1565 = constructor_value_regs_get_gpr(ctx, v1564, 0x0_usize);
                            let v1566 = constructor_do_clz(ctx, I64, I64, v1565);
                            let v1567 = RegMemImm::Imm {
                                simm32: 0x40_u32,
                            };
                            let v1568 = &C::gpr_mem_imm_new(ctx, &v1567);
                            let v1569 = constructor_x64_add(ctx, I64, v1566, v1568);
                            let v1570 = &C::gpr_to_gpr_mem_64(ctx, v1563);
                            let v1572 = &constructor_x64_cmpq_mi_sxb(ctx, v1570, 64_i8);
                            let v1574 = &C::gpr_to_gpr_mem(ctx, v1563);
                            let v1575 = &constructor_cmove(ctx, I64, &CC::NZ, v1574, v1569);
                            let v1576 = constructor_with_flags_reg(ctx, v1572, v1575);
                            let v1577 = C::gpr_new(ctx, v1576);
                            let v1578 = C::gpr_to_reg(ctx, v1577);
                            let v1579 = constructor_imm(ctx, I64, 0x0_u64);
                            let v1580 = C::value_regs(ctx, v1578, v1579);
                            let v1581 = C::output(ctx, v1580);
                            let v1582 = Some(v1581);
                            // Rule at src/isa/x64/lower.isle line 2286.
                            return v1582;
                        }
                    }
                }
                &Opcode::Cls => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        let v69 = C::ty_32_or_64(ctx, v3);
                        if let Some(v70) = v69 {
                            let v591 = constructor_put_in_gpr(ctx, v590);
                            let v1609 = constructor_do_cls(ctx, v70, v591);
                            let v1610 = constructor_output_gpr(ctx, v1609);
                            let v1611 = Some(v1610);
                            // Rule at src/isa/x64/lower.isle line 2351.
                            return v1611;
                        }
                        let v1549 = C::ty_8_or_16(ctx, v3);
                        if let Some(v1550) = v1549 {
                            let v1612 = constructor_extend_to_gpr(ctx, v590, I32, &ExtendKind::Sign);
                            let v1613 = constructor_do_cls(ctx, I32, v1612);
                            let v1554 = C::ty_bits(ctx, v1550);
                            let v1555 = C::u8_into_u32(ctx, v1554);
                            let v1614 = C::u32_wrapping_sub(ctx, 0x20_u32, v1555);
                            let v1615 = RegMemImm::Imm {
                                simm32: v1614,
                            };
                            let v1616 = &C::gpr_mem_imm_new(ctx, &v1615);
                            let v1617 = constructor_x64_sub(ctx, I32, v1613, v1616);
                            let v1618 = constructor_output_gpr(ctx, v1617);
                            let v1619 = Some(v1618);
                            // Rule at src/isa/x64/lower.isle line 2354.
                            return v1619;
                        }
                        if v3 == I128 {
                            let v595 = C::put_in_regs(ctx, v590);
                            let v1562 = constructor_value_regs_get_gpr(ctx, v595, 0x1_usize);
                            let v1620 = constructor_do_cls(ctx, I64, v1562);
                            let v1564 = C::put_in_regs(ctx, v590);
                            let v1595 = constructor_value_regs_get_gpr(ctx, v1564, 0x1_usize);
                            let v1621 = constructor_x64_sarq_mi(ctx, v1595, 0x3f_u8);
                            let v1622 = C::put_in_regs(ctx, v590);
                            let v1623 = constructor_value_regs_get_gpr(ctx, v1622, 0x0_usize);
                            let v1624 = &C::gpr_to_gpr_mem_imm(ctx, v1621);
                            let v1625 = constructor_x64_xor(ctx, I64, v1623, v1624);
                            let v1626 = constructor_do_clz(ctx, I64, I64, v1625);
                            let v561 = RegMemImm::Imm {
                                simm32: 0x3f_u32,
                            };
                            let v1627 = &C::gpr_mem_imm_new(ctx, &v561);
                            let v1628 = constructor_x64_add(ctx, I64, v1626, v1627);
                            let v1629 = &C::gpr_to_gpr_mem_64(ctx, v1620);
                            let v1631 = &constructor_x64_cmpq_mi_sxb(ctx, v1629, 63_i8);
                            let v1632 = &C::gpr_to_gpr_mem(ctx, v1620);
                            let v1633 = &constructor_cmove(ctx, I64, &CC::NZ, v1632, v1628);
                            let v1634 = constructor_with_flags_reg(ctx, v1631, v1633);
                            let v1635 = C::gpr_new(ctx, v1634);
                            let v1636 = C::gpr_to_reg(ctx, v1635);
                            let v1637 = constructor_imm(ctx, I64, 0x0_u64);
                            let v1638 = C::value_regs(ctx, v1636, v1637);
                            let v1639 = C::output(ctx, v1638);
                            let v1640 = Some(v1639);
                            // Rule at src/isa/x64/lower.isle line 2359.
                            return v1640;
                        }
                    }
                }
                &Opcode::Ctz => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        let v69 = C::ty_32_or_64(ctx, v3);
                        if let Some(v70) = v69 {
                            let v591 = constructor_put_in_gpr(ctx, v590);
                            let v1583 = constructor_do_ctz(ctx, v70, v70, v591);
                            let v1584 = constructor_output_gpr(ctx, v1583);
                            let v1585 = Some(v1584);
                            // Rule at src/isa/x64/lower.isle line 2317.
                            return v1585;
                        }
                        let v1549 = C::ty_8_or_16(ctx, v3);
                        if let Some(v1550) = v1549 {
                            let v1586 = constructor_extend_to_gpr(ctx, v590, I32, &ExtendKind::Zero);
                            let v1554 = C::ty_bits(ctx, v1550);
                            let v1555 = C::u8_into_u32(ctx, v1554);
                            let v1587 = C::u32_wrapping_shl(ctx, 0x1_u32, v1555);
                            let v1588 = RegMemImm::Imm {
                                simm32: v1587,
                            };
                            let v1589 = &C::gpr_mem_imm_new(ctx, &v1588);
                            let v1590 = constructor_x64_or(ctx, I32, v1586, v1589);
                            let v1591 = constructor_do_ctz(ctx, I32, v1550, v1590);
                            let v1592 = constructor_output_gpr(ctx, v1591);
                            let v1593 = Some(v1592);
                            // Rule at src/isa/x64/lower.isle line 2320.
                            return v1593;
                        }
                        if v3 == I128 {
                            let v595 = C::put_in_regs(ctx, v590);
                            let v596 = constructor_value_regs_get_gpr(ctx, v595, 0x0_usize);
                            let v1594 = constructor_do_ctz(ctx, I64, I64, v596);
                            let v1564 = C::put_in_regs(ctx, v590);
                            let v1595 = constructor_value_regs_get_gpr(ctx, v1564, 0x1_usize);
                            let v1596 = constructor_do_ctz(ctx, I64, I64, v1595);
                            let v1567 = RegMemImm::Imm {
                                simm32: 0x40_u32,
                            };
                            let v1568 = &C::gpr_mem_imm_new(ctx, &v1567);
                            let v1597 = constructor_x64_add(ctx, I64, v1596, v1568);
                            let v1598 = &C::gpr_to_gpr_mem_64(ctx, v1594);
                            let v1599 = &constructor_x64_cmpq_mi_sxb(ctx, v1598, 64_i8);
                            let v1601 = &C::gpr_to_gpr_mem(ctx, v1597);
                            let v1602 = &constructor_cmove(ctx, I64, &CC::Z, v1601, v1594);
                            let v1603 = constructor_with_flags_reg(ctx, v1599, v1602);
                            let v1604 = C::gpr_new(ctx, v1603);
                            let v1605 = C::gpr_to_reg(ctx, v1604);
                            let v1579 = constructor_imm(ctx, I64, 0x0_u64);
                            let v1606 = C::value_regs(ctx, v1605, v1579);
                            let v1607 = C::output(ctx, v1606);
                            let v1608 = Some(v1607);
                            // Rule at src/isa/x64/lower.isle line 2325.
                            return v1608;
                        }
                    }
                }
                &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 v591 = constructor_put_in_gpr(ctx, v590);
                                let v1746 = constructor_x64_rolw_mi(ctx, v591, 0x8_u8);
                                let v1747 = constructor_output_gpr(ctx, v1746);
                                let v1748 = Some(v1747);
                                // Rule at src/isa/x64/lower.isle line 2614.
                                return v1748;
                            }
                            I32 => {
                                let v591 = constructor_put_in_gpr(ctx, v590);
                                let v1749 = constructor_x64_bswap(ctx, I32, v591);
                                let v1750 = constructor_output_gpr(ctx, v1749);
                                let v1751 = Some(v1750);
                                // Rule at src/isa/x64/lower.isle line 2617.
                                return v1751;
                            }
                            I64 => {
                                let v591 = constructor_put_in_gpr(ctx, v590);
                                let v1752 = constructor_x64_bswap(ctx, I64, v591);
                                let v1753 = constructor_output_gpr(ctx, v1752);
                                let v1754 = Some(v1753);
                                // Rule at src/isa/x64/lower.isle line 2620.
                                return v1754;
                            }
                            I128 => {
                                let v595 = C::put_in_regs(ctx, v590);
                                let v1562 = constructor_value_regs_get_gpr(ctx, v595, 0x1_usize);
                                let v1755 = constructor_x64_bswap(ctx, I64, v1562);
                                let v1756 = C::gpr_to_reg(ctx, v1755);
                                let v1652 = C::put_in_regs(ctx, v590);
                                let v1740 = constructor_value_regs_get_gpr(ctx, v1652, 0x0_usize);
                                let v1757 = constructor_x64_bswap(ctx, I64, v1740);
                                let v1758 = C::gpr_to_reg(ctx, v1757);
                                let v1759 = C::value_regs(ctx, v1756, v1758);
                                let v1760 = C::output(ctx, v1759);
                                let v1761 = Some(v1760);
                                // Rule at src/isa/x64/lower.isle line 2623.
                                return v1761;
                            }
                            _ => {}
                        }
                    }
                }
                &Opcode::Popcnt => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v1641 = C::use_popcnt(ctx);
                        if v1641 == true {
                            let v3 = C::value_type(ctx, v2);
                            let v69 = C::ty_32_or_64(ctx, v3);
                            if let Some(v70) = v69 {
                                let v1642 = &constructor_put_in_gpr_mem(ctx, v590);
                                let v1643 = constructor_x64_popcnt(ctx, v70, v1642);
                                let v1644 = constructor_output_gpr(ctx, v1643);
                                let v1645 = Some(v1644);
                                // Rule at src/isa/x64/lower.isle line 2386.
                                return v1645;
                            }
                            let v1549 = C::ty_8_or_16(ctx, v3);
                            if let Some(v1550) = v1549 {
                                let v1586 = constructor_extend_to_gpr(ctx, v590, I32, &ExtendKind::Zero);
                                let v1646 = &C::gpr_to_gpr_mem(ctx, v1586);
                                let v1647 = constructor_x64_popcnt(ctx, I32, v1646);
                                let v1648 = constructor_output_gpr(ctx, v1647);
                                let v1649 = Some(v1648);
                                // Rule at src/isa/x64/lower.isle line 2390.
                                return v1649;
                            }
                        }
                        let v3 = C::value_type(ctx, v2);
                        match v3 {
                            I128 => {
                                if v1641 == true {
                                    let v595 = C::put_in_regs(ctx, v590);
                                    let v596 = constructor_value_regs_get_gpr(ctx, v595, 0x0_usize);
                                    let v1650 = &C::gpr_to_gpr_mem(ctx, v596);
                                    let v1651 = constructor_x64_popcnt(ctx, I64, v1650);
                                    let v1652 = C::put_in_regs(ctx, v590);
                                    let v1653 = constructor_value_regs_get_gpr(ctx, v1652, 0x1_usize);
                                    let v1654 = &C::gpr_to_gpr_mem(ctx, v1653);
                                    let v1655 = constructor_x64_popcnt(ctx, I64, v1654);
                                    let v1656 = &C::gpr_to_gpr_mem_imm(ctx, v1655);
                                    let v1657 = constructor_x64_add(ctx, I64, v1651, v1656);
                                    let v1658 = C::gpr_to_reg(ctx, v1657);
                                    let v1659 = constructor_imm(ctx, I64, 0x0_u64);
                                    let v1660 = C::value_regs(ctx, v1658, v1659);
                                    let v1661 = C::output(ctx, v1660);
                                    let v1662 = Some(v1661);
                                    // Rule at src/isa/x64/lower.isle line 2394.
                                    return v1662;
                                }
                                let v595 = C::put_in_regs(ctx, v590);
                                let v596 = constructor_value_regs_get_gpr(ctx, v595, 0x0_usize);
                                let v1669 = constructor_do_popcnt(ctx, I64, v596);
                                let v1564 = C::put_in_regs(ctx, v590);
                                let v1595 = constructor_value_regs_get_gpr(ctx, v1564, 0x1_usize);
                                let v1670 = constructor_do_popcnt(ctx, I64, v1595);
                                let v1671 = &C::gpr_to_gpr_mem_imm(ctx, v1670);
                                let v1672 = constructor_x64_add(ctx, I64, v1669, v1671);
                                let v1673 = C::gpr_to_reg(ctx, v1672);
                                let v1674 = constructor_imm(ctx, I64, 0x0_u64);
                                let v1675 = C::value_regs(ctx, v1673, v1674);
                                let v1676 = C::output(ctx, v1675);
                                let v1677 = Some(v1676);
                                // Rule at src/isa/x64/lower.isle line 2410.
                                return v1677;
                            }
                            I8X16 => {
                                let v533 = C::has_avx512vl(ctx);
                                if v533 == true {
                                    let v1678 = C::has_avx512bitalg(ctx);
                                    if v1678 == true {
                                        let v786 = &C::put_in_xmm_mem_128(ctx, v590);
                                        let v1679 = constructor_x64_vpopcntb(ctx, v786);
                                        let v1680 = constructor_output_xmm(ctx, v1679);
                                        let v1681 = Some(v1680);
                                        // Rule at src/isa/x64/lower.isle line 2479.
                                        return v1681;
                                    }
                                }
                                let v785 = C::has_ssse3(ctx);
                                if v785 == true {
                                    let v1683 = &constructor_emit_xmm_mem_128_le_const(ctx, 0xf0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f_u128);
                                    let v1684 = constructor_put_in_xmm(ctx, v590);
                                    let v1685 = constructor_x64_pand(ctx, v1684, v1683);
                                    let v1686 = constructor_put_in_xmm(ctx, v590);
                                    let v1688 = &C::xmi_imm(ctx, 0x4_u32);
                                    let v1689 = constructor_x64_psrlw(ctx, v1686, v1688);
                                    let v1690 = constructor_x64_pand(ctx, v1689, v1683);
                                    let v1692 = C::emit_u128_le_const(ctx, 0x4030302030202010302020102010100_u128);
                                    let v1693 = constructor_x64_xmm_load_const(ctx, I8X16, v1692);
                                    let v1694 = &C::xmm_to_xmm_mem_128(ctx, v1685);
                                    let v1695 = constructor_x64_pshufb(ctx, v1693, v1694);
                                    let v1696 = &C::xmm_to_xmm_mem_128(ctx, v1690);
                                    let v1697 = constructor_x64_pshufb(ctx, v1693, v1696);
                                    let v1698 = &C::xmm_to_xmm_mem_128(ctx, v1697);
                                    let v1699 = constructor_x64_paddb(ctx, v1695, v1698);
                                    let v1700 = constructor_output_xmm(ctx, v1699);
                                    let v1701 = Some(v1700);
                                    // Rule at src/isa/x64/lower.isle line 2505.
                                    return v1701;
                                }
                                let v1703 = &constructor_emit_xmm_mem_128_le_const(ctx, 0x77777777777777777777777777777777_u128);
                                let v1684 = constructor_put_in_xmm(ctx, v590);
                                let v886 = &C::xmi_imm(ctx, 0x1_u32);
                                let v1704 = constructor_x64_psrlq(ctx, v1684, v886);
                                let v1705 = constructor_x64_pand(ctx, v1704, v1703);
                                let v1706 = &C::xmm_to_xmm_mem_128(ctx, v1705);
                                let v1707 = constructor_x64_psubb(ctx, v1684, v1706);
                                let v1708 = &C::xmi_imm(ctx, 0x1_u32);
                                let v1709 = constructor_x64_psrlq(ctx, v1705, v1708);
                                let v1710 = constructor_x64_pand(ctx, v1709, v1703);
                                let v1711 = &C::xmm_to_xmm_mem_128(ctx, v1710);
                                let v1712 = constructor_x64_psubb(ctx, v1707, v1711);
                                let v1713 = &C::xmi_imm(ctx, 0x1_u32);
                                let v1714 = constructor_x64_psrlq(ctx, v1710, v1713);
                                let v1715 = constructor_x64_pand(ctx, v1714, v1703);
                                let v1716 = &C::xmm_to_xmm_mem_128(ctx, v1715);
                                let v1717 = constructor_x64_psubb(ctx, v1712, v1716);
                                let v1718 = &C::xmi_imm(ctx, 0x4_u32);
                                let v1719 = constructor_x64_psrlw(ctx, v1717, v1718);
                                let v1720 = &C::xmm_to_xmm_mem_128(ctx, v1719);
                                let v1721 = constructor_x64_paddb(ctx, v1717, v1720);
                                let v1722 = &constructor_emit_xmm_mem_128_le_const(ctx, 0xf0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f_u128);
                                let v1723 = constructor_x64_pand(ctx, v1721, v1722);
                                let v1724 = constructor_output_xmm(ctx, v1723);
                                let v1725 = Some(v1724);
                                // Rule at src/isa/x64/lower.isle line 2521.
                                return v1725;
                            }
                            _ => {}
                        }
                        let v69 = C::ty_32_or_64(ctx, v3);
                        if let Some(v70) = v69 {
                            let v591 = constructor_put_in_gpr(ctx, v590);
                            let v1663 = constructor_do_popcnt(ctx, v70, v591);
                            let v1664 = constructor_output_gpr(ctx, v1663);
                            let v1665 = Some(v1664);
                            // Rule at src/isa/x64/lower.isle line 2400.
                            return v1665;
                        }
                        let v1549 = C::ty_8_or_16(ctx, v3);
                        if let Some(v1550) = v1549 {
                            let v1586 = constructor_extend_to_gpr(ctx, v590, I32, &ExtendKind::Zero);
                            let v1666 = constructor_do_popcnt(ctx, I32, v1586);
                            let v1667 = constructor_output_gpr(ctx, v1666);
                            let v1668 = Some(v1667);
                            // Rule at src/isa/x64/lower.isle line 2405.
                            return v1668;
                        }
                    }
                }
                &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 v1880 = constructor_xmm_zero(ctx, F32X4);
                                let v1881 = &C::put_in_xmm_mem_32(ctx, v590);
                                let v1882 = constructor_x64_sqrtss(ctx, v1880, v1881);
                                let v1883 = constructor_output_xmm(ctx, v1882);
                                let v1884 = Some(v1883);
                                // Rule at src/isa/x64/lower.isle line 2753.
                                return v1884;
                            }
                            F64 => {
                                let v1886 = constructor_xmm_zero(ctx, F64X2);
                                let v1887 = &C::put_in_xmm_mem_64(ctx, v590);
                                let v1888 = constructor_x64_sqrtsd(ctx, v1886, v1887);
                                let v1889 = constructor_output_xmm(ctx, v1888);
                                let v1890 = Some(v1889);
                                // Rule at src/isa/x64/lower.isle line 2755.
                                return v1890;
                            }
                            F32X4 => {
                                let v786 = &C::put_in_xmm_mem_128(ctx, v590);
                                let v1891 = constructor_x64_sqrtps(ctx, v786);
                                let v1892 = constructor_output_xmm(ctx, v1891);
                                let v1893 = Some(v1892);
                                // Rule at src/isa/x64/lower.isle line 2757.
                                return v1893;
                            }
                            F64X2 => {
                                let v786 = &C::put_in_xmm_mem_128(ctx, v590);
                                let v1894 = constructor_x64_sqrtpd(ctx, v786);
                                let v1895 = constructor_output_xmm(ctx, v1894);
                                let v1896 = Some(v1895);
                                // Rule at src/isa/x64/lower.isle line 2759.
                                return v1896;
                            }
                            _ => {}
                        }
                    }
                }
                &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 v790 = constructor_put_in_xmm(ctx, v590);
                                let v898 = constructor_imm(ctx, F32, 0x80000000_u64);
                                let v899 = C::xmm_new(ctx, v898);
                                let v900 = &C::xmm_to_xmm_mem_128(ctx, v899);
                                let v901 = constructor_x64_xorps(ctx, v790, v900);
                                let v902 = constructor_output_xmm(ctx, v901);
                                let v903 = Some(v902);
                                // Rule at src/isa/x64/lower.isle line 1420.
                                return v903;
                            }
                            F64 => {
                                let v790 = constructor_put_in_xmm(ctx, v590);
                                let v905 = constructor_imm(ctx, F64, 0x8000000000000000_u64);
                                let v906 = C::xmm_new(ctx, v905);
                                let v907 = &C::xmm_to_xmm_mem_128(ctx, v906);
                                let v908 = constructor_x64_xorpd(ctx, v790, v907);
                                let v909 = constructor_output_xmm(ctx, v908);
                                let v910 = Some(v909);
                                // Rule at src/isa/x64/lower.isle line 1423.
                                return v910;
                            }
                            F32X4 => {
                                let v790 = constructor_put_in_xmm(ctx, v590);
                                let v885 = constructor_vector_all_ones(ctx);
                                let v911 = &C::xmi_imm(ctx, 0x1f_u32);
                                let v912 = constructor_x64_pslld(ctx, v885, v911);
                                let v913 = &C::xmm_to_xmm_mem_128(ctx, v912);
                                let v914 = constructor_x64_xorps(ctx, v790, v913);
                                let v915 = constructor_output_xmm(ctx, v914);
                                let v916 = Some(v915);
                                // Rule at src/isa/x64/lower.isle line 1426.
                                return v916;
                            }
                            F64X2 => {
                                let v790 = constructor_put_in_xmm(ctx, v590);
                                let v885 = constructor_vector_all_ones(ctx);
                                let v917 = &C::xmi_imm(ctx, 0x3f_u32);
                                let v918 = constructor_x64_psllq(ctx, v885, v917);
                                let v919 = &C::xmm_to_xmm_mem_128(ctx, v918);
                                let v920 = constructor_x64_xorpd(ctx, v790, v919);
                                let v921 = constructor_output_xmm(ctx, v920);
                                let v922 = Some(v921);
                                // Rule at src/isa/x64/lower.isle line 1430.
                                return v922;
                            }
                            _ => {}
                        }
                    }
                }
                &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 v790 = constructor_put_in_xmm(ctx, v590);
                                let v872 = constructor_imm(ctx, F32, 0x7fffffff_u64);
                                let v873 = C::xmm_new(ctx, v872);
                                let v874 = &C::xmm_to_xmm_mem_128(ctx, v873);
                                let v875 = constructor_x64_andps(ctx, v790, v874);
                                let v876 = constructor_output_xmm(ctx, v875);
                                let v877 = Some(v876);
                                // Rule at src/isa/x64/lower.isle line 1402.
                                return v877;
                            }
                            F64 => {
                                let v790 = constructor_put_in_xmm(ctx, v590);
                                let v879 = constructor_imm(ctx, F64, 0x7fffffffffffffff_u64);
                                let v880 = C::xmm_new(ctx, v879);
                                let v881 = &C::xmm_to_xmm_mem_128(ctx, v880);
                                let v882 = constructor_x64_andpd(ctx, v790, v881);
                                let v883 = constructor_output_xmm(ctx, v882);
                                let v884 = Some(v883);
                                // Rule at src/isa/x64/lower.isle line 1405.
                                return v884;
                            }
                            F32X4 => {
                                let v790 = constructor_put_in_xmm(ctx, v590);
                                let v885 = constructor_vector_all_ones(ctx);
                                let v886 = &C::xmi_imm(ctx, 0x1_u32);
                                let v887 = constructor_x64_psrld(ctx, v885, v886);
                                let v888 = &C::xmm_to_xmm_mem_128(ctx, v887);
                                let v889 = constructor_x64_andps(ctx, v790, v888);
                                let v890 = constructor_output_xmm(ctx, v889);
                                let v891 = Some(v890);
                                // Rule at src/isa/x64/lower.isle line 1409.
                                return v891;
                            }
                            F64X2 => {
                                let v790 = constructor_put_in_xmm(ctx, v590);
                                let v885 = constructor_vector_all_ones(ctx);
                                let v886 = &C::xmi_imm(ctx, 0x1_u32);
                                let v892 = constructor_x64_psrlq(ctx, v885, v886);
                                let v893 = &C::xmm_to_xmm_mem_128(ctx, v892);
                                let v894 = constructor_x64_andpd(ctx, v790, v893);
                                let v895 = constructor_output_xmm(ctx, v894);
                                let v896 = Some(v895);
                                // Rule at src/isa/x64/lower.isle line 1414.
                                return v896;
                            }
                            _ => {}
                        }
                    }
                }
                &Opcode::Ceil => {
                    let v923 = C::value_type(ctx, v590);
                    let v3032 = constructor_x64_round(ctx, v923, v590, &RoundImm::RoundUp);
                    let v3033 = constructor_output_xmm(ctx, v3032);
                    let v3034 = Some(v3033);
                    // Rule at src/isa/x64/lower.isle line 4413.
                    return v3034;
                }
                &Opcode::Floor => {
                    let v923 = C::value_type(ctx, v590);
                    let v3036 = constructor_x64_round(ctx, v923, v590, &RoundImm::RoundDown);
                    let v3037 = constructor_output_xmm(ctx, v3036);
                    let v3038 = Some(v3037);
                    // Rule at src/isa/x64/lower.isle line 4418.
                    return v3038;
                }
                &Opcode::Trunc => {
                    let v923 = C::value_type(ctx, v590);
                    let v3044 = constructor_x64_round(ctx, v923, v590, &RoundImm::RoundZero);
                    let v3045 = constructor_output_xmm(ctx, v3044);
                    let v3046 = Some(v3045);
                    // Rule at src/isa/x64/lower.isle line 4428.
                    return v3046;
                }
                &Opcode::Nearest => {
                    let v923 = C::value_type(ctx, v590);
                    let v3040 = constructor_x64_round(ctx, v923, v590, &RoundImm::RoundNearest);
                    let v3041 = constructor_output_xmm(ctx, v3040);
                    let v3042 = Some(v3041);
                    // Rule at src/isa/x64/lower.isle line 4423.
                    return v3042;
                }
                &Opcode::ScalarToVector => {
                    let v3350 = &C::sinkable_load(ctx, v590);
                    if let Some(v3351) = v3350 {
                        let v923 = C::value_type(ctx, v590);
                        let v3358 = C::ty_64(ctx, v923);
                        if let Some(v3359) = v3358 {
                            let v3354 = &C::sink_load(ctx, v3351);
                            let v3360 = constructor_x64_movsd_load(ctx, v3354);
                            let v3361 = constructor_output_xmm(ctx, v3360);
                            let v3362 = Some(v3361);
                            // Rule at src/isa/x64/lower.isle line 4858.
                            return v3362;
                        }
                        let v3352 = C::ty_32(ctx, v923);
                        if let Some(v3353) = v3352 {
                            let v3354 = &C::sink_load(ctx, v3351);
                            let v3355 = constructor_x64_movss_load(ctx, v3354);
                            let v3356 = constructor_output_xmm(ctx, v3355);
                            let v3357 = Some(v3356);
                            // Rule at src/isa/x64/lower.isle line 4856.
                            return v3357;
                        }
                    }
                    let v923 = C::value_type(ctx, v590);
                    match v923 {
                        F32 => {
                            let v1880 = constructor_xmm_zero(ctx, F32X4);
                            let v1684 = constructor_put_in_xmm(ctx, v590);
                            let v3340 = constructor_x64_movss_regmove(ctx, v1880, v1684);
                            let v3341 = constructor_output_xmm(ctx, v3340);
                            let v3342 = Some(v3341);
                            // Rule at src/isa/x64/lower.isle line 4844.
                            return v3342;
                        }
                        F64 => {
                            let v1886 = constructor_xmm_zero(ctx, F64X2);
                            let v1684 = constructor_put_in_xmm(ctx, v590);
                            let v3343 = constructor_x64_movsd_regmove(ctx, v1886, v1684);
                            let v3344 = constructor_output_xmm(ctx, v3343);
                            let v3345 = Some(v3344);
                            // Rule at src/isa/x64/lower.isle line 4846.
                            return v3345;
                        }
                        _ => {}
                    }
                    let v591 = constructor_put_in_gpr(ctx, v590);
                    let v3346 = C::ty_bits(ctx, v923);
                    let v3347 = constructor_bitcast_gpr_to_xmm(ctx, v3346, v591);
                    let v3348 = constructor_output_xmm(ctx, v3347);
                    let v3349 = Some(v3348);
                    // Rule at src/isa/x64/lower.isle line 4851.
                    return v3349;
                }
                &Opcode::Bmask => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v595 = C::put_in_regs(ctx, v590);
                        let v3 = C::value_type(ctx, v2);
                        let v923 = C::value_type(ctx, v590);
                        let v924 = constructor_lower_bmask(ctx, v3, v923, v595);
                        let v925 = C::output(ctx, v924);
                        let v926 = Some(v925);
                        // Rule at src/isa/x64/lower.isle line 1476.
                        return v926;
                    }
                }
                &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 v595 = C::put_in_regs(ctx, v590);
                            let v596 = constructor_value_regs_get_gpr(ctx, v595, 0x0_usize);
                            let v1786 = constructor_output_gpr(ctx, v596);
                            let v1787 = Some(v1786);
                            // Rule at src/isa/x64/lower.isle line 2672.
                            return v1787;
                        }
                        let v923 = C::value_type(ctx, v590);
                        if v3 == v923 {
                            let v1784 = constructor_output_value(ctx, v590);
                            let v1785 = Some(v1784);
                            // Rule at src/isa/x64/lower.isle line 2666.
                            return v1785;
                        }
                    }
                }
                &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 v692 = C::has_sse41(ctx);
                                if v692 == true {
                                    let v923 = C::value_type(ctx, v590);
                                    if v923 == I8X16 {
                                        let v790 = constructor_put_in_xmm(ctx, v590);
                                        let v1900 = &C::xmm_to_xmm_mem_64(ctx, v790);
                                        let v2884 = constructor_x64_pmovsxbw(ctx, v1900);
                                        let v2885 = constructor_output_xmm(ctx, v2884);
                                        let v2886 = Some(v2885);
                                        // Rule at src/isa/x64/lower.isle line 4106.
                                        return v2886;
                                    }
                                }
                            }
                            I32X4 => {
                                let v692 = C::has_sse41(ctx);
                                if v692 == true {
                                    let v923 = C::value_type(ctx, v590);
                                    if v923 == I16X8 {
                                        let v790 = constructor_put_in_xmm(ctx, v590);
                                        let v1900 = &C::xmm_to_xmm_mem_64(ctx, v790);
                                        let v2887 = constructor_x64_pmovsxwd(ctx, v1900);
                                        let v2888 = constructor_output_xmm(ctx, v2887);
                                        let v2889 = Some(v2888);
                                        // Rule at src/isa/x64/lower.isle line 4109.
                                        return v2889;
                                    }
                                }
                            }
                            I64X2 => {
                                let v692 = C::has_sse41(ctx);
                                if v692 == true {
                                    let v923 = C::value_type(ctx, v590);
                                    if v923 == I32X4 {
                                        let v790 = constructor_put_in_xmm(ctx, v590);
                                        let v1900 = &C::xmm_to_xmm_mem_64(ctx, v790);
                                        let v2890 = constructor_x64_pmovsxdq(ctx, v1900);
                                        let v2891 = constructor_output_xmm(ctx, v2890);
                                        let v2892 = Some(v2891);
                                        // Rule at src/isa/x64/lower.isle line 4112.
                                        return v2892;
                                    }
                                }
                            }
                            _ => {}
                        }
                        let v790 = constructor_put_in_xmm(ctx, v590);
                        let v2893 = constructor_lower_swiden_low(ctx, v3, v790);
                        let v2894 = constructor_output_xmm(ctx, v2893);
                        let v2895 = Some(v2894);
                        // Rule at src/isa/x64/lower.isle line 4116.
                        return v2895;
                    }
                }
                &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 v923 = C::value_type(ctx, v590);
                                if v923 == I8X16 {
                                    let v692 = C::has_sse41(ctx);
                                    if v692 == true {
                                        let v785 = C::has_ssse3(ctx);
                                        if v785 == true {
                                            let v790 = constructor_put_in_xmm(ctx, v590);
                                            let v2728 = &C::xmm_to_xmm_mem_128(ctx, v790);
                                            let v2896 = constructor_x64_palignr(ctx, v790, v2728, 0x8_u8);
                                            let v2897 = &C::xmm_to_xmm_mem_64(ctx, v2896);
                                            let v2898 = constructor_x64_pmovsxbw(ctx, v2897);
                                            let v2899 = constructor_output_xmm(ctx, v2898);
                                            let v2900 = Some(v2899);
                                            // Rule at src/isa/x64/lower.isle line 4139.
                                            return v2900;
                                        }
                                    }
                                    let v790 = constructor_put_in_xmm(ctx, v590);
                                    let v2728 = &C::xmm_to_xmm_mem_128(ctx, v790);
                                    let v2909 = constructor_x64_punpckhbw(ctx, v790, v2728);
                                    let v2910 = &C::xmi_imm(ctx, 0x8_u32);
                                    let v2911 = constructor_x64_psraw(ctx, v2909, v2910);
                                    let v2912 = constructor_output_xmm(ctx, v2911);
                                    let v2913 = Some(v2912);
                                    // Rule at src/isa/x64/lower.isle line 4155.
                                    return v2913;
                                }
                            }
                            I32X4 => {
                                let v923 = C::value_type(ctx, v590);
                                if v923 == I16X8 {
                                    let v692 = C::has_sse41(ctx);
                                    if v692 == true {
                                        let v785 = C::has_ssse3(ctx);
                                        if v785 == true {
                                            let v790 = constructor_put_in_xmm(ctx, v590);
                                            let v2728 = &C::xmm_to_xmm_mem_128(ctx, v790);
                                            let v2896 = constructor_x64_palignr(ctx, v790, v2728, 0x8_u8);
                                            let v2897 = &C::xmm_to_xmm_mem_64(ctx, v2896);
                                            let v2901 = constructor_x64_pmovsxwd(ctx, v2897);
                                            let v2902 = constructor_output_xmm(ctx, v2901);
                                            let v2903 = Some(v2902);
                                            // Rule at src/isa/x64/lower.isle line 4144.
                                            return v2903;
                                        }
                                    }
                                    let v790 = constructor_put_in_xmm(ctx, v590);
                                    let v2728 = &C::xmm_to_xmm_mem_128(ctx, v790);
                                    let v2914 = constructor_x64_punpckhwd(ctx, v790, v2728);
                                    let v2698 = &C::xmi_imm(ctx, 0x10_u32);
                                    let v2915 = constructor_x64_psrad(ctx, v2914, v2698);
                                    let v2916 = constructor_output_xmm(ctx, v2915);
                                    let v2917 = Some(v2916);
                                    // Rule at src/isa/x64/lower.isle line 4158.
                                    return v2917;
                                }
                            }
                            I64X2 => {
                                let v923 = C::value_type(ctx, v590);
                                if v923 == I32X4 {
                                    let v692 = C::has_sse41(ctx);
                                    if v692 == true {
                                        let v786 = &C::put_in_xmm_mem_128(ctx, v590);
                                        let v2904 = constructor_x64_pshufd(ctx, v786, 0xee_u8);
                                        let v2905 = &C::xmm_to_xmm_mem_64(ctx, v2904);
                                        let v2906 = constructor_x64_pmovsxdq(ctx, v2905);
                                        let v2907 = constructor_output_xmm(ctx, v2906);
                                        let v2908 = Some(v2907);
                                        // Rule at src/isa/x64/lower.isle line 4149.
                                        return v2908;
                                    }
                                    let v786 = &C::put_in_xmm_mem_128(ctx, v590);
                                    let v2919 = constructor_x64_pshufd(ctx, v786, 0xe_u8);
                                    let v2920 = constructor_xmm_zero(ctx, I32X4);
                                    let v2921 = &C::xmm_to_xmm_mem_aligned_128(ctx, v2919);
                                    let v2922 = constructor_x64_pcmpgtd_a(ctx, v2920, v2921);
                                    let v2923 = &C::xmm_to_xmm_mem_128(ctx, v2922);
                                    let v2924 = constructor_x64_punpckldq(ctx, v2919, v2923);
                                    let v2925 = constructor_output_xmm(ctx, v2924);
                                    let v2926 = Some(v2925);
                                    // Rule at src/isa/x64/lower.isle line 4163.
                                    return v2926;
                                }
                            }
                            _ => {}
                        }
                    }
                }
                &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 v692 = C::has_sse41(ctx);
                                if v692 == true {
                                    let v923 = C::value_type(ctx, v590);
                                    if v923 == I8X16 {
                                        let v790 = constructor_put_in_xmm(ctx, v590);
                                        let v1900 = &C::xmm_to_xmm_mem_64(ctx, v790);
                                        let v2927 = constructor_x64_pmovzxbw(ctx, v1900);
                                        let v2928 = constructor_output_xmm(ctx, v2927);
                                        let v2929 = Some(v2928);
                                        // Rule at src/isa/x64/lower.isle line 4172.
                                        return v2929;
                                    }
                                }
                            }
                            I32X4 => {
                                let v692 = C::has_sse41(ctx);
                                if v692 == true {
                                    let v923 = C::value_type(ctx, v590);
                                    if v923 == I16X8 {
                                        let v790 = constructor_put_in_xmm(ctx, v590);
                                        let v1900 = &C::xmm_to_xmm_mem_64(ctx, v790);
                                        let v2930 = constructor_x64_pmovzxwd(ctx, v1900);
                                        let v2931 = constructor_output_xmm(ctx, v2930);
                                        let v2932 = Some(v2931);
                                        // Rule at src/isa/x64/lower.isle line 4175.
                                        return v2932;
                                    }
                                }
                            }
                            I64X2 => {
                                let v692 = C::has_sse41(ctx);
                                if v692 == true {
                                    let v923 = C::value_type(ctx, v590);
                                    if v923 == I32X4 {
                                        let v790 = constructor_put_in_xmm(ctx, v590);
                                        let v1900 = &C::xmm_to_xmm_mem_64(ctx, v790);
                                        let v2933 = constructor_x64_pmovzxdq(ctx, v1900);
                                        let v2934 = constructor_output_xmm(ctx, v2933);
                                        let v2935 = Some(v2934);
                                        // Rule at src/isa/x64/lower.isle line 4178.
                                        return v2935;
                                    }
                                }
                            }
                            _ => {}
                        }
                        let v790 = constructor_put_in_xmm(ctx, v590);
                        let v2936 = constructor_lower_uwiden_low(ctx, v3, v790);
                        let v2937 = constructor_output_xmm(ctx, v2936);
                        let v2938 = Some(v2937);
                        // Rule at src/isa/x64/lower.isle line 4182.
                        return v2938;
                    }
                }
                &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 v923 = C::value_type(ctx, v590);
                                if v923 == I8X16 {
                                    let v790 = constructor_put_in_xmm(ctx, v590);
                                    let v791 = constructor_xmm_zero(ctx, I8X16);
                                    let v2939 = &C::xmm_to_xmm_mem_128(ctx, v791);
                                    let v2940 = constructor_x64_punpckhbw(ctx, v790, v2939);
                                    let v2941 = constructor_output_xmm(ctx, v2940);
                                    let v2942 = Some(v2941);
                                    // Rule at src/isa/x64/lower.isle line 4197.
                                    return v2942;
                                }
                            }
                            I32X4 => {
                                let v923 = C::value_type(ctx, v590);
                                if v923 == I16X8 {
                                    let v790 = constructor_put_in_xmm(ctx, v590);
                                    let v791 = constructor_xmm_zero(ctx, I8X16);
                                    let v2939 = &C::xmm_to_xmm_mem_128(ctx, v791);
                                    let v2943 = constructor_x64_punpckhwd(ctx, v790, v2939);
                                    let v2944 = constructor_output_xmm(ctx, v2943);
                                    let v2945 = Some(v2944);
                                    // Rule at src/isa/x64/lower.isle line 4199.
                                    return v2945;
                                }
                            }
                            I64X2 => {
                                let v923 = C::value_type(ctx, v590);
                                if v923 == I32X4 {
                                    let v790 = constructor_put_in_xmm(ctx, v590);
                                    let v2744 = constructor_xmm_zero(ctx, F32X4);
                                    let v2745 = &C::xmm_to_xmm_mem_128(ctx, v2744);
                                    let v2946 = constructor_x64_unpckhps(ctx, v790, v2745);
                                    let v2947 = constructor_output_xmm(ctx, v2946);
                                    let v2948 = Some(v2947);
                                    // Rule at src/isa/x64/lower.isle line 4201.
                                    return v2948;
                                }
                            }
                            _ => {}
                        }
                    }
                }
                &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 v1551 = constructor_extend_to_gpr(ctx, v590, I64, &ExtendKind::Zero);
                                let v1767 = constructor_output_gpr(ctx, v1551);
                                let v1768 = Some(v1767);
                                // Rule at src/isa/x64/lower.isle line 2635.
                                return v1768;
                            }
                            I128 => {
                                let v1551 = constructor_extend_to_gpr(ctx, v590, I64, &ExtendKind::Zero);
                                let v1762 = C::gpr_to_reg(ctx, v1551);
                                let v1763 = constructor_imm(ctx, I64, 0x0_u64);
                                let v1764 = C::value_regs(ctx, v1762, v1763);
                                let v1765 = C::output(ctx, v1764);
                                let v1766 = Some(v1765);
                                // Rule at src/isa/x64/lower.isle line 2631.
                                return v1766;
                            }
                            _ => {}
                        }
                        let v1769 = C::fits_in_32(ctx, v3);
                        if let Some(v1770) = v1769 {
                            let v1586 = constructor_extend_to_gpr(ctx, v590, I32, &ExtendKind::Zero);
                            let v1771 = constructor_output_gpr(ctx, v1586);
                            let v1772 = Some(v1771);
                            // Rule at src/isa/x64/lower.isle line 2640.
                            return v1772;
                        }
                    }
                }
                &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 v1773 = constructor_extend_to_gpr(ctx, v590, I64, &ExtendKind::Sign);
                                let v1780 = constructor_output_gpr(ctx, v1773);
                                let v1781 = Some(v1780);
                                // Rule at src/isa/x64/lower.isle line 2655.
                                return v1781;
                            }
                            I128 => {
                                let v1773 = constructor_extend_to_gpr(ctx, v590, I64, &ExtendKind::Sign);
                                let v1774 = constructor_x64_sarq_mi(ctx, v1773, 0x3f_u8);
                                let v1775 = C::gpr_to_reg(ctx, v1773);
                                let v1776 = C::gpr_to_reg(ctx, v1774);
                                let v1777 = C::value_regs(ctx, v1775, v1776);
                                let v1778 = C::output(ctx, v1777);
                                let v1779 = Some(v1778);
                                // Rule at src/isa/x64/lower.isle line 2649.
                                return v1779;
                            }
                            _ => {}
                        }
                        let v1769 = C::fits_in_32(ctx, v3);
                        if let Some(v1770) = v1769 {
                            let v1612 = constructor_extend_to_gpr(ctx, v590, I32, &ExtendKind::Sign);
                            let v1782 = constructor_output_gpr(ctx, v1612);
                            let v1783 = Some(v1782);
                            // Rule at src/isa/x64/lower.isle line 2660.
                            return v1783;
                        }
                    }
                }
                &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 v1886 = constructor_xmm_zero(ctx, F64X2);
                            let v1881 = &C::put_in_xmm_mem_32(ctx, v590);
                            let v1897 = constructor_x64_cvtss2sd(ctx, v1886, v1881);
                            let v1898 = constructor_output_xmm(ctx, v1897);
                            let v1899 = Some(v1898);
                            // Rule at src/isa/x64/lower.isle line 2763.
                            return v1899;
                        }
                    }
                }
                &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 v1880 = constructor_xmm_zero(ctx, F32X4);
                            let v1887 = &C::put_in_xmm_mem_64(ctx, v590);
                            let v1904 = constructor_x64_cvtsd2ss(ctx, v1880, v1887);
                            let v1905 = constructor_output_xmm(ctx, v1904);
                            let v1906 = Some(v1905);
                            // Rule at src/isa/x64/lower.isle line 2771.
                            return v1906;
                        }
                    }
                }
                &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 v786 = &C::put_in_xmm_mem_128(ctx, v590);
                            let v1907 = constructor_x64_cvtpd2ps(ctx, v786);
                            let v1908 = constructor_output_xmm(ctx, v1907);
                            let v1909 = Some(v1908);
                            // Rule at src/isa/x64/lower.isle line 2775.
                            return v1909;
                        }
                    }
                }
                &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 v790 = constructor_put_in_xmm(ctx, v590);
                            let v1900 = &C::xmm_to_xmm_mem_64(ctx, v790);
                            let v1901 = constructor_x64_cvtps2pd(ctx, v1900);
                            let v1902 = constructor_output_xmm(ctx, v1901);
                            let v1903 = Some(v1902);
                            // Rule at src/isa/x64/lower.isle line 2767.
                            return v1903;
                        }
                    }
                }
                &Opcode::FcvtToUint => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v923 = C::value_type(ctx, v590);
                        let v2714 = C::ty_scalar_float(ctx, v923);
                        if let Some(v2715) = v2714 {
                            let v3 = C::value_type(ctx, v2);
                            let v197 = false;
                            let v2716 = constructor_cvt_float_to_uint_seq(ctx, v3, v590, v197);
                            let v2717 = constructor_output_gpr(ctx, v2716);
                            let v2718 = Some(v2717);
                            // Rule at src/isa/x64/lower.isle line 3854.
                            return v2718;
                        }
                    }
                }
                &Opcode::FcvtToSint => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v923 = C::value_type(ctx, v590);
                        let v2714 = C::ty_scalar_float(ctx, v923);
                        if let Some(v2715) = v2714 {
                            let v3 = C::value_type(ctx, v2);
                            let v197 = false;
                            let v2722 = constructor_cvt_float_to_sint_seq(ctx, v3, v590, v197);
                            let v2723 = constructor_output_gpr(ctx, v2722);
                            let v2724 = Some(v2723);
                            // Rule at src/isa/x64/lower.isle line 3860.
                            return v2724;
                        }
                    }
                }
                &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 v923 = C::value_type(ctx, v590);
                            if v923 == F32X4 {
                                let v790 = constructor_put_in_xmm(ctx, v590);
                                let v2744 = constructor_xmm_zero(ctx, F32X4);
                                let v2745 = &C::xmm_to_xmm_mem_128(ctx, v2744);
                                let v2746 = constructor_x64_maxps(ctx, v790, v2745);
                                let v2747 = &C::xmm_to_xmm_mem_128(ctx, v2744);
                                let v2748 = constructor_x64_pcmpeqd(ctx, v2744, v2747);
                                let v2749 = &C::xmi_imm(ctx, 0x1_u32);
                                let v2750 = constructor_x64_psrld(ctx, v2748, v2749);
                                let v2751 = &C::xmm_to_xmm_mem_128(ctx, v2750);
                                let v2752 = constructor_x64_cvtdq2ps(ctx, v2751);
                                let v2753 = &C::xmm_to_xmm_mem_128(ctx, v2746);
                                let v2754 = constructor_x64_cvttps2dq(ctx, v2753);
                                let v2755 = &C::xmm_to_xmm_mem_128(ctx, v2752);
                                let v2756 = constructor_x64_subps(ctx, v2746, v2755);
                                let v2757 = &C::xmm_to_xmm_mem_128(ctx, v2756);
                                let v2758 = constructor_x64_cmpps(ctx, v2752, v2757, &FcmpImm::LessThanOrEqual);
                                let v2759 = &C::xmm_to_xmm_mem_128(ctx, v2756);
                                let v2760 = constructor_x64_cvttps2dq(ctx, v2759);
                                let v2761 = &C::xmm_to_xmm_mem_128(ctx, v2758);
                                let v2762 = constructor_x64_pxor(ctx, v2760, v2761);
                                let v2763 = constructor_xmm_zero(ctx, I32X4);
                                let v2764 = constructor_lower_vec_smax(ctx, I32X4, v2762, v2763);
                                let v2765 = &C::xmm_to_xmm_mem_128(ctx, v2754);
                                let v2766 = constructor_x64_paddd(ctx, v2764, v2765);
                                let v2767 = constructor_output_xmm(ctx, v2766);
                                let v2768 = Some(v2767);
                                // Rule at src/isa/x64/lower.isle line 3938.
                                return v2768;
                            }
                        }
                        let v923 = C::value_type(ctx, v590);
                        let v2714 = C::ty_scalar_float(ctx, v923);
                        if let Some(v2715) = v2714 {
                            let v207 = true;
                            let v2719 = constructor_cvt_float_to_uint_seq(ctx, v3, v590, v207);
                            let v2720 = constructor_output_gpr(ctx, v2719);
                            let v2721 = Some(v2720);
                            // Rule at src/isa/x64/lower.isle line 3857.
                            return v2721;
                        }
                    }
                }
                &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 v923 = C::value_type(ctx, v590);
                            if v923 == F32X4 {
                                let v790 = constructor_put_in_xmm(ctx, v590);
                                let v2728 = &C::xmm_to_xmm_mem_128(ctx, v790);
                                let v2729 = constructor_x64_cmpps(ctx, v790, v2728, &FcmpImm::Equal);
                                let v2730 = &C::xmm_to_xmm_mem_128(ctx, v2729);
                                let v2731 = constructor_x64_andps(ctx, v790, v2730);
                                let v2732 = &C::xmm_to_xmm_mem_128(ctx, v2731);
                                let v2733 = constructor_x64_pxor(ctx, v2729, v2732);
                                let v2734 = &C::xmm_to_xmm_mem_128(ctx, v2731);
                                let v2735 = constructor_x64_cvttps2dq(ctx, v2734);
                                let v2736 = &C::xmm_to_xmm_mem_128(ctx, v2733);
                                let v2737 = constructor_x64_pand(ctx, v2735, v2736);
                                let v2738 = &C::xmi_imm(ctx, 0x1f_u32);
                                let v2739 = constructor_x64_psrad(ctx, v2737, v2738);
                                let v2740 = &C::xmm_to_xmm_mem_128(ctx, v2735);
                                let v2741 = constructor_x64_pxor(ctx, v2739, v2740);
                                let v2742 = constructor_output_xmm(ctx, v2741);
                                let v2743 = Some(v2742);
                                // Rule at src/isa/x64/lower.isle line 3867.
                                return v2743;
                            }
                        }
                        let v923 = C::value_type(ctx, v590);
                        let v2714 = C::ty_scalar_float(ctx, v923);
                        if let Some(v2715) = v2714 {
                            let v207 = true;
                            let v2725 = constructor_cvt_float_to_sint_seq(ctx, v3, v590, v207);
                            let v2726 = constructor_output_gpr(ctx, v2725);
                            let v2727 = Some(v2726);
                            // Rule at src/isa/x64/lower.isle line 3863.
                            return v2727;
                        }
                    }
                }
                &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 v923 = C::value_type(ctx, v590);
                            if v923 == F32X4 {
                                let v786 = &C::put_in_xmm_mem_128(ctx, v590);
                                let v2769 = constructor_x64_cvttps2dq(ctx, v786);
                                let v2770 = constructor_output_xmm(ctx, v2769);
                                let v2771 = Some(v2770);
                                // Rule at src/isa/x64/lower.isle line 3985.
                                return v2771;
                            }
                        }
                    }
                }
                &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 v923 = C::value_type(ctx, v590);
                                let v2649 = C::fits_in_32(ctx, v923);
                                if let Some(v2650) = v2649 {
                                    let v2651 = C::ty_int(ctx, v2650);
                                    if let Some(v2652) = v2651 {
                                        let v1880 = constructor_xmm_zero(ctx, F32X4);
                                        let v2653 = constructor_extend_to_gpr(ctx, v590, I64, &ExtendKind::Zero);
                                        let v2654 = &C::gpr_to_gpr_mem(ctx, v2653);
                                        let v2655 = constructor_x64_cvtsi2ss(ctx, I64, v1880, v2654);
                                        let v2656 = constructor_output_xmm(ctx, v2655);
                                        let v2657 = Some(v2656);
                                        // Rule at src/isa/x64/lower.isle line 3742.
                                        return v2657;
                                    }
                                }
                            }
                            F64 => {
                                let v923 = C::value_type(ctx, v590);
                                let v2649 = C::fits_in_32(ctx, v923);
                                if let Some(v2650) = v2649 {
                                    let v2651 = C::ty_int(ctx, v2650);
                                    if let Some(v2652) = v2651 {
                                        let v1886 = constructor_xmm_zero(ctx, F64X2);
                                        let v2653 = constructor_extend_to_gpr(ctx, v590, I64, &ExtendKind::Zero);
                                        let v2654 = &C::gpr_to_gpr_mem(ctx, v2653);
                                        let v2658 = constructor_x64_cvtsi2sd(ctx, I64, v1886, v2654);
                                        let v2659 = constructor_output_xmm(ctx, v2658);
                                        let v2660 = Some(v2659);
                                        // Rule at src/isa/x64/lower.isle line 3745.
                                        return v2660;
                                    }
                                }
                            }
                            F32X4 => {
                                let v533 = C::has_avx512vl(ctx);
                                if v533 == true {
                                    let v534 = C::has_avx512f(ctx);
                                    if v534 == true {
                                        let v786 = &C::put_in_xmm_mem_128(ctx, v590);
                                        let v2692 = constructor_x64_vcvtudq2ps(ctx, v786);
                                        let v2693 = constructor_output_xmm(ctx, v2692);
                                        let v2694 = Some(v2693);
                                        // Rule at src/isa/x64/lower.isle line 3802.
                                        return v2694;
                                    }
                                }
                                let v790 = constructor_put_in_xmm(ctx, v590);
                                let v2696 = &C::xmi_imm(ctx, 0x10_u32);
                                let v2697 = constructor_x64_pslld(ctx, v790, v2696);
                                let v2698 = &C::xmi_imm(ctx, 0x10_u32);
                                let v2699 = constructor_x64_psrld(ctx, v2697, v2698);
                                let v2700 = &C::xmm_to_xmm_mem_128(ctx, v2699);
                                let v2701 = constructor_x64_psubd(ctx, v790, v2700);
                                let v2702 = &C::xmm_to_xmm_mem_128(ctx, v2699);
                                let v2703 = constructor_x64_cvtdq2ps(ctx, v2702);
                                let v2704 = &C::xmi_imm(ctx, 0x1_u32);
                                let v2705 = constructor_x64_psrld(ctx, v2701, v2704);
                                let v2706 = &C::xmm_to_xmm_mem_128(ctx, v2705);
                                let v2707 = constructor_x64_cvtdq2ps(ctx, v2706);
                                let v2708 = &C::xmm_to_xmm_mem_128(ctx, v2707);
                                let v2709 = constructor_x64_addps(ctx, v2707, v2708);
                                let v2710 = &C::xmm_to_xmm_mem_128(ctx, v2703);
                                let v2711 = constructor_x64_addps(ctx, v2709, v2710);
                                let v2712 = constructor_output_xmm(ctx, v2711);
                                let v2713 = Some(v2712);
                                // Rule at src/isa/x64/lower.isle line 3830.
                                return v2713;
                            }
                            F64X2 => {
                                let v2636 = C::def_inst(ctx, v590);
                                if let Some(v2637) = v2636 {
                                    let v2638 = C::inst_data_value(ctx, v2637);
                                    if let &InstructionData::Unary {
                                        opcode: ref v2641,
                                        arg: v2642,
                                    } = &v2638.1 {
                                        if let &Opcode::UwidenLow = v2641 {
                                            let v2643 = C::value_type(ctx, v2642);
                                            if v2643 == I32X4 {
                                                let v2685 = &constructor_emit_xmm_mem_128_le_const(ctx, 0x4330000043300000_u128);
                                                let v2686 = constructor_put_in_xmm(ctx, v2642);
                                                let v2687 = constructor_x64_unpcklps(ctx, v2686, v2685);
                                                let v2688 = &constructor_emit_xmm_mem_128_le_const(ctx, 0x43300000000000004330000000000000_u128);
                                                let v2689 = constructor_x64_subpd(ctx, v2687, v2688);
                                                let v2690 = constructor_output_xmm(ctx, v2689);
                                                let v2691 = Some(v2690);
                                                // Rule at src/isa/x64/lower.isle line 3794.
                                                return v2691;
                                            }
                                        }
                                    }
                                }
                            }
                            _ => {}
                        }
                        let v923 = C::value_type(ctx, v590);
                        match v923 {
                            I64 => {
                                let v591 = constructor_put_in_gpr(ctx, v590);
                                let v2661 = constructor_cvt_u64_to_float_seq(ctx, v3, v591);
                                let v2662 = constructor_output_xmm(ctx, v2661);
                                let v2663 = Some(v2662);
                                // Rule at src/isa/x64/lower.isle line 3748.
                                return v2663;
                            }
                            I64X2 => {
                                if v3 == F64X2 {
                                    let v2665 = &constructor_emit_xmm_mem_128_le_const(ctx, 0xffffffff00000000ffffffff_u128);
                                    let v2667 = &constructor_emit_xmm_mem_128_le_const(ctx, 0x43300000000000004330000000000000_u128);
                                    let v2669 = &constructor_emit_xmm_mem_128_le_const(ctx, 0x45300000000000004530000000000000_u128);
                                    let v2671 = &constructor_emit_xmm_mem_128_le_const(ctx, 0x45300000001000004530000000100000_u128);
                                    let v2672 = constructor_put_in_xmm(ctx, v590);
                                    let v2673 = constructor_x64_pand(ctx, v2672, v2665);
                                    let v2674 = constructor_x64_por(ctx, v2673, v2667);
                                    let v2675 = constructor_put_in_xmm(ctx, v590);
                                    let v2676 = &C::xmi_imm(ctx, 0x20_u32);
                                    let v2677 = constructor_x64_psrlq(ctx, v2675, v2676);
                                    let v2678 = constructor_x64_por(ctx, v2677, v2669);
                                    let v2679 = constructor_x64_subpd(ctx, v2678, v2671);
                                    let v2680 = &C::xmm_to_xmm_mem_128(ctx, v2679);
                                    let v2681 = constructor_x64_addpd(ctx, v2674, v2680);
                                    let v2682 = constructor_output_xmm(ctx, v2681);
                                    let v2683 = Some(v2682);
                                    // Rule at src/isa/x64/lower.isle line 3779.
                                    return v2683;
                                }
                            }
                            _ => {}
                        }
                    }
                }
                &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 v923 = C::value_type(ctx, v590);
                                match v923 {
                                    I8 => {
                                        let v1880 = constructor_xmm_zero(ctx, F32X4);
                                        let v2602 = constructor_extend_to_gpr(ctx, v590, I32, &ExtendKind::Sign);
                                        let v2603 = &C::gpr_to_gpr_mem(ctx, v2602);
                                        let v2604 = constructor_x64_cvtsi2ss(ctx, I32, v1880, v2603);
                                        let v2605 = constructor_output_xmm(ctx, v2604);
                                        let v2606 = Some(v2605);
                                        // Rule at src/isa/x64/lower.isle line 3701.
                                        return v2606;
                                    }
                                    I16 => {
                                        let v1880 = constructor_xmm_zero(ctx, F32X4);
                                        let v2602 = constructor_extend_to_gpr(ctx, v590, I32, &ExtendKind::Sign);
                                        let v2603 = &C::gpr_to_gpr_mem(ctx, v2602);
                                        let v2604 = constructor_x64_cvtsi2ss(ctx, I32, v1880, v2603);
                                        let v2605 = constructor_output_xmm(ctx, v2604);
                                        let v2606 = Some(v2605);
                                        // Rule at src/isa/x64/lower.isle line 3704.
                                        return v2606;
                                    }
                                    _ => {}
                                }
                                let v2607 = C::ty_int(ctx, v923);
                                if let Some(v2608) = v2607 {
                                    let v2609 = C::fits_in_64(ctx, v2608);
                                    if let Some(v2610) = v2609 {
                                        let v1880 = constructor_xmm_zero(ctx, F32X4);
                                        let v2611 = &constructor_put_in_gpr_mem(ctx, v590);
                                        let v2612 = constructor_x64_cvtsi2ss(ctx, v2610, v1880, v2611);
                                        let v2613 = constructor_output_xmm(ctx, v2612);
                                        let v2614 = Some(v2613);
                                        // Rule at src/isa/x64/lower.isle line 3707.
                                        return v2614;
                                    }
                                }
                            }
                            F64 => {
                                let v923 = C::value_type(ctx, v590);
                                match v923 {
                                    I8 => {
                                        let v1886 = constructor_xmm_zero(ctx, F64X2);
                                        let v2602 = constructor_extend_to_gpr(ctx, v590, I32, &ExtendKind::Sign);
                                        let v2603 = &C::gpr_to_gpr_mem(ctx, v2602);
                                        let v2615 = constructor_x64_cvtsi2sd(ctx, I32, v1886, v2603);
                                        let v2616 = constructor_output_xmm(ctx, v2615);
                                        let v2617 = Some(v2616);
                                        // Rule at src/isa/x64/lower.isle line 3710.
                                        return v2617;
                                    }
                                    I16 => {
                                        let v1886 = constructor_xmm_zero(ctx, F64X2);
                                        let v2602 = constructor_extend_to_gpr(ctx, v590, I32, &ExtendKind::Sign);
                                        let v2603 = &C::gpr_to_gpr_mem(ctx, v2602);
                                        let v2615 = constructor_x64_cvtsi2sd(ctx, I32, v1886, v2603);
                                        let v2616 = constructor_output_xmm(ctx, v2615);
                                        let v2617 = Some(v2616);
                                        // Rule at src/isa/x64/lower.isle line 3713.
                                        return v2617;
                                    }
                                    _ => {}
                                }
                                let v2607 = C::ty_int(ctx, v923);
                                if let Some(v2608) = v2607 {
                                    let v2609 = C::fits_in_64(ctx, v2608);
                                    if let Some(v2610) = v2609 {
                                        let v1886 = constructor_xmm_zero(ctx, F64X2);
                                        let v2611 = &constructor_put_in_gpr_mem(ctx, v590);
                                        let v2618 = constructor_x64_cvtsi2sd(ctx, v2610, v1886, v2611);
                                        let v2619 = constructor_output_xmm(ctx, v2618);
                                        let v2620 = Some(v2619);
                                        // Rule at src/isa/x64/lower.isle line 3716.
                                        return v2620;
                                    }
                                }
                            }
                            F64X2 => {
                                let v2636 = C::def_inst(ctx, v590);
                                if let Some(v2637) = v2636 {
                                    let v2638 = C::inst_data_value(ctx, v2637);
                                    if let &InstructionData::Unary {
                                        opcode: ref v2641,
                                        arg: v2642,
                                    } = &v2638.1 {
                                        if let &Opcode::SwidenLow = v2641 {
                                            let v2643 = C::value_type(ctx, v2642);
                                            if v2643 == I32X4 {
                                                let v2644 = constructor_put_in_xmm(ctx, v2642);
                                                let v2645 = &C::xmm_to_xmm_mem_64(ctx, v2644);
                                                let v2646 = constructor_x64_cvtdq2pd(ctx, v2645);
                                                let v2647 = constructor_output_xmm(ctx, v2646);
                                                let v2648 = Some(v2647);
                                                // Rule at src/isa/x64/lower.isle line 3734.
                                                return v2648;
                                            }
                                        }
                                    }
                                }
                            }
                            _ => {}
                        }
                    }
                    let v923 = C::value_type(ctx, v590);
                    match v923 {
                        I32X4 => {
                            let v786 = &C::put_in_xmm_mem_128(ctx, v590);
                            let v2621 = constructor_x64_cvtdq2ps(ctx, v786);
                            let v2622 = constructor_output_xmm(ctx, v2621);
                            let v2623 = Some(v2622);
                            // Rule at src/isa/x64/lower.isle line 3719.
                            return v2623;
                        }
                        I64X2 => {
                            let v790 = constructor_put_in_xmm(ctx, v590);
                            let v2624 = constructor_xmm_zero(ctx, F64X2);
                            let v2625 = constructor_x64_movq_to_gpr(ctx, v790);
                            let v2626 = &C::gpr_to_gpr_mem(ctx, v2625);
                            let v2627 = constructor_x64_cvtsi2sd(ctx, I64, v2624, v2626);
                            let v826 = &C::xmm_to_xmm_mem_128(ctx, v790);
                            let v2628 = constructor_x64_pshufd(ctx, v826, 0xee_u8);
                            let v2629 = constructor_x64_movq_to_gpr(ctx, v2628);
                            let v2630 = &C::gpr_to_gpr_mem(ctx, v2629);
                            let v2631 = constructor_x64_cvtsi2sd(ctx, I64, v2624, v2630);
                            let v2632 = &C::xmm_to_xmm_mem_128(ctx, v2631);
                            let v2633 = constructor_x64_unpcklpd(ctx, v2627, v2632);
                            let v2634 = constructor_output_xmm(ctx, v2633);
                            let v2635 = Some(v2634);
                            // Rule at src/isa/x64/lower.isle line 3725.
                            return v2635;
                        }
                        _ => {}
                    }
                }
                &Opcode::Isplit => {
                    let v923 = C::value_type(ctx, v590);
                    if v923 == I128 {
                        let v595 = C::put_in_regs(ctx, v590);
                        let v3493 = C::value_regs_get(ctx, v595, 0x0_usize);
                        let v3494 = C::value_regs_get(ctx, v595, 0x1_usize);
                        let v3495 = C::value_reg(ctx, v3493);
                        let v3496 = C::value_reg(ctx, v3494);
                        let v3497 = C::output_pair(ctx, v3495, v3496);
                        let v3498 = Some(v3497);
                        // Rule at src/isa/x64/lower.isle line 5079.
                        return v3498;
                    }
                }
                _ => {}
            }
        }
        &InstructionData::UnaryConst {
            opcode: ref v45,
            constant_handle: v46,
        } => {
            match v45 {
                &Opcode::F128const => {
                    let v52 = C::u128_from_constant(ctx, v46);
                    if let Some(v53) = v52 {
                        if v53 == 0x0_u128 {
                            let v54 = constructor_xmm_zero(ctx, F128);
                            let v55 = constructor_output_xmm(ctx, v54);
                            let v56 = Some(v55);
                            // Rule at src/isa/x64/lower.isle line 46.
                            return v56;
                        }
                    }
                    let v48 = C::const_to_vconst(ctx, v46);
                    let v49 = constructor_x64_xmm_load_const(ctx, F128, v48);
                    let v50 = constructor_output_xmm(ctx, v49);
                    let v51 = Some(v50);
                    // Rule at src/isa/x64/lower.isle line 42.
                    return v51;
                }
                &Opcode::Vconst => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v52 = C::u128_from_constant(ctx, v46);
                        if let Some(v53) = v52 {
                            match v53 {
                                0xffffffffffffffffffffffffffffffff_u128 => {
                                    let v3149 = constructor_vector_all_ones(ctx);
                                    let v3150 = constructor_output_xmm(ctx, v3149);
                                    let v3151 = Some(v3150);
                                    // Rule at src/isa/x64/lower.isle line 4598.
                                    return v3151;
                                }
                                0x0_u128 => {
                                    let v3 = C::value_type(ctx, v2);
                                    let v3146 = constructor_xmm_zero(ctx, v3);
                                    let v3147 = constructor_output_xmm(ctx, v3146);
                                    let v3148 = Some(v3147);
                                    // Rule at src/isa/x64/lower.isle line 4597.
                                    return v3148;
                                }
                                _ => {}
                            }
                        }
                        let v48 = C::const_to_vconst(ctx, v46);
                        let v3 = C::value_type(ctx, v2);
                        let v3143 = constructor_x64_xmm_load_const(ctx, v3, v48);
                        let v3144 = constructor_output_xmm(ctx, v3143);
                        let v3145 = Some(v3144);
                        // Rule at src/isa/x64/lower.isle line 4592.
                        return v3145;
                    }
                }
                _ => {}
            }
        }
        &InstructionData::UnaryGlobalValue {
            opcode: ref v2375,
            global_value: v2376,
        } => {
            match v2375 {
                &Opcode::SymbolValue => {
                    let v2377 = C::symbol_value_data(ctx, v2376);
                    if let Some(v2378) = v2377 {
                        let v2382 = constructor_load_ext_name(ctx, v2378.0, v2378.2, &v2378.1);
                        let v2383 = constructor_output_gpr(ctx, v2382);
                        let v2384 = Some(v2383);
                        // Rule at src/isa/x64/lower.isle line 3436.
                        return v2384;
                    }
                }
                &Opcode::TlsValue => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v2377 = C::symbol_value_data(ctx, v2376);
                        if let Some(v2378) = v2377 {
                            let v3 = C::value_type(ctx, v2);
                            let v3499 = &C::tls_model(ctx, v3);
                            match v3499 {
                                &TlsModel::ElfGd => {
                                    let v3500 = constructor_elf_tls_get_addr(ctx, v2378.0);
                                    let v3501 = constructor_output_gpr(ctx, v3500);
                                    let v3502 = Some(v3501);
                                    // Rule at src/isa/x64/lower.isle line 5087.
                                    return v3502;
                                }
                                &TlsModel::Macho => {
                                    let v3503 = constructor_macho_tls_get_addr(ctx, v2378.0);
                                    let v3504 = constructor_output_gpr(ctx, v3503);
                                    let v3505 = Some(v3504);
                                    // Rule at src/isa/x64/lower.isle line 5090.
                                    return v3505;
                                }
                                &TlsModel::Coff => {
                                    let v3506 = constructor_coff_tls_get_addr(ctx, v2378.0);
                                    let v3507 = constructor_output_gpr(ctx, v3506);
                                    let v3508 = Some(v3507);
                                    // Rule at src/isa/x64/lower.isle line 5093.
                                    return v3508;
                                }
                                _ => {}
                            }
                        }
                    }
                }
                _ => {}
            }
        }
        &InstructionData::UnaryIeee16 {
            opcode: ref v22,
            imm: v23,
        } => {
            if let &Opcode::F16const = v22 {
                let v24 = C::u16_from_ieee16(ctx, v23);
                let v26 = C::u16_into_u64(ctx, v24);
                let v27 = constructor_imm(ctx, F16, v26);
                let v28 = constructor_output_reg(ctx, v27);
                let v29 = Some(v28);
                // Rule at src/isa/x64/lower.isle line 28.
                return v29;
            }
        }
        &InstructionData::UnaryIeee32 {
            opcode: ref v30,
            imm: v31,
        } => {
            if let &Opcode::F32const = v30 {
                let v32 = C::u32_from_ieee32(ctx, v31);
                let v34 = C::u32_into_u64(ctx, v32);
                let v35 = constructor_imm(ctx, F32, v34);
                let v36 = constructor_output_reg(ctx, v35);
                let v37 = Some(v36);
                // Rule at src/isa/x64/lower.isle line 33.
                return v37;
            }
        }
        &InstructionData::UnaryIeee64 {
            opcode: ref v38,
            imm: v39,
        } => {
            if let &Opcode::F64const = v38 {
                let v40 = C::u64_from_ieee64(ctx, v39);
                let v42 = constructor_imm(ctx, F64, v40);
                let v43 = constructor_output_reg(ctx, v42);
                let v44 = Some(v43);
                // Rule at src/isa/x64/lower.isle line 38.
                return v44;
            }
        }
        &InstructionData::UnaryImm {
            opcode: ref v9,
            imm: v10,
        } => {
            if let &Opcode::Iconst = v9 {
                let v1 = C::first_result(ctx, arg0);
                if let Some(v2) = v1 {
                    let v3 = C::value_type(ctx, v2);
                    if v3 == I128 {
                        let v11 = C::u64_from_imm64(ctx, v10);
                        let v16 = constructor_imm(ctx, I64, v11);
                        let v18 = constructor_imm(ctx, I64, 0x0_u64);
                        let v19 = C::value_regs(ctx, v16, v18);
                        let v20 = C::output(ctx, v19);
                        let v21 = Some(v20);
                        // Rule at src/isa/x64/lower.isle line 21.
                        return v21;
                    }
                    let v4 = C::fits_in_64(ctx, v3);
                    if let Some(v5) = v4 {
                        let v11 = C::u64_from_imm64(ctx, v10);
                        let v12 = constructor_imm(ctx, v5, v11);
                        let v13 = constructor_output_reg(ctx, v12);
                        let v14 = Some(v13);
                        // Rule at src/isa/x64/lower.isle line 16.
                        return v14;
                    }
                }
            }
        }
        _ => {}
    }
    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.1 {
        &InstructionData::BranchTable {
            opcode: ref v73,
            arg: v74,
            table: v75,
        } => {
            if let &Opcode::BrTable = v73 {
                let v77 = C::jump_table_targets(ctx, arg1);
                if let Some(v78) = v77 {
                    let v81 = C::jump_table_size(ctx, &v78.1);
                    let v76 = C::value_type(ctx, v74);
                    let v82 = C::u32_into_u64(ctx, v81);
                    let v83 = constructor_imm(ctx, v76, v82);
                    let v86 = constructor_extend_to_gpr(ctx, v74, I64, &ExtendKind::Zero);
                    let v87 = &constructor_reg_to_gpr_mem_imm(ctx, v83);
                    let v88 = &constructor_x64_cmp(ctx, v76, v86, v87);
                    let v90 = &C::gpr_to_gpr_mem(ctx, v86);
                    let v91 = C::gpr_new(ctx, v83);
                    let v92 = &constructor_cmove(ctx, v76, &CC::B, v90, v91);
                    let v93 = constructor_with_flags_reg(ctx, v88, v92);
                    let v94 = C::gpr_new(ctx, v93);
                    let v95 = &constructor_jmp_table_seq(ctx, v76, v94, v78.0, &v78.1);
                    let v96 = constructor_emit_side_effect(ctx, v95);
                    let v97 = Some(v96);
                    // Rule at src/isa/x64/lower.isle line 3657.
                    return v97;
                }
            }
        }
        &InstructionData::Brif {
            opcode: ref v59,
            arg: v60,
            blocks: ref v61,
        } => {
            if let &Opcode::Brif = v59 {
                let v65 = C::two_targets(ctx, arg1);
                if let Some(v66) = v65 {
                    let v69 = &constructor_is_nonzero_cmp(ctx, v60);
                    let v70 = &constructor_jmp_cond_result(ctx, v69, v66.0, v66.1);
                    let v71 = constructor_emit_side_effect(ctx, v70);
                    let v72 = Some(v71);
                    // Rule at src/isa/x64/lower.isle line 3652.
                    return v72;
                }
            }
        }
        &InstructionData::Jump {
            opcode: ref v52,
            destination: v53,
        } => {
            if let &Opcode::Jump = v52 {
                let v54 = C::single_target(ctx, arg1);
                if let Some(v55) = v54 {
                    let v56 = &constructor_jmp_known(ctx, v55);
                    let v57 = constructor_emit_side_effect(ctx, v56);
                    let v58 = Some(v57);
                    // Rule at src/isa/x64/lower.isle line 3647.
                    return v58;
                }
            }
        }
        &InstructionData::TryCall {
            opcode: ref v4,
            args: v5,
            func_ref: v6,
            exception: v7,
        } => {
            if let &Opcode::TryCall = v4 {
                let v9 = C::func_ref_data(ctx, v6);
                if let &RelocDistance::Near = &v9.2 {
                    let v15 = C::abi_sig(ctx, v9.0);
                    let v16 = C::try_call_info(ctx, v7, arg1);
                    let v8 = C::value_list_slice(ctx, v5);
                    let v17 = &C::put_in_regs_vec(ctx, v8);
                    let v18 = C::gen_call_args(ctx, v15, v17);
                    let v19 = C::gen_try_call_rets(ctx, v15);
                    let v20 = &C::gen_call_info(ctx, v15, v9.1, v18, v19, v16, v9.3);
                    let v21 = &constructor_call_known(ctx, v20);
                    let v22 = constructor_emit_side_effect(ctx, v21);
                    let v23 = Some(v22);
                    // Rule at src/isa/x64/lower.isle line 3595.
                    return v23;
                }
                if v9.3 == false {
                    let v15 = C::abi_sig(ctx, v9.0);
                    let v16 = C::try_call_info(ctx, v7, arg1);
                    let v8 = C::value_list_slice(ctx, v5);
                    let v17 = &C::put_in_regs_vec(ctx, v8);
                    let v18 = C::gen_call_args(ctx, v15, v17);
                    let v19 = C::gen_try_call_rets(ctx, v15);
                    let v25 = constructor_load_ext_name(ctx, v9.1, 0_i64, &v9.2);
                    let v26 = C::gpr_to_reg(ctx, v25);
                    let v27 = RegMem::Reg {
                        reg: v26,
                    };
                    let v28 = &C::gen_call_ind_info(ctx, v15, &v27, v18, v19, v16);
                    let v29 = &constructor_call_unknown(ctx, v28);
                    let v30 = constructor_emit_side_effect(ctx, v29);
                    let v31 = Some(v30);
                    // Rule at src/isa/x64/lower.isle line 3604.
                    return v31;
                }
            }
        }
        &InstructionData::TryCallIndirect {
            opcode: ref v32,
            args: v33,
            exception: v34,
        } => {
            if let &Opcode::TryCallIndirect = v32 {
                let v35 = C::value_list_slice(ctx, v33);
                let v36 = C::value_slice_unwrap(ctx, v35);
                if let Some(v37) = v36 {
                    let v40 = C::exception_sig(ctx, v34);
                    let v41 = C::abi_sig(ctx, v40);
                    let v42 = C::try_call_info(ctx, v34, arg1);
                    let v43 = C::put_in_reg(ctx, v37.0);
                    let v45 = &C::put_in_regs_vec(ctx, v37.1);
                    let v46 = C::gen_call_args(ctx, v41, v45);
                    let v47 = C::gen_try_call_rets(ctx, v41);
                    let v44 = RegMem::Reg {
                        reg: v43,
                    };
                    let v48 = &C::gen_call_ind_info(ctx, v41, &v44, v46, v47, v42);
                    let v49 = &constructor_call_unknown(ctx, v48);
                    let v50 = constructor_emit_side_effect(ctx, v49);
                    let v51 = Some(v50);
                    // Rule at src/isa/x64/lower.isle line 3614.
                    return v51;
                }
            }
        }
        _ => {}
    }
    None
}

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

// 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: &GprMemImm64,
    arg3: &GprMemImm64,
) -> ValueRegs {
    let v5 = &C::gpr_mem_imm_64_to_gpr_mem_imm(ctx, arg2);
    let v6 = &constructor_x64_sub_with_flags_paired(ctx, I64, arg0, v5);
    let v7 = &C::gpr_mem_imm_64_to_gpr_mem_imm(ctx, arg3);
    let v8 = &constructor_x64_sbb_paired(ctx, I64, arg1, v7);
    let v9 = constructor_with_flags(ctx, v6, v8);
    // Rule at src/isa/x64/lower.isle line 291.
    return v9;
}

// Generated as internal constructor for term sse_and.
pub fn constructor_sse_and<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Xmm,
    arg2: &XmmMem128,
) -> Xmm {
    match arg0 {
        F32 => {
            let v3 = constructor_x64_andps(ctx, arg1, arg2);
            // Rule at src/isa/x64/lower.isle line 348.
            return v3;
        }
        F64 => {
            let v4 = constructor_x64_andpd(ctx, arg1, arg2);
            // Rule at src/isa/x64/lower.isle line 349.
            return v4;
        }
        F32X4 => {
            let v3 = constructor_x64_andps(ctx, arg1, arg2);
            // Rule at src/isa/x64/lower.isle line 346.
            return v3;
        }
        F64X2 => {
            let v4 = constructor_x64_andpd(ctx, arg1, arg2);
            // Rule at src/isa/x64/lower.isle line 347.
            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 350.
        return v9;
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "sse_and", "src/isa/x64/lower.isle line 345")
}

// 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 359.
    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: &XmmMem128,
) -> Xmm {
    match arg0 {
        F32X4 => {
            let v3 = constructor_x64_andnps(ctx, arg1, arg2);
            // Rule at src/isa/x64/lower.isle line 377.
            return v3;
        }
        F64X2 => {
            let v4 = constructor_x64_andnpd(ctx, arg1, arg2);
            // Rule at src/isa/x64/lower.isle line 378.
            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 379.
        return v9;
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "sse_and_not", "src/isa/x64/lower.isle line 376")
}

// 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 v6,
            args: ref v7,
        } = &v3.1 {
            match v6 {
                &Opcode::Iadd => {
                    let v8 = C::unpack_value_array_2(ctx, v7);
                    let v22 = C::i64_from_iconst(ctx, v8.0);
                    if let Some(v23) = v22 {
                        if v23 == -1_i64 {
                            let v24 = Some(v8.1);
                            // Rule at src/isa/x64/lower.isle line 408.
                            return v24;
                        }
                    }
                    let v20 = C::i64_from_iconst(ctx, v8.1);
                    if let Some(v21) = v20 {
                        if v21 == -1_i64 {
                            let v19 = Some(v8.0);
                            // Rule at src/isa/x64/lower.isle line 407.
                            return v19;
                        }
                    }
                }
                &Opcode::Isub => {
                    let v8 = C::unpack_value_array_2(ctx, v7);
                    let v11 = C::def_inst(ctx, v8.1);
                    if let Some(v12) = v11 {
                        let v13 = C::inst_data_value(ctx, v12);
                        if let &InstructionData::UnaryImm {
                            opcode: ref v16,
                            imm: v17,
                        } = &v13.1 {
                            if let &Opcode::Iconst = v16 {
                                let v18 = C::u64_from_imm64(ctx, v17);
                                if v18 == 0x1_u64 {
                                    let v19 = Some(v8.0);
                                    // Rule at src/isa/x64/lower.isle line 406.
                                    return v19;
                                }
                            }
                        }
                    }
                }
                _ => {}
            }
        }
    }
    None
}

// Generated as internal constructor for term sse_or.
pub fn constructor_sse_or<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Xmm,
    arg2: &XmmMem128,
) -> Xmm {
    match arg0 {
        F32 => {
            let v3 = constructor_x64_orps(ctx, arg1, arg2);
            // Rule at src/isa/x64/lower.isle line 476.
            return v3;
        }
        F64 => {
            let v4 = constructor_x64_orpd(ctx, arg1, arg2);
            // Rule at src/isa/x64/lower.isle line 477.
            return v4;
        }
        F32X4 => {
            let v3 = constructor_x64_orps(ctx, arg1, arg2);
            // Rule at src/isa/x64/lower.isle line 474.
            return v3;
        }
        F64X2 => {
            let v4 = constructor_x64_orpd(ctx, arg1, arg2);
            // Rule at src/isa/x64/lower.isle line 475.
            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 478.
        return v9;
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "sse_or", "src/isa/x64/lower.isle line 473")
}

// 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 487.
    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_64(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_64(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 583.
    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_data(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 657.
            return v13.clone();
        }
        &RegMemImm::Mem {
            addr: ref v14,
        } => {
            let v15 = &C::synthetic_amode_to_gpr_mem_64(ctx, v14);
            let v16 = constructor_x64_movq_rm(ctx, v15);
            let v17 = C::gpr_to_reg(ctx, v16);
            let v18 = RegMemImm::Reg {
                reg: v17,
            };
            let v19 = &constructor_ishl_i8x16_mask(ctx, &v18);
            // Rule at src/isa/x64/lower.isle line 667.
            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 648.
            return v2.clone();
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "ishl_i8x16_mask", "src/isa/x64/lower.isle line 642")
}

// 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_64(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_64(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 692.
    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_data(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 761.
            return v13.clone();
        }
        &RegMemImm::Mem {
            addr: ref v14,
        } => {
            let v15 = &C::synthetic_amode_to_gpr_mem_64(ctx, v14);
            let v16 = constructor_x64_movq_rm(ctx, v15);
            let v17 = C::gpr_to_reg(ctx, v16);
            let v18 = RegMemImm::Reg {
                reg: v17,
            };
            let v19 = &constructor_ushr_i8x16_mask(ctx, &v18);
            // Rule at src/isa/x64/lower.isle line 771.
            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 752.
            return v2.clone();
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "ushr_i8x16_mask", "src/isa/x64/lower.isle line 746")
}

// 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 v16,
            imm: v17,
        } = &v13.1 {
            if let &Opcode::Iconst = v16 {
                let v18 = C::shift_amount_masked(ctx, arg0, v17);
                let v19 = C::u8_into_u32(ctx, v18);
                let v20 = RegMemImm::Imm {
                    simm32: v19,
                };
                // Rule at src/isa/x64/lower.isle line 788.
                return v20;
            }
        }
    }
    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 786.
    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_64(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_64(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 802.
    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 870.
            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 874.
            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 868.
            return v6.clone();
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "sshr_i8x16_bigger_shift", "src/isa/x64/lower.isle line 867")
}

// 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_128(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_128(ctx, v11);
        let v14 = constructor_x64_pshufd(ctx, v12, 0xe8_u8);
        let v15 = &C::xmm_to_xmm_mem_128(ctx, v9);
        let v16 = constructor_x64_punpckldq(ctx, v14, v15);
        // Rule at src/isa/x64/lower.isle line 913.
        return v16;
    }
    if arg1 == 0x20_u32 {
        let v17 = &C::xmm_to_xmm_mem_128(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_128(ctx, v21);
        let v23 = constructor_x64_pshufd(ctx, v22, 0xed_u8);
        let v24 = &C::xmm_to_xmm_mem_128(ctx, v23);
        let v25 = constructor_x64_punpckldq(ctx, v18, v24);
        // Rule at src/isa/x64/lower.isle line 924.
        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_128(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_128(ctx, v34);
        let v36 = constructor_x64_pshufd(ctx, v35, 0xed_u8);
        let v37 = &C::xmm_to_xmm_mem_128(ctx, v30);
        let v38 = constructor_x64_punpckldq(ctx, v36, v37);
        // Rule at src/isa/x64/lower.isle line 935.
        return v38;
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "lower_i64x2_sshr_imm", "src/isa/x64/lower.isle line 908")
}

// 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_64(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_128(ctx, v9);
    let v11 = constructor_x64_pxor(ctx, v7, v10);
    let v12 = &C::xmm_to_xmm_mem_128(ctx, v7);
    let v13 = constructor_x64_psubq(ctx, v11, v12);
    // Rule at src/isa/x64/lower.isle line 950.
    return v13;
}

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

// 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 1468.
        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 1460.
            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 1449.
            return v15;
        }
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "lower_bmask", "src/isa/x64/lower.isle line 1437")
}

// 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 1491.
    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.1 {
            &InstructionData::FloatCompare {
                opcode: ref v19,
                args: ref v20,
                cond: ref v21,
            } => {
                if let &Opcode::Fcmp = v19 {
                    let v12 = C::value_type(ctx, arg0);
                    let v13 = C::multi_lane(ctx, v12);
                    if let Some(v14) = v13 {
                        let v17 = true;
                        let v18 = Some(v17);
                        // Rule at src/isa/x64/lower.isle line 1537.
                        return v18;
                    }
                }
            }
            &InstructionData::IntCompare {
                opcode: ref v6,
                args: ref v7,
                cond: ref v8,
            } => {
                if let &Opcode::Icmp = v6 {
                    let v12 = C::value_type(ctx, arg0);
                    let v13 = C::multi_lane(ctx, v12);
                    if let Some(v14) = v13 {
                        let v17 = true;
                        let v18 = Some(v17);
                        // Rule at src/isa/x64/lower.isle line 1536.
                        return v18;
                    }
                }
            }
            &InstructionData::LoadNoOffset {
                opcode: ref v25,
                arg: v26,
                flags: v27,
            } => {
                if let &Opcode::Bitcast = v25 {
                    let v12 = C::value_type(ctx, arg0);
                    let v13 = C::multi_lane(ctx, v12);
                    if let Some(v14) = v13 {
                        let v28 = C::def_inst(ctx, v26);
                        if let Some(v29) = v28 {
                            let v30 = C::inst_data_value(ctx, v29);
                            if let &InstructionData::FloatCompare {
                                opcode: ref v33,
                                args: ref v34,
                                cond: ref v35,
                            } = &v30.1 {
                                if let &Opcode::Fcmp = v33 {
                                    let v17 = true;
                                    let v18 = Some(v17);
                                    // Rule at src/isa/x64/lower.isle line 1538.
                                    return v18;
                                }
                            }
                        }
                    }
                }
            }
            &InstructionData::UnaryConst {
                opcode: ref v39,
                constant_handle: v40,
            } => {
                if let &Opcode::Vconst = v39 {
                    let v41 = C::vconst_all_ones_or_all_zeros(ctx, v40);
                    if let Some(v42) = v41 {
                        let v17 = true;
                        let v18 = Some(v17);
                        // Rule at src/isa/x64/lower.isle line 1539.
                        return v18;
                    }
                }
            }
            _ => {}
        }
    }
    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 1645.
            return 0x54_u8;
        }
        0x1_u8 => {
            // Rule at src/isa/x64/lower.isle line 1646.
            return 0x51_u8;
        }
        0x2_u8 => {
            // Rule at src/isa/x64/lower.isle line 1647.
            return 0x45_u8;
        }
        0x3_u8 => {
            // Rule at src/isa/x64/lower.isle line 1648.
            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 1644")
}

// 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_32(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 1714.
        return v6;
    }
    match arg2 {
        0x0_u8 => {
            let v7 = constructor_x64_movss_regmove(ctx, arg0, arg1);
            // Rule at src/isa/x64/lower.isle line 1723.
            return v7;
        }
        0x1_u8 => {
            let v8 = constructor_x64_movlhps(ctx, arg1, arg0);
            let v9 = &C::xmm_to_xmm_mem_128(ctx, arg0);
            let v11 = constructor_x64_shufps(ctx, v8, v9, 0xe2_u8);
            // Rule at src/isa/x64/lower.isle line 1729.
            return v11;
        }
        0x2_u8 => {
            let v12 = &C::xmm_to_xmm_mem_128(ctx, arg0);
            let v14 = constructor_x64_shufps(ctx, arg1, v12, 0x30_u8);
            let v15 = &C::xmm_to_xmm_mem_128(ctx, v14);
            let v17 = constructor_x64_shufps(ctx, arg0, v15, 0x84_u8);
            // Rule at src/isa/x64/lower.isle line 1736.
            return v17;
        }
        0x3_u8 => {
            let v12 = &C::xmm_to_xmm_mem_128(ctx, arg0);
            let v19 = constructor_x64_shufps(ctx, arg1, v12, 0xe4_u8);
            let v20 = &C::xmm_to_xmm_mem_128(ctx, v19);
            let v22 = constructor_x64_shufps(ctx, arg0, v20, 0x24_u8);
            // Rule at src/isa/x64/lower.isle line 1743.
            return v22;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "f32x4_insertlane", "src/isa/x64/lower.isle line 1711")
}

// 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 1768.
        return v15;
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "cmp_and_choose", "src/isa/x64/lower.isle line 1767")
}

// 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 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 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 1798.
            return v1;
        }
        I64X2 => {
            let v2 = false;
            // Rule at src/isa/x64/lower.isle line 1799.
            return v2;
        }
        _ => {}
    }
    let v3 = C::has_sse41(ctx);
    // Rule at src/isa/x64/lower.isle line 1800.
    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 1803.
            return v1;
        }
        I64X2 => {
            let v2 = false;
            // Rule at src/isa/x64/lower.isle line 1804.
            return v2;
        }
        _ => {}
    }
    let v3 = C::has_sse41(ctx);
    // Rule at src/isa/x64/lower.isle line 1805.
    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 1808.
            return v1;
        }
        I64X2 => {
            let v2 = false;
            // Rule at src/isa/x64/lower.isle line 1809.
            return v2;
        }
        _ => {}
    }
    let v3 = C::has_sse41(ctx);
    // Rule at src/isa/x64/lower.isle line 1810.
    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_128(ctx, arg2);
        let v5 = constructor_x64_pmaxs(ctx, arg0, arg1, v4);
        // Rule at src/isa/x64/lower.isle line 1818.
        return v5;
    }
    let v4 = &C::xmm_to_xmm_mem_128(ctx, arg2);
    let v6 = constructor_x64_pcmpgt(ctx, arg0, arg1, v4);
    let v7 = &C::xmm_to_xmm_mem_128(ctx, arg1);
    let v8 = constructor_x64_pand(ctx, v6, v7);
    let v9 = &C::xmm_to_xmm_mem_128(ctx, arg2);
    let v10 = constructor_x64_pandn(ctx, v6, v9);
    let v11 = &C::xmm_to_xmm_mem_128(ctx, v10);
    let v12 = constructor_x64_por(ctx, v8, v11);
    // Rule at src/isa/x64/lower.isle line 1822.
    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 = &constructor_emit_xmm_mem_128_le_const(ctx, 0x80008000800080008000800080008000_u128);
            let v3 = constructor_x64_movdqu_load(ctx, v2);
            // Rule at src/isa/x64/lower.isle line 1877.
            return v3;
        }
        I32X4 => {
            let v5 = &constructor_emit_xmm_mem_128_le_const(ctx, 0x80000000800000008000000080000000_u128);
            let v6 = constructor_x64_movdqu_load(ctx, v5);
            // Rule at src/isa/x64/lower.isle line 1879.
            return v6;
        }
        I64X2 => {
            let v8 = &constructor_emit_xmm_mem_128_le_const(ctx, 0x80000000000000008000000000000000_u128);
            let v9 = constructor_x64_movdqu_load(ctx, v8);
            // Rule at src/isa/x64/lower.isle line 1881.
            return v9;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "flip_high_bit_mask", "src/isa/x64/lower.isle line 1876")
}

// 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 1921.
            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 1923.
            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 1925.
            return v15.clone();
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "trap_if_cond", "src/isa/x64/lower.isle line 1920")
}

// 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 2212.
        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 2206.
        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 2204.
            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 2202.
            return v11;
        }
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "lower_select", "src/isa/x64/lower.isle line 2201")
}

// 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 2216.
            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 2218.
            return v20;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "lower_select_gpr", "src/isa/x64/lower.isle line 2215")
}

// 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 2225.
            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 2227.
            return v21;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "lower_select_xmm", "src/isa/x64/lower.isle line 2224")
}

// 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 2234.
            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 2236.
            return v14;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "lower_select128", "src/isa/x64/lower.isle line 2233")
}

// 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 2245.
    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 2254.
                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 2258.
                return v14;
            }
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "consumes_flags_return_last", "src/isa/x64/lower.isle line 2253")
}

// 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 2306.
        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 2310.
    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 2342.
        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 2346.
    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 2378.
    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 2461.
            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 2420.
            return v37;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "do_popcnt", "src/isa/x64/lower.isle line 2419")
}

// 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 2553.
    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 2576.
    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 2588.
    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 2600.
        return v12;
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "do_bitrev64", "src/isa/x64/lower.isle line 2599")
}

// 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 v23 = C::def_inst(ctx, arg2);
    if let Some(v24) = v23 {
        let v25 = C::inst_data_value(ctx, v24);
        if let &InstructionData::Unary {
            opcode: ref v28,
            arg: v29,
        } = &v25.1 {
            if let &Opcode::Fneg = v28 {
                let v30 = constructor_fnmadd(ctx, arg0, arg1, v29, arg3);
                // Rule at src/isa/x64/lower.isle line 3027.
                return v30;
            }
        }
    }
    let v15 = C::def_inst(ctx, arg1);
    if let Some(v16) = v15 {
        let v17 = C::inst_data_value(ctx, v16);
        if let &InstructionData::Unary {
            opcode: ref v20,
            arg: v21,
        } = &v17.1 {
            if let &Opcode::Fneg = v20 {
                let v22 = constructor_fnmadd(ctx, arg0, v21, arg2, arg3);
                // Rule at src/isa/x64/lower.isle line 3026.
                return v22;
            }
        }
    }
    let v12 = &C::sinkable_load(ctx, arg2);
    if let Some(v13) = v12 {
        let v4 = constructor_put_in_xmm(ctx, arg1);
        let v10 = constructor_put_in_xmm(ctx, arg3);
        let v14 = constructor_x64_vfmadd132(ctx, arg0, v4, v10, arg2);
        // Rule at src/isa/x64/lower.isle line 3022.
        return v14;
    }
    let v7 = &C::sinkable_load(ctx, arg1);
    if let Some(v8) = v7 {
        let v9 = constructor_put_in_xmm(ctx, arg2);
        let v10 = constructor_put_in_xmm(ctx, arg3);
        let v11 = constructor_x64_vfmadd132(ctx, arg0, v9, v10, arg1);
        // Rule at src/isa/x64/lower.isle line 3021.
        return v11;
    }
    let v4 = constructor_put_in_xmm(ctx, arg1);
    let v5 = constructor_put_in_xmm(ctx, arg2);
    let v6 = constructor_x64_vfmadd213(ctx, arg0, v4, v5, arg3);
    // Rule at src/isa/x64/lower.isle line 3014.
    return v6;
}

// 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 v12 = &C::sinkable_load(ctx, arg2);
    if let Some(v13) = v12 {
        let v4 = constructor_put_in_xmm(ctx, arg1);
        let v10 = constructor_put_in_xmm(ctx, arg3);
        let v14 = constructor_x64_vfnmadd132(ctx, arg0, v4, v10, arg2);
        // Rule at src/isa/x64/lower.isle line 3031.
        return v14;
    }
    let v7 = &C::sinkable_load(ctx, arg1);
    if let Some(v8) = v7 {
        let v9 = constructor_put_in_xmm(ctx, arg2);
        let v10 = constructor_put_in_xmm(ctx, arg3);
        let v11 = constructor_x64_vfnmadd132(ctx, arg0, v9, v10, arg1);
        // Rule at src/isa/x64/lower.isle line 3030.
        return v11;
    }
    let v4 = constructor_put_in_xmm(ctx, arg1);
    let v5 = constructor_put_in_xmm(ctx, arg2);
    let v6 = constructor_x64_vfnmadd213(ctx, arg0, v4, v5, arg3);
    // Rule at src/isa/x64/lower.isle line 3029.
    return v6;
}

// 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 v23 = C::def_inst(ctx, arg2);
    if let Some(v24) = v23 {
        let v25 = C::inst_data_value(ctx, v24);
        if let &InstructionData::Unary {
            opcode: ref v28,
            arg: v29,
        } = &v25.1 {
            if let &Opcode::Fneg = v28 {
                let v30 = constructor_fnmsub(ctx, arg0, arg1, v29, arg3);
                // Rule at src/isa/x64/lower.isle line 3054.
                return v30;
            }
        }
    }
    let v15 = C::def_inst(ctx, arg1);
    if let Some(v16) = v15 {
        let v17 = C::inst_data_value(ctx, v16);
        if let &InstructionData::Unary {
            opcode: ref v20,
            arg: v21,
        } = &v17.1 {
            if let &Opcode::Fneg = v20 {
                let v22 = constructor_fnmsub(ctx, arg0, v21, arg2, arg3);
                // Rule at src/isa/x64/lower.isle line 3053.
                return v22;
            }
        }
    }
    let v12 = &C::sinkable_load(ctx, arg2);
    if let Some(v13) = v12 {
        let v4 = constructor_put_in_xmm(ctx, arg1);
        let v10 = constructor_put_in_xmm(ctx, arg3);
        let v14 = constructor_x64_vfmsub132(ctx, arg0, v4, v10, arg2);
        // Rule at src/isa/x64/lower.isle line 3049.
        return v14;
    }
    let v7 = &C::sinkable_load(ctx, arg1);
    if let Some(v8) = v7 {
        let v9 = constructor_put_in_xmm(ctx, arg2);
        let v10 = constructor_put_in_xmm(ctx, arg3);
        let v11 = constructor_x64_vfmsub132(ctx, arg0, v9, v10, arg1);
        // Rule at src/isa/x64/lower.isle line 3048.
        return v11;
    }
    let v4 = constructor_put_in_xmm(ctx, arg1);
    let v5 = constructor_put_in_xmm(ctx, arg2);
    let v6 = constructor_x64_vfmsub213(ctx, arg0, v4, v5, arg3);
    // Rule at src/isa/x64/lower.isle line 3043.
    return v6;
}

// 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 v12 = &C::sinkable_load(ctx, arg2);
    if let Some(v13) = v12 {
        let v4 = constructor_put_in_xmm(ctx, arg1);
        let v10 = constructor_put_in_xmm(ctx, arg3);
        let v14 = constructor_x64_vfnmsub132(ctx, arg0, v4, v10, arg2);
        // Rule at src/isa/x64/lower.isle line 3058.
        return v14;
    }
    let v7 = &C::sinkable_load(ctx, arg1);
    if let Some(v8) = v7 {
        let v9 = constructor_put_in_xmm(ctx, arg2);
        let v10 = constructor_put_in_xmm(ctx, arg3);
        let v11 = constructor_x64_vfnmsub132(ctx, arg0, v9, v10, arg1);
        // Rule at src/isa/x64/lower.isle line 3057.
        return v11;
    }
    let v4 = constructor_put_in_xmm(ctx, arg1);
    let v5 = constructor_put_in_xmm(ctx, arg2);
    let v6 = constructor_x64_vfnmsub213(ctx, arg0, v4, v5, arg3);
    // Rule at src/isa/x64/lower.isle line 3056.
    return v6;
}

// 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 3679.
        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 3678.
    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_128(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 4123.
            return v6;
        }
        I32X4 => {
            let v2 = &C::xmm_to_xmm_mem_128(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 4125.
            return v10;
        }
        I64X2 => {
            let v12 = constructor_xmm_zero(ctx, I32X4);
            let v13 = &C::xmm_to_xmm_mem_aligned_128(ctx, arg1);
            let v14 = constructor_x64_pcmpgtd_a(ctx, v12, v13);
            let v15 = &C::xmm_to_xmm_mem_128(ctx, v14);
            let v16 = constructor_x64_punpckldq(ctx, arg1, v15);
            // Rule at src/isa/x64/lower.isle line 4131.
            return v16;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "lower_swiden_low", "src/isa/x64/lower.isle line 4118")
}

// 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_128(ctx, v3);
            let v5 = constructor_x64_punpcklbw(ctx, arg1, v4);
            // Rule at src/isa/x64/lower.isle line 4187.
            return v5;
        }
        I32X4 => {
            let v3 = constructor_xmm_zero(ctx, I8X16);
            let v4 = &C::xmm_to_xmm_mem_128(ctx, v3);
            let v6 = constructor_x64_punpcklwd(ctx, arg1, v4);
            // Rule at src/isa/x64/lower.isle line 4188.
            return v6;
        }
        I64X2 => {
            let v8 = constructor_xmm_zero(ctx, F32X4);
            let v9 = &C::xmm_to_xmm_mem_128(ctx, v8);
            let v10 = constructor_x64_unpcklps(ctx, arg1, v9);
            // Rule at src/isa/x64/lower.isle line 4189.
            return v10;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "lower_uwiden_low", "src/isa/x64/lower.isle line 4186")
}

// 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_128(ctx, v2);
    let v4 = constructor_x64_pcmpgtd_a_or_avx(ctx, arg0, v3);
    let v5 = &C::xmm_to_xmm_mem_128(ctx, v4);
    let v6 = constructor_x64_pand(ctx, arg0, v5);
    let v8 = &constructor_emit_xmm_mem_128_le_const(ctx, 0xffff0000ffff0000ffff0000ffff_u128);
    let v9 = constructor_x64_movdqu_load(ctx, v8);
    let v10 = &C::xmm_to_xmm_mem_128(ctx, v6);
    let v11 = constructor_x64_pcmpgtd_a_or_avx(ctx, v9, v10);
    let v12 = &C::xmm_to_xmm_mem_128(ctx, v11);
    let v13 = constructor_x64_pand(ctx, v6, v12);
    let v14 = &C::xmm_to_xmm_mem_128(ctx, v9);
    let v15 = constructor_x64_pandn(ctx, v11, v14);
    let v16 = &C::xmm_to_xmm_mem_128(ctx, v15);
    let v17 = constructor_x64_por(ctx, v13, v16);
    let v18 = &C::xmm_to_xmm_mem_128(ctx, v17);
    let v20 = constructor_x64_pshuflw(ctx, v18, 0x8_u8);
    let v21 = &C::xmm_to_xmm_mem_128(ctx, v20);
    let v22 = constructor_x64_pshufhw(ctx, v21, 0x8_u8);
    let v23 = &C::xmm_to_xmm_mem_128(ctx, v22);
    let v24 = constructor_x64_pshufd(ctx, v23, 0x8_u8);
    // Rule at src/isa/x64/lower.isle line 4269.
    return v24;
}

// Generated as internal constructor for term x64_round.
pub fn constructor_x64_round<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: &RoundImm,
) -> Xmm {
    match arg0 {
        F32 => {
            let v3 = &C::put_in_xmm_mem_32(ctx, arg1);
            let v4 = constructor_x64_round_f32(ctx, v3, arg2);
            // Rule at src/isa/x64/lower.isle line 4343.
            return v4;
        }
        F64 => {
            let v5 = &C::put_in_xmm_mem_64(ctx, arg1);
            let v6 = constructor_x64_round_f64(ctx, v5, arg2);
            // Rule at src/isa/x64/lower.isle line 4344.
            return v6;
        }
        F32X4 => {
            let v7 = &C::put_in_xmm_mem_128(ctx, arg1);
            let v8 = constructor_x64_round_f32x4(ctx, v7, arg2);
            // Rule at src/isa/x64/lower.isle line 4345.
            return v8;
        }
        F64X2 => {
            let v7 = &C::put_in_xmm_mem_128(ctx, arg1);
            let v9 = constructor_x64_round_f64x2(ctx, v7, arg2);
            // Rule at src/isa/x64/lower.isle line 4346.
            return v9;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_round", "src/isa/x64/lower.isle line 4342")
}

// Generated as internal constructor for term x64_round_f32.
pub fn constructor_x64_round_f32<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem32,
    arg1: &RoundImm,
) -> Xmm {
    let v2 = C::has_sse41(ctx);
    if v2 == true {
        let v3 = constructor_x64_roundss(ctx, arg0, arg1);
        // Rule at src/isa/x64/lower.isle line 4351.
        return v3;
    }
    let v4 = C::is_xmm_32(ctx, arg0);
    if let Some(v5) = v4 {
        let v7 = &constructor_round_libcall(ctx, F32, arg1);
        let v8 = C::xmm_to_reg(ctx, v5);
        let v9 = C::libcall_1(ctx, v7, v8);
        let v10 = C::xmm_new(ctx, v9);
        // Rule at src/isa/x64/lower.isle line 4354.
        return v10;
    }
    let v11 = &C::is_mem_32(ctx, arg0);
    if let Some(v12) = v11 {
        let v13 = constructor_x64_movss_load(ctx, v12);
        let v14 = &C::xmm_to_xmm_mem_32(ctx, v13);
        let v15 = constructor_x64_round_f32(ctx, v14, arg1);
        // Rule at src/isa/x64/lower.isle line 4356.
        return v15;
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_round_f32", "src/isa/x64/lower.isle line 4350")
}

// Generated as internal constructor for term x64_round_f64.
pub fn constructor_x64_round_f64<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem64,
    arg1: &RoundImm,
) -> Xmm {
    let v2 = C::has_sse41(ctx);
    if v2 == true {
        let v3 = constructor_x64_roundsd(ctx, arg0, arg1);
        // Rule at src/isa/x64/lower.isle line 4360.
        return v3;
    }
    let v4 = C::is_xmm_64(ctx, arg0);
    if let Some(v5) = v4 {
        let v7 = &constructor_round_libcall(ctx, F64, arg1);
        let v8 = C::xmm_to_reg(ctx, v5);
        let v9 = C::libcall_1(ctx, v7, v8);
        let v10 = C::xmm_new(ctx, v9);
        // Rule at src/isa/x64/lower.isle line 4363.
        return v10;
    }
    let v11 = &C::is_mem_64(ctx, arg0);
    if let Some(v12) = v11 {
        let v13 = constructor_x64_movsd_load(ctx, v12);
        let v14 = &C::xmm_to_xmm_mem_64(ctx, v13);
        let v15 = constructor_x64_round_f64(ctx, v14, arg1);
        // Rule at src/isa/x64/lower.isle line 4365.
        return v15;
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_round_f64", "src/isa/x64/lower.isle line 4359")
}

// Generated as internal constructor for term x64_round_f32x4.
pub fn constructor_x64_round_f32x4<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem128,
    arg1: &RoundImm,
) -> Xmm {
    let v2 = C::has_sse41(ctx);
    if v2 == true {
        let v3 = constructor_x64_roundps(ctx, arg0, arg1);
        // Rule at src/isa/x64/lower.isle line 4369.
        return v3;
    }
    let v4 = C::is_xmm_128(ctx, arg0);
    if let Some(v5) = v4 {
        let v7 = &constructor_round_libcall(ctx, F32, arg1);
        let v8 = C::xmm_to_reg(ctx, v5);
        let v9 = C::libcall_1(ctx, v7, v8);
        let v10 = C::xmm_new(ctx, v9);
        let v11 = &C::xmm_to_xmm_mem_128(ctx, v5);
        let v13 = constructor_x64_pshufd(ctx, v11, 0x1_u8);
        let v14 = C::xmm_to_reg(ctx, v13);
        let v15 = C::libcall_1(ctx, v7, v14);
        let v16 = C::xmm_new(ctx, v15);
        let v17 = constructor_f32x4_insertlane(ctx, v10, v16, 0x1_u8);
        let v18 = &C::xmm_to_xmm_mem_128(ctx, v5);
        let v20 = constructor_x64_pshufd(ctx, v18, 0x2_u8);
        let v21 = C::xmm_to_reg(ctx, v20);
        let v22 = C::libcall_1(ctx, v7, v21);
        let v23 = C::xmm_new(ctx, v22);
        let v24 = constructor_f32x4_insertlane(ctx, v17, v23, 0x2_u8);
        let v25 = &C::xmm_to_xmm_mem_128(ctx, v5);
        let v27 = constructor_x64_pshufd(ctx, v25, 0x3_u8);
        let v28 = C::xmm_to_reg(ctx, v27);
        let v29 = C::libcall_1(ctx, v7, v28);
        let v30 = C::xmm_new(ctx, v29);
        let v31 = constructor_f32x4_insertlane(ctx, v24, v30, 0x3_u8);
        // Rule at src/isa/x64/lower.isle line 4372.
        return v31;
    }
    let v32 = &C::is_mem_128(ctx, arg0);
    if let Some(v33) = v32 {
        let v34 = &C::synthetic_amode_to_xmm_mem_128(ctx, v33);
        let v35 = constructor_x64_movdqu_load(ctx, v34);
        let v36 = &C::xmm_to_xmm_mem_128(ctx, v35);
        let v37 = constructor_x64_round_f32x4(ctx, v36, arg1);
        // Rule at src/isa/x64/lower.isle line 4384.
        return v37;
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_round_f32x4", "src/isa/x64/lower.isle line 4368")
}

// Generated as internal constructor for term x64_round_f64x2.
pub fn constructor_x64_round_f64x2<C: Context>(
    ctx: &mut C,
    arg0: &XmmMem128,
    arg1: &RoundImm,
) -> Xmm {
    let v2 = C::has_sse41(ctx);
    if v2 == true {
        let v3 = constructor_x64_roundpd(ctx, arg0, arg1);
        // Rule at src/isa/x64/lower.isle line 4388.
        return v3;
    }
    let v4 = C::is_xmm_128(ctx, arg0);
    if let Some(v5) = v4 {
        let v7 = &constructor_round_libcall(ctx, F64, arg1);
        let v8 = C::xmm_to_reg(ctx, v5);
        let v9 = C::libcall_1(ctx, v7, v8);
        let v10 = C::xmm_new(ctx, v9);
        let v11 = &C::xmm_to_xmm_mem_128(ctx, v5);
        let v13 = constructor_x64_pshufd(ctx, v11, 0xe_u8);
        let v14 = C::xmm_to_reg(ctx, v13);
        let v15 = C::libcall_1(ctx, v7, v14);
        let v16 = C::xmm_new(ctx, v15);
        let v17 = constructor_x64_movlhps(ctx, v10, v16);
        // Rule at src/isa/x64/lower.isle line 4391.
        return v17;
    }
    let v18 = &C::is_mem_128(ctx, arg0);
    if let Some(v19) = v18 {
        let v20 = &C::synthetic_amode_to_xmm_mem_128(ctx, v19);
        let v21 = constructor_x64_movdqu_load(ctx, v20);
        let v22 = &C::xmm_to_xmm_mem_128(ctx, v21);
        let v23 = constructor_x64_round_f64x2(ctx, v22, arg1);
        // Rule at src/isa/x64/lower.isle line 4398.
        return v23;
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "x64_round_f64x2", "src/isa/x64/lower.isle line 4387")
}

// 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 4406.
                    return LibCall::NearestF32;
                }
                &RoundImm::RoundDown => {
                    // Rule at src/isa/x64/lower.isle line 4404.
                    return LibCall::FloorF32;
                }
                &RoundImm::RoundUp => {
                    // Rule at src/isa/x64/lower.isle line 4402.
                    return LibCall::CeilF32;
                }
                &RoundImm::RoundZero => {
                    // Rule at src/isa/x64/lower.isle line 4408.
                    return LibCall::TruncF32;
                }
                _ => {}
            }
        }
        F64 => {
            match arg1 {
                &RoundImm::RoundNearest => {
                    // Rule at src/isa/x64/lower.isle line 4407.
                    return LibCall::NearestF64;
                }
                &RoundImm::RoundDown => {
                    // Rule at src/isa/x64/lower.isle line 4405.
                    return LibCall::FloorF64;
                }
                &RoundImm::RoundUp => {
                    // Rule at src/isa/x64/lower.isle line 4403.
                    return LibCall::CeilF64;
                }
                &RoundImm::RoundZero => {
                    // Rule at src/isa/x64/lower.isle line 4409.
                    return LibCall::TruncF64;
                }
                _ => {}
            }
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "round_libcall", "src/isa/x64/lower.isle line 4401")
}

// 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 4480.
            return v2;
        }
        I32 => {
            let v3 = constructor_x64_cltd_zo(ctx, arg1);
            // Rule at src/isa/x64/lower.isle line 4481.
            return v3;
        }
        I64 => {
            let v4 = constructor_x64_cqto_zo(ctx, arg1);
            // Rule at src/isa/x64/lower.isle line 4482.
            return v4;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "repeat_sign_bit", "src/isa/x64/lower.isle line 4479")
}

// 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 v7,
            imm: v8,
        } = &v4.1 {
            if let &Opcode::Iconst = v7 {
                let v9 = C::safe_divisor_from_imm64(ctx, arg0, v8);
                if let Some(v10) = v9 {
                    let v11 = constructor_imm(ctx, arg0, v10);
                    // Rule at src/isa/x64/lower.isle line 4489.
                    return v11;
                }
            }
        }
    }
    let v12 = C::put_in_reg(ctx, arg1);
    let v13 = C::gpr_new(ctx, v12);
    let v14 = &constructor_reg_to_gpr_mem_imm(ctx, v12);
    let v15 = &constructor_x64_test(ctx, arg0, v13, v14);
    let v18 = &constructor_trap_if(ctx, &CC::Z, &TrapCode::INTEGER_DIVISION_BY_ZERO);
    let v19 = &constructor_with_flags_side_effect(ctx, v15, v18);
    let v20 = constructor_side_effect(ctx, v19);
    // Rule at src/isa/x64/lower.isle line 4492.
    return v12;
}

// Generated as internal constructor for term lower_pshufb.
pub fn constructor_lower_pshufb<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem128,
) -> Xmm {
    let v2 = C::has_ssse3(ctx);
    if v2 == true {
        let v3 = constructor_x64_pshufb(ctx, arg0, arg1);
        // Rule at src/isa/x64/lower.isle line 4773.
        return v3;
    }
    let v4 = C::is_xmm_128(ctx, arg1);
    if let Some(v5) = v4 {
        let v7 = C::xmm_to_reg(ctx, arg0);
        let v8 = C::xmm_to_reg(ctx, v5);
        let v9 = C::libcall_2(ctx, &LibCall::X86Pshufb, v7, v8);
        let v10 = C::xmm_new(ctx, v9);
        // Rule at src/isa/x64/lower.isle line 4776.
        return v10;
    }
    let v11 = &C::is_mem_128(ctx, arg1);
    if let Some(v12) = v11 {
        let v13 = &C::synthetic_amode_to_xmm_mem_128(ctx, v12);
        let v14 = constructor_x64_movdqu_load(ctx, v13);
        let v15 = &C::xmm_to_xmm_mem_128(ctx, v14);
        let v16 = constructor_lower_pshufb(ctx, arg0, v15);
        // Rule at src/isa/x64/lower.isle line 4778.
        return v16;
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "lower_pshufb", "src/isa/x64/lower.isle line 4772")
}

// 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 v16 = C::def_inst(ctx, arg0);
        if let Some(v17) = v16 {
            let v18 = C::inst_data_value(ctx, v17);
            match &v18.1 {
                &InstructionData::Binary {
                    opcode: ref v23,
                    args: ref v24,
                } => {
                    if let &Opcode::Band = v23 {
                        let v21 = C::ty_vec128(ctx, v18.0);
                        if let Some(v22) = v21 {
                            let v25 = C::unpack_value_array_2(ctx, v24);
                            let v44 = C::def_inst(ctx, v25.0);
                            if let Some(v45) = v44 {
                                let v46 = C::inst_data_value(ctx, v45);
                                if let &InstructionData::Unary {
                                    opcode: ref v49,
                                    arg: v50,
                                } = &v46.1 {
                                    if let &Opcode::Bnot = v49 {
                                        let v51 = constructor_put_in_xmm(ctx, v50);
                                        let v29 = &C::put_in_xmm_mem_128(ctx, v25.1);
                                        let v52 = &constructor_x64_ptest(ctx, v51, v29);
                                        let v53 = CondResult::CC {
                                            producer: v52.clone(),
                                            cc: CC::NB,
                                        };
                                        // Rule at src/isa/x64/lower.isle line 4991.
                                        return v53;
                                    }
                                }
                            }
                            let v32 = C::def_inst(ctx, v25.1);
                            if let Some(v33) = v32 {
                                let v34 = C::inst_data_value(ctx, v33);
                                if let &InstructionData::Unary {
                                    opcode: ref v37,
                                    arg: v38,
                                } = &v34.1 {
                                    if let &Opcode::Bnot = v37 {
                                        let v39 = constructor_put_in_xmm(ctx, v38);
                                        let v40 = &C::put_in_xmm_mem_128(ctx, v25.0);
                                        let v41 = &constructor_x64_ptest(ctx, v39, v40);
                                        let v43 = CondResult::CC {
                                            producer: v41.clone(),
                                            cc: CC::NB,
                                        };
                                        // Rule at src/isa/x64/lower.isle line 4988.
                                        return v43;
                                    }
                                }
                            }
                            let v28 = constructor_put_in_xmm(ctx, v25.0);
                            let v29 = &C::put_in_xmm_mem_128(ctx, v25.1);
                            let v30 = &constructor_x64_ptest(ctx, v28, v29);
                            let v31 = CondResult::CC {
                                producer: v30.clone(),
                                cc: CC::NZ,
                            };
                            // Rule at src/isa/x64/lower.isle line 4981.
                            return v31;
                        }
                    }
                }
                &InstructionData::IntCompare {
                    opcode: ref v54,
                    args: ref v55,
                    cond: ref v56,
                } => {
                    if let &Opcode::Icmp = v54 {
                        if let &IntCC::NotEqual = v56 {
                            let v21 = C::ty_vec128(ctx, v18.0);
                            if let Some(v22) = v21 {
                                let v57 = C::unpack_value_array_2(ctx, v55);
                                let v60 = constructor_put_in_xmm(ctx, v57.0);
                                let v61 = &C::put_in_xmm_mem_128(ctx, v57.1);
                                let v62 = constructor_x64_pxor(ctx, v60, v61);
                                let v63 = &C::xmm_to_xmm_mem_128(ctx, v62);
                                let v64 = &constructor_x64_ptest(ctx, v62, v63);
                                let v65 = CondResult::CC {
                                    producer: v64.clone(),
                                    cc: CC::NZ,
                                };
                                // Rule at src/isa/x64/lower.isle line 5001.
                                return v65;
                            }
                        }
                    }
                }
                _ => {}
            }
        }
        let v1 = constructor_put_in_xmm(ctx, arg0);
        let v13 = &C::xmm_to_xmm_mem_128(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 4974.
        return v15;
    }
    let v1 = constructor_put_in_xmm(ctx, arg0);
    let v3 = constructor_xmm_zero(ctx, I8X16);
    let v4 = &C::xmm_to_xmm_mem_128(ctx, v3);
    let v5 = constructor_x64_pcmpeqb(ctx, v1, v4);
    let v6 = constructor_x64_pmovmskb(ctx, v5);
    let v7 = &C::gpr_to_gpr_mem_32(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 4964.
    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 v12 = C::has_sse41(ctx);
    if v12 == true {
        let v21 = C::def_inst(ctx, arg0);
        if let Some(v22) = v21 {
            let v23 = C::inst_data_value(ctx, v22);
            if let &InstructionData::IntCompare {
                opcode: ref v28,
                args: ref v29,
                cond: ref v30,
            } = &v23.1 {
                if let &Opcode::Icmp = v28 {
                    if let &IntCC::Equal = v30 {
                        let v26 = C::ty_vec128(ctx, v23.0);
                        if let Some(v27) = v26 {
                            let v31 = C::unpack_value_array_2(ctx, v29);
                            let v34 = constructor_put_in_xmm(ctx, v31.0);
                            let v35 = &C::put_in_xmm_mem_128(ctx, v31.1);
                            let v36 = constructor_x64_pxor(ctx, v34, v35);
                            let v37 = &C::xmm_to_xmm_mem_128(ctx, v36);
                            let v38 = &constructor_x64_ptest(ctx, v36, v37);
                            let v39 = CondResult::CC {
                                producer: v38.clone(),
                                cc: CC::Z,
                            };
                            // Rule at src/isa/x64/lower.isle line 5035.
                            return v39;
                        }
                    }
                }
            }
        }
        let v13 = constructor_put_in_xmm(ctx, arg0);
        let v1 = C::value_type(ctx, arg0);
        let v14 = constructor_xmm_zero(ctx, v1);
        let v15 = constructor_vec_int_type(ctx, v1);
        let v16 = &C::xmm_to_xmm_mem_128(ctx, v14);
        let v17 = constructor_x64_pcmpeq(ctx, v15, v13, v16);
        let v18 = &C::xmm_to_xmm_mem_128(ctx, v17);
        let v19 = &constructor_x64_ptest(ctx, v17, v18);
        let v20 = CondResult::CC {
            producer: v19.clone(),
            cc: CC::Z,
        };
        // Rule at src/isa/x64/lower.isle line 5023.
        return v20;
    }
    let v1 = C::value_type(ctx, arg0);
    let v2 = constructor_vec_int_type(ctx, v1);
    let v3 = constructor_put_in_xmm(ctx, arg0);
    let v4 = constructor_xmm_zero(ctx, v1);
    let v5 = &C::xmm_to_xmm_mem_128(ctx, v4);
    let v6 = constructor_x64_pcmpeq(ctx, v2, v3, v5);
    let v7 = constructor_x64_pmovmskb(ctx, v6);
    let v8 = &C::gpr_to_gpr_mem_32(ctx, v7);
    let v9 = &constructor_x64_testl_mr(ctx, v8, v7);
    let v11 = CondResult::CC {
        producer: v9.clone(),
        cc: CC::Z,
    };
    // Rule at src/isa/x64/lower.isle line 5015.
    return v11;
}

// 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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMem128,
) -> 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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMem128,
) -> 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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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_8(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 = &C::synthetic_amode_to_gpr_mem_8(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_16(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 = &C::synthetic_amode_to_gpr_mem_16(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_32(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 = &C::synthetic_amode_to_gpr_mem_32(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_64(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 = &C::synthetic_amode_to_gpr_mem_64(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_32(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 = &C::synthetic_amode_to_gpr_mem_32(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_64(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 = &C::synthetic_amode_to_gpr_mem_64(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_8(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 = &C::synthetic_amode_to_gpr_mem_8(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_16(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 = &C::synthetic_amode_to_gpr_mem_16(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_32(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 = &C::synthetic_amode_to_gpr_mem_32(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_64(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 = &C::synthetic_amode_to_gpr_mem_64(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: &GprMem8,
) -> 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: &GprMem16,
) -> 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: &GprMem32,
) -> 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: &GprMem64,
) -> 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_8(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 = &C::synthetic_amode_to_gpr_mem_8(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_16(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 = &C::synthetic_amode_to_gpr_mem_16(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_32(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 = &C::synthetic_amode_to_gpr_mem_32(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_64(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 = &C::synthetic_amode_to_gpr_mem_64(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_32(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 = &C::synthetic_amode_to_gpr_mem_32(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_64(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 = &C::synthetic_amode_to_gpr_mem_64(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_8(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 = &C::synthetic_amode_to_gpr_mem_8(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_16(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 = &C::synthetic_amode_to_gpr_mem_16(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_32(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 = &C::synthetic_amode_to_gpr_mem_32(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_64(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 = &C::synthetic_amode_to_gpr_mem_64(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: &GprMem8,
) -> 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: &GprMem16,
) -> 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: &GprMem32,
) -> 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: &GprMem64,
) -> 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: &XmmMem32,
) -> 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: &XmmMem32,
) -> 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: &XmmMem64,
) -> 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: &XmmMem64,
) -> 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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMem32,
) -> 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: &XmmMem64,
) -> 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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &XmmMemAligned128,
    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: &XmmMem128,
    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_128_to_xmm_mem_aligned_128(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: &XmmMem128,
    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_8(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 = &C::synthetic_amode_to_gpr_mem_8(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_16(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 = &C::synthetic_amode_to_gpr_mem_16(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_32(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 = &C::synthetic_amode_to_gpr_mem_32(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_64(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 = &C::synthetic_amode_to_gpr_mem_64(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_32(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 = &C::synthetic_amode_to_gpr_mem_32(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_64(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 = &C::synthetic_amode_to_gpr_mem_64(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_8(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 = &C::synthetic_amode_to_gpr_mem_8(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_16(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 = &C::synthetic_amode_to_gpr_mem_16(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_32(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 = &C::synthetic_amode_to_gpr_mem_32(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_64(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 = &C::synthetic_amode_to_gpr_mem_64(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: &GprMem8,
) -> 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: &GprMem16,
) -> 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: &GprMem32,
) -> 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: &GprMem64,
) -> 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: &GprMem32,
) -> 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: &GprMem64,
) -> 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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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_8(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_16(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_32(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_64(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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &GprMem16,
) -> 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: &GprMem32,
) -> 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: &GprMem64,
) -> 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: &GprMem16,
) -> 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: &GprMem32,
) -> 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: &GprMem64,
) -> 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: &GprMem16,
) -> 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: &GprMem32,
) -> 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: &GprMem64,
) -> 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: &GprMem16,
) -> 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: &GprMem32,
) -> 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: &GprMem64,
) -> 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: &GprMem16,
) -> 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: &GprMem32,
) -> 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: &GprMem64,
) -> 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: &GprMem16,
    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: &GprMem32,
    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: &GprMem64,
    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: &GprMem16,
    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: &GprMem32,
    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: &GprMem64,
    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: &GprMem32,
) -> 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: &GprMem64,
) -> 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: &GprMem32,
) -> 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: &GprMem64,
) -> 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: &GprMem32,
) -> 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: &GprMem64,
) -> 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: &GprMem32,
    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: &GprMem64,
    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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &GprMem16,
) -> 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: &GprMem32,
) -> 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: &GprMem64,
) -> 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: &GprMem16,
) -> 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: &GprMem32,
) -> 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: &GprMem64,
) -> 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: &GprMem16,
) -> 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: &GprMem32,
) -> 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: &GprMem64,
) -> 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: &GprMem16,
) -> 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: &GprMem32,
) -> 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: &GprMem64,
) -> 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: &GprMem16,
) -> 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: &GprMem32,
) -> 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: &GprMem64,
) -> 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: &GprMem16,
) -> 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: &GprMem32,
) -> 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: &GprMem64,
) -> 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: &GprMem16,
) -> 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: &GprMem32,
) -> 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: &GprMem64,
) -> 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: &GprMem16,
) -> 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: &GprMem32,
) -> 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: &GprMem64,
) -> 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: &GprMem16,
) -> 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: &GprMem32,
) -> 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: &GprMem64,
) -> 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: &GprMem16,
) -> 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: &GprMem32,
) -> 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: &GprMem64,
) -> 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: &GprMem16,
) -> 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: &GprMem32,
) -> 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: &GprMem64,
) -> 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: &GprMem16,
) -> 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: &GprMem32,
) -> 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: &GprMem64,
) -> 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: &GprMem16,
) -> 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: &GprMem32,
) -> 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: &GprMem64,
) -> 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: &GprMem16,
) -> 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: &GprMem32,
) -> 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: &GprMem64,
) -> 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: &GprMem16,
) -> 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: &GprMem32,
) -> 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: &GprMem64,
) -> 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: &GprMem16,
) -> 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: &GprMem32,
) -> 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: &GprMem64,
) -> 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: &GprMem8,
    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: &GprMem16,
    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: &GprMem32,
    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: &GprMem64,
    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: &GprMem16,
    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: &GprMem32,
    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: &GprMem64,
    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: &GprMem8,
    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: &GprMem16,
    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: &GprMem32,
    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: &GprMem64,
    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: &GprMem8,
) -> 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: &GprMem16,
) -> 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: &GprMem32,
) -> 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: &GprMem64,
) -> 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: &GprMem8,
    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: &GprMem16,
    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: &GprMem32,
    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: &GprMem64,
    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: &GprMem8,
    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: &GprMem16,
    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: &GprMem32,
    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: &GprMem64,
    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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMem128,
) -> 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: &XmmMem32,
) -> 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: &XmmMem32,
) -> 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: &XmmMem64,
) -> 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: &XmmMem64,
) -> 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: &XmmMem32,
) -> 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: &XmmMem64,
) -> 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: &XmmMem32,
    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: &XmmMem64,
    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: &XmmMem128,
    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: &XmmMem128,
    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: &XmmMem32,
    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: &XmmMem64,
    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: &XmmMem128,
    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: &XmmMem128,
    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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &XmmMem64,
) -> 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: &XmmMemAligned128,
) -> 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: &XmmMem32,
) -> 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: &XmmMem32,
) -> 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: &XmmMem32,
) -> 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: &XmmMem32,
) -> 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: &XmmMem32,
) -> 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: &XmmMem64,
) -> 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: &XmmMem128,
) -> 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: &XmmMem32,
) -> 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: &XmmMem32,
) -> 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: &XmmMem32,
) -> 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: &XmmMem32,
) -> 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: &XmmMem32,
) -> 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: &XmmMemAligned128,
) -> 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: &XmmMemAligned128,
) -> 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: &XmmMem64,
) -> 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: &XmmMem64,
) -> 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: &XmmMem64,
) -> 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: &XmmMem64,
) -> 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: &XmmMem64,
) -> 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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &XmmMem64,
) -> 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: &XmmMem64,
) -> 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: &XmmMem64,
) -> 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: &XmmMem64,
) -> 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: &XmmMem64,
) -> 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: &XmmMemAligned128,
) -> 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: &XmmMem64,
) -> 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: &GprMem32,
) -> 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: &GprMem64,
) -> 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: &GprMem32,
) -> 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: &GprMem64,
) -> 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: &XmmMem64,
) -> 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: &XmmMem128,
) -> 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: &GprMem32,
) -> 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: &GprMem64,
) -> 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: &GprMem32,
) -> 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: &GprMem64,
) -> 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: &XmmMem128,
) -> 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: &GprMem8,
    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: &GprMem16,
    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: &GprMem32,
    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: &GprMem64,
    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: &GprMem8,
    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: &GprMem16,
    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: &GprMem32,
    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: &GprMem64,
    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: &XmmMem32,
) -> 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: &XmmMem32,
) -> 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: &XmmMem64,
) -> 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: &XmmMem64,
) -> 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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMem32,
) -> 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: &XmmMem64,
) -> 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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &XmmMem32,
) -> 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: &XmmMem32,
) -> 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: &XmmMem32,
) -> 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: &XmmMem64,
) -> 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: &XmmMem64,
) -> 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: &XmmMem64,
) -> 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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &XmmMem32,
) -> 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: &XmmMem32,
) -> 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: &XmmMem32,
) -> 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: &XmmMem64,
) -> 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: &XmmMem64,
) -> 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: &XmmMem64,
) -> 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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &XmmMem32,
) -> 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: &XmmMem32,
) -> 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: &XmmMem32,
) -> 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: &XmmMem64,
) -> 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: &XmmMem64,
) -> 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: &XmmMem64,
) -> 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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &XmmMem32,
) -> 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: &XmmMem32,
) -> 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: &XmmMem32,
) -> 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: &XmmMem64,
) -> 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: &XmmMem64,
) -> 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: &XmmMem64,
) -> 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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &GprMem64,
) -> 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 = &C::writable_gpr_to_gpr_mem_32(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 = &C::synthetic_amode_to_gpr_mem_32(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 = &C::writable_gpr_to_gpr_mem_32(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 = &C::synthetic_amode_to_gpr_mem_32(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 = &C::writable_gpr_to_gpr_mem_32(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 = &C::synthetic_amode_to_gpr_mem_32(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 = &C::writable_gpr_to_gpr_mem_32(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 = &C::synthetic_amode_to_gpr_mem_32(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 = &C::writable_gpr_to_gpr_mem_64(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 = &C::synthetic_amode_to_gpr_mem_64(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 = &C::writable_gpr_to_gpr_mem_32(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 = &C::synthetic_amode_to_gpr_mem_32(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 = &C::writable_gpr_to_gpr_mem_32(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 = &C::synthetic_amode_to_gpr_mem_32(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 = &C::writable_gpr_to_gpr_mem_32(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 = &C::synthetic_amode_to_gpr_mem_32(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 = &C::writable_gpr_to_gpr_mem_32(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 = &C::synthetic_amode_to_gpr_mem_32(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 = &C::writable_gpr_to_gpr_mem_64(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 = &C::synthetic_amode_to_gpr_mem_64(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: &XmmMem32,
    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: &XmmMem32,
    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: &GprMem32,
    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: &GprMem32,
    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: &GprMem32,
    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: &GprMem64,
    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: &XmmMem32,
    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: &GprMem32,
    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: &GprMem32,
    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: &GprMem32,
    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: &GprMem64,
    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: &XmmMem64,
) -> 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: &XmmMem64,
) -> 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: &XmmMem64,
) -> 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: &XmmMemAligned128,
    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: &XmmMem128,
    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_128_to_xmm_mem_aligned_128(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: &XmmMemAligned128,
    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: &XmmMemAligned128,
    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: &XmmMemAligned128,
    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: &XmmMem128,
    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: &XmmMem128,
    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: &XmmMem128,
    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: &XmmMem128,
    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: &XmmMemAligned128,
    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: &XmmMem128,
    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_128_to_xmm_mem_aligned_128(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: &XmmMem128,
    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: &XmmMemAligned128,
    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: &XmmMem128,
    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_128_to_xmm_mem_aligned_128(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: &XmmMem128,
    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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMemAligned128,
    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: &XmmMem128,
    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_128_to_xmm_mem_aligned_128(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: &XmmMemAligned128,
    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: &XmmMem128,
    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_128_to_xmm_mem_aligned_128(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: &XmmMemAligned128,
    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: &XmmMem128,
    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_128_to_xmm_mem_aligned_128(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: &XmmMem128,
) -> 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: &XmmMem128,
    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: &XmmMem128,
    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: &XmmMem128,
    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: &XmmMem8,
) -> 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: &XmmMem16,
) -> 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: &XmmMem32,
) -> 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: &XmmMem64,
) -> 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: &XmmMem128,
) -> 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: &XmmMem32,
) -> 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: &XmmMem32,
) -> 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: &XmmMem64,
) -> 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: &XmmMem64,
) -> 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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMem32,
) -> 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: &XmmMem64,
) -> 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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &XmmMem32,
) -> 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: &XmmMem32,
) -> 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: &XmmMem64,
) -> 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: &XmmMem64,
) -> 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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMem32,
) -> 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: &XmmMem64,
) -> 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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &GprMem64,
) -> 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 = &C::writable_gpr_to_gpr_mem_8(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 = &C::synthetic_amode_to_gpr_mem_8(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 = &C::writable_gpr_to_gpr_mem_16(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 = &C::synthetic_amode_to_gpr_mem_16(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 = &C::writable_gpr_to_gpr_mem_32(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 = &C::synthetic_amode_to_gpr_mem_32(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 = &C::writable_gpr_to_gpr_mem_64(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 = &C::synthetic_amode_to_gpr_mem_64(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: &GprMem8,
) -> 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: &GprMem16,
) -> 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: &GprMem32,
) -> 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: &GprMem64,
) -> 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 = &C::writable_gpr_to_gpr_mem_8(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 = &C::synthetic_amode_to_gpr_mem_8(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 = &C::writable_gpr_to_gpr_mem_16(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 = &C::synthetic_amode_to_gpr_mem_16(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 = &C::writable_gpr_to_gpr_mem_32(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 = &C::synthetic_amode_to_gpr_mem_32(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 = &C::writable_gpr_to_gpr_mem_64(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 = &C::synthetic_amode_to_gpr_mem_64(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: &GprMem8,
) -> 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: &GprMem8,
) -> 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: &GprMem8,
) -> 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: &GprMem16,
) -> 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: &GprMem16,
) -> 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: &GprMem16,
) -> 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: &GprMem32,
) -> 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: &GprMem8,
) -> 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: &GprMem8,
) -> 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: &GprMem8,
) -> 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: &GprMem16,
) -> 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: &GprMem16,
) -> 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: &GprMem16,
) -> 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: &GprMem32,
) -> 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: &GprMem64,
) -> 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 = &C::writable_gpr_to_gpr_mem_32(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 = &C::synthetic_amode_to_gpr_mem_32(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 = &C::writable_gpr_to_gpr_mem_64(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 = &C::synthetic_amode_to_gpr_mem_64(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: &GprMem32,
) -> 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: &GprMem64,
) -> 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 = &C::writable_gpr_to_gpr_mem_32(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 = &C::synthetic_amode_to_gpr_mem_32(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 = &C::writable_gpr_to_gpr_mem_64(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 = &C::synthetic_amode_to_gpr_mem_64(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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> Xmm {
    let v1 = C::has_avx(ctx);
    if v1 == true {
        let v2 = &C::xmm_mem_128_to_xmm_mem_aligned_128(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_128_to_xmm_mem_aligned_128(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 = &C::writable_xmm_to_xmm_mem_aligned_128(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_128(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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> Xmm {
    let v1 = C::has_avx(ctx);
    if v1 == true {
        let v2 = &C::xmm_mem_128_to_xmm_mem_aligned_128(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_128_to_xmm_mem_aligned_128(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 = &C::writable_xmm_to_xmm_mem_aligned_128(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_128(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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> Xmm {
    let v1 = C::has_avx(ctx);
    if v1 == true {
        let v2 = &C::xmm_mem_128_to_xmm_mem_aligned_128(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_128_to_xmm_mem_aligned_128(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 = &C::writable_xmm_to_xmm_mem_aligned_128(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_128(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: &XmmMemAligned128,
) -> 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 = &C::writable_xmm_to_xmm_mem_aligned_128(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_128(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: &XmmMemAligned128,
) -> 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 = &C::writable_xmm_to_xmm_mem_aligned_128(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_128(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: &XmmMemAligned128,
) -> 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 = &C::writable_xmm_to_xmm_mem_aligned_128(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_128(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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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 = &C::writable_xmm_to_xmm_mem_128(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 = &C::synthetic_amode_to_xmm_mem_128(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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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 = &C::writable_xmm_to_xmm_mem_128(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 = &C::synthetic_amode_to_xmm_mem_128(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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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 = &C::writable_xmm_to_xmm_mem_128(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 = &C::synthetic_amode_to_xmm_mem_128(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: &XmmMem128,
) -> 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 = &C::writable_xmm_to_xmm_mem_128(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 = &C::synthetic_amode_to_xmm_mem_128(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: &XmmMem128,
) -> 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 = &C::writable_xmm_to_xmm_mem_128(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 = &C::synthetic_amode_to_xmm_mem_128(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: &XmmMem128,
) -> 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 = &C::writable_xmm_to_xmm_mem_128(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 = &C::synthetic_amode_to_xmm_mem_128(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: &XmmMem64,
) -> 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: &XmmMem64,
) -> 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: &XmmMem32,
) -> 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: &XmmMem32,
) -> 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: &XmmMem16,
) -> 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: &XmmMem16,
) -> 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: &XmmMem64,
) -> 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: &XmmMem64,
) -> 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: &XmmMem32,
) -> 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: &XmmMem32,
) -> 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: &XmmMem64,
) -> 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: &XmmMem64,
) -> 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: &XmmMem64,
) -> 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: &XmmMem32,
) -> 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: &XmmMem16,
) -> 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: &XmmMem64,
) -> 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: &XmmMem32,
) -> 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: &XmmMem64,
) -> 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: &XmmMem64,
) -> 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: &XmmMem64,
) -> 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: &XmmMem32,
) -> 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: &XmmMem32,
) -> 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: &XmmMem16,
) -> 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: &XmmMem16,
) -> 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: &XmmMem64,
) -> 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: &XmmMem64,
) -> 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: &XmmMem32,
) -> 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: &XmmMem32,
) -> 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: &XmmMem64,
) -> 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: &XmmMem64,
) -> 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: &XmmMem64,
) -> 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: &XmmMem32,
) -> 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: &XmmMem16,
) -> 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: &XmmMem64,
) -> 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: &XmmMem32,
) -> 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: &XmmMem64,
) -> 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: &GprMem8,
) -> 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: &GprMem16,
) -> 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: &GprMem32,
) -> 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: &GprMem64,
) -> 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: &GprMem8,
) -> 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: &GprMem16,
) -> 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: &GprMem32,
) -> 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: &GprMem64,
) -> 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: &GprMem16,
) -> 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: &GprMem32,
) -> 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: &GprMem64,
) -> 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: &GprMem16,
    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: &GprMem32,
    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: &GprMem64,
    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: &GprMem16,
    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: &GprMem32,
    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: &GprMem64,
    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: &GprMem32,
    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: &GprMem64,
    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: &XmmMem32,
) -> 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: &XmmMem32,
) -> 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: &XmmMem64,
) -> 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: &XmmMem64,
) -> 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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMem32,
) -> 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: &XmmMem64,
) -> 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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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_8(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 = &C::synthetic_amode_to_gpr_mem_8(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_16(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 = &C::synthetic_amode_to_gpr_mem_16(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_32(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 = &C::synthetic_amode_to_gpr_mem_32(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_64(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 = &C::synthetic_amode_to_gpr_mem_64(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_8(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 = &C::synthetic_amode_to_gpr_mem_8(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_16(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 = &C::synthetic_amode_to_gpr_mem_16(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_32(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 = &C::synthetic_amode_to_gpr_mem_32(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_64(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 = &C::synthetic_amode_to_gpr_mem_64(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: &GprMem32,
) -> 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_8(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 = &C::synthetic_amode_to_gpr_mem_8(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_16(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 = &C::synthetic_amode_to_gpr_mem_16(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_32(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 = &C::synthetic_amode_to_gpr_mem_32(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_64(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 = &C::synthetic_amode_to_gpr_mem_64(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_32(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 = &C::synthetic_amode_to_gpr_mem_32(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_64(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 = &C::synthetic_amode_to_gpr_mem_64(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_8(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 = &C::synthetic_amode_to_gpr_mem_8(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_16(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 = &C::synthetic_amode_to_gpr_mem_16(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_32(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 = &C::synthetic_amode_to_gpr_mem_32(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_64(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 = &C::synthetic_amode_to_gpr_mem_64(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: &GprMem8,
) -> 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: &GprMem16,
) -> 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: &GprMem32,
) -> 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: &GprMem64,
) -> 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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMem128,
) -> 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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMem128,
) -> 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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMem32,
) -> 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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMem32,
) -> 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: &XmmMem128,
) -> 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: &XmmMem32,
) -> 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: &XmmMem128,
) -> 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: &XmmMem32,
) -> 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: &XmmMemAligned128,
    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: &XmmMemAligned128,
    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: &XmmMem64,
    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: &XmmMem32,
    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: &XmmMem128,
    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: &XmmMem128,
    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: &XmmMem64,
    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: &XmmMem32,
    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 = &C::writable_gpr_to_gpr_mem_8(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 = &C::writable_gpr_to_gpr_mem_8(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 = &C::writable_gpr_to_gpr_mem_8(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 = &C::writable_gpr_to_gpr_mem_8(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 = &C::writable_gpr_to_gpr_mem_8(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 = &C::writable_gpr_to_gpr_mem_8(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 = &C::writable_gpr_to_gpr_mem_8(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 = &C::writable_gpr_to_gpr_mem_8(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 = &C::writable_gpr_to_gpr_mem_8(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 = &C::writable_gpr_to_gpr_mem_8(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 = &C::writable_gpr_to_gpr_mem_8(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 = &C::writable_gpr_to_gpr_mem_8(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 = &C::writable_gpr_to_gpr_mem_8(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 = &C::writable_gpr_to_gpr_mem_8(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 = &C::writable_gpr_to_gpr_mem_8(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 = &C::writable_gpr_to_gpr_mem_8(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_8(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 = &C::synthetic_amode_to_gpr_mem_8(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_8(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 = &C::synthetic_amode_to_gpr_mem_8(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_8(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 = &C::synthetic_amode_to_gpr_mem_8(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_16(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 = &C::synthetic_amode_to_gpr_mem_16(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_16(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 = &C::synthetic_amode_to_gpr_mem_16(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_16(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 = &C::synthetic_amode_to_gpr_mem_16(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_32(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 = &C::synthetic_amode_to_gpr_mem_32(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_32(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 = &C::synthetic_amode_to_gpr_mem_32(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_32(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 = &C::synthetic_amode_to_gpr_mem_32(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_64(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 = &C::synthetic_amode_to_gpr_mem_64(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_64(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 = &C::synthetic_amode_to_gpr_mem_64(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_64(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 = &C::synthetic_amode_to_gpr_mem_64(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_8(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 = &C::synthetic_amode_to_gpr_mem_8(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_8(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 = &C::synthetic_amode_to_gpr_mem_8(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_8(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 = &C::synthetic_amode_to_gpr_mem_8(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_16(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 = &C::synthetic_amode_to_gpr_mem_16(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_16(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 = &C::synthetic_amode_to_gpr_mem_16(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_16(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 = &C::synthetic_amode_to_gpr_mem_16(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_32(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 = &C::synthetic_amode_to_gpr_mem_32(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_32(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 = &C::synthetic_amode_to_gpr_mem_32(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_32(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 = &C::synthetic_amode_to_gpr_mem_32(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_64(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 = &C::synthetic_amode_to_gpr_mem_64(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_64(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 = &C::synthetic_amode_to_gpr_mem_64(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_64(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 = &C::synthetic_amode_to_gpr_mem_64(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_8(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 = &C::synthetic_amode_to_gpr_mem_8(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_8(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 = &C::synthetic_amode_to_gpr_mem_8(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_8(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 = &C::synthetic_amode_to_gpr_mem_8(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_16(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 = &C::synthetic_amode_to_gpr_mem_16(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_16(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 = &C::synthetic_amode_to_gpr_mem_16(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_16(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 = &C::synthetic_amode_to_gpr_mem_16(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_32(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 = &C::synthetic_amode_to_gpr_mem_32(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_32(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 = &C::synthetic_amode_to_gpr_mem_32(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_32(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 = &C::synthetic_amode_to_gpr_mem_32(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_64(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 = &C::synthetic_amode_to_gpr_mem_64(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_64(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 = &C::synthetic_amode_to_gpr_mem_64(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_64(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 = &C::synthetic_amode_to_gpr_mem_64(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_8(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 = &C::synthetic_amode_to_gpr_mem_8(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_8(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 = &C::synthetic_amode_to_gpr_mem_8(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_8(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 = &C::synthetic_amode_to_gpr_mem_8(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_16(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 = &C::synthetic_amode_to_gpr_mem_16(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_16(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 = &C::synthetic_amode_to_gpr_mem_16(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_16(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 = &C::synthetic_amode_to_gpr_mem_16(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_32(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 = &C::synthetic_amode_to_gpr_mem_32(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_32(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 = &C::synthetic_amode_to_gpr_mem_32(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_32(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 = &C::synthetic_amode_to_gpr_mem_32(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_64(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 = &C::synthetic_amode_to_gpr_mem_64(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_64(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 = &C::synthetic_amode_to_gpr_mem_64(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_64(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 = &C::synthetic_amode_to_gpr_mem_64(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_8(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 = &C::synthetic_amode_to_gpr_mem_8(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_8(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 = &C::synthetic_amode_to_gpr_mem_8(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_8(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 = &C::synthetic_amode_to_gpr_mem_8(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_16(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 = &C::synthetic_amode_to_gpr_mem_16(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_16(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 = &C::synthetic_amode_to_gpr_mem_16(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_16(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 = &C::synthetic_amode_to_gpr_mem_16(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_32(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 = &C::synthetic_amode_to_gpr_mem_32(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_32(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 = &C::synthetic_amode_to_gpr_mem_32(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_32(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 = &C::synthetic_amode_to_gpr_mem_32(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_64(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 = &C::synthetic_amode_to_gpr_mem_64(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_64(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 = &C::synthetic_amode_to_gpr_mem_64(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_64(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 = &C::synthetic_amode_to_gpr_mem_64(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_16(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 = &C::synthetic_amode_to_gpr_mem_16(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_16(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 = &C::synthetic_amode_to_gpr_mem_16(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_32(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 = &C::synthetic_amode_to_gpr_mem_32(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_64(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 = &C::synthetic_amode_to_gpr_mem_64(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_32(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 = &C::synthetic_amode_to_gpr_mem_32(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_64(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 = &C::synthetic_amode_to_gpr_mem_64(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: &GprMem32,
    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: &GprMem32,
    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: &GprMem32,
    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: &GprMem64,
    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: &GprMem64,
    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: &GprMem64,
    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: &GprMem32,
    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: &GprMem64,
    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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &XmmMem128,
    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: &XmmMem128,
) -> 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: &XmmMem128,
    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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &XmmMem128,
    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: &XmmMem128,
) -> 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: &XmmMem128,
    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: &XmmMem128,
) -> 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: &XmmMem128,
    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: &XmmMem128,
) -> 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: &XmmMem128,
    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: &XmmMem32,
) -> 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: &XmmMem32,
) -> 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: &XmmMem64,
) -> 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: &XmmMem64,
) -> 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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMem32,
) -> 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: &XmmMem64,
) -> 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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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 = &C::writable_gpr_to_gpr_mem_16(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 = &C::synthetic_amode_to_gpr_mem_16(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 = &C::writable_gpr_to_gpr_mem_64(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 = &C::synthetic_amode_to_gpr_mem_64(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_8(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 = &C::synthetic_amode_to_gpr_mem_8(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_16(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 = &C::synthetic_amode_to_gpr_mem_16(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_32(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 = &C::synthetic_amode_to_gpr_mem_32(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_64(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 = &C::synthetic_amode_to_gpr_mem_64(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_32(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 = &C::synthetic_amode_to_gpr_mem_32(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_64(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 = &C::synthetic_amode_to_gpr_mem_64(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_8(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 = &C::synthetic_amode_to_gpr_mem_8(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_16(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 = &C::synthetic_amode_to_gpr_mem_16(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_32(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 = &C::synthetic_amode_to_gpr_mem_32(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_64(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 = &C::synthetic_amode_to_gpr_mem_64(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: &GprMem8,
) -> 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: &GprMem16,
) -> 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: &GprMem32,
) -> 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: &GprMem64,
) -> 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_8(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 = &C::synthetic_amode_to_gpr_mem_8(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_16(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 = &C::synthetic_amode_to_gpr_mem_16(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_32(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 = &C::synthetic_amode_to_gpr_mem_32(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_64(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 = &C::synthetic_amode_to_gpr_mem_64(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_32(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 = &C::synthetic_amode_to_gpr_mem_32(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_64(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 = &C::synthetic_amode_to_gpr_mem_64(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_8(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 = &C::synthetic_amode_to_gpr_mem_8(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_16(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 = &C::synthetic_amode_to_gpr_mem_16(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_32(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 = &C::synthetic_amode_to_gpr_mem_32(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_64(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 = &C::synthetic_amode_to_gpr_mem_64(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: &GprMem8,
) -> 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: &GprMem16,
) -> 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: &GprMem32,
) -> 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: &GprMem64,
) -> 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: &XmmMem32,
) -> 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: &XmmMem32,
) -> 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: &XmmMem64,
) -> 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: &XmmMem64,
) -> 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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMem32,
) -> 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: &XmmMem64,
) -> 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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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_8(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 = &C::synthetic_amode_to_gpr_mem_8(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_16(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 = &C::synthetic_amode_to_gpr_mem_16(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_32(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 = &C::synthetic_amode_to_gpr_mem_32(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_64(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 = &C::synthetic_amode_to_gpr_mem_64(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_32(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 = &C::synthetic_amode_to_gpr_mem_32(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_64(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 = &C::synthetic_amode_to_gpr_mem_64(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_8(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 = &C::synthetic_amode_to_gpr_mem_8(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_16(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 = &C::synthetic_amode_to_gpr_mem_16(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_32(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 = &C::synthetic_amode_to_gpr_mem_32(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_64(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 = &C::synthetic_amode_to_gpr_mem_64(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: &GprMem8,
) -> 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: &GprMem16,
) -> 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: &GprMem32,
) -> 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: &GprMem64,
) -> 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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMemAligned128,
) -> 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: &XmmMem128,
) -> 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_128_to_xmm_mem_aligned_128(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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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: &XmmMem128,
) -> 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;
}
