// GENERATED BY ISLE. DO NOT EDIT!
//
// Generated automatically from the instruction-selection DSL code in:
// - src/prelude.isle
// - src/prelude_opt.isle
// - src/opts/arithmetic.isle
// - src/opts/bitops.isle
// - src/opts/cprop.isle
// - src/opts/extends.isle
// - src/opts/icmp.isle
// - src/opts/remat.isle
// - src/opts/selects.isle
// - src/opts/shifts.isle
// - src/opts/skeleton.isle
// - src/opts/spaceship.isle
// - src/opts/spectre.isle
// - src/opts/vector.isle
// - <OUT_DIR>/numerics.isle
// - <OUT_DIR>/clif_opt.isle

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

/// Context during lowering: an implementation of this trait
/// must be provided with all external constructors and extractors.
/// A mutable borrow is passed along through all lowering logic.
pub trait Context {
    fn unit(&mut self, ) -> Unit;
    fn def_inst(&mut self, arg0: Value) -> Option<Inst>;
    fn value_type(&mut self, arg0: Value) -> Type;
    fn u32_nonnegative(&mut self, arg0: u32) -> Option<u32>;
    fn offset32(&mut self, arg0: Offset32) -> i32;
    fn checked_add_with_type(&mut self, arg0: Type, arg1: u64, arg2: u64) -> Option<u64>;
    fn add_overflows_with_type(&mut self, arg0: Type, arg1: u64, arg2: u64) -> bool;
    fn imm64_sdiv(&mut self, arg0: Type, arg1: Imm64, arg2: Imm64) -> Option<Imm64>;
    fn imm64_srem(&mut self, arg0: Type, arg1: Imm64, arg2: Imm64) -> Option<Imm64>;
    fn imm64_shl(&mut self, arg0: Type, arg1: Imm64, arg2: Imm64) -> Imm64;
    fn imm64_ushr(&mut self, arg0: Type, arg1: Imm64, arg2: Imm64) -> Imm64;
    fn imm64_sshr(&mut self, arg0: Type, arg1: Imm64, arg2: Imm64) -> Imm64;
    fn i64_sextend_u64(&mut self, arg0: Type, arg1: u64) -> i64;
    fn i64_sextend_imm64(&mut self, arg0: Type, arg1: Imm64) -> i64;
    fn u64_uextend_imm64(&mut self, arg0: Type, arg1: Imm64) -> u64;
    fn imm64_icmp(&mut self, arg0: Type, arg1: &IntCC, arg2: Imm64, arg3: Imm64) -> Imm64;
    fn imm64_clz(&mut self, arg0: Type, arg1: Imm64) -> Imm64;
    fn imm64_ctz(&mut self, arg0: Type, arg1: Imm64) -> Imm64;
    fn u128_replicated_u64(&mut self, arg0: u128) -> Option<u64>;
    fn u64_replicated_u32(&mut self, arg0: u64) -> Option<u64>;
    fn u32_replicated_u16(&mut self, arg0: u64) -> Option<u64>;
    fn u16_replicated_u8(&mut self, arg0: u64) -> Option<u8>;
    fn u128_low_bits(&mut self, arg0: u128) -> u64;
    fn u128_high_bits(&mut self, arg0: u128) -> u64;
    fn f16_min(&mut self, arg0: Ieee16, arg1: Ieee16) -> Option<Ieee16>;
    fn f16_max(&mut self, arg0: Ieee16, arg1: Ieee16) -> Option<Ieee16>;
    fn f16_neg(&mut self, arg0: Ieee16) -> Ieee16;
    fn f16_abs(&mut self, arg0: Ieee16) -> Ieee16;
    fn f16_copysign(&mut self, arg0: Ieee16, arg1: Ieee16) -> Ieee16;
    fn f32_add(&mut self, arg0: Ieee32, arg1: Ieee32) -> Option<Ieee32>;
    fn f32_sub(&mut self, arg0: Ieee32, arg1: Ieee32) -> Option<Ieee32>;
    fn f32_mul(&mut self, arg0: Ieee32, arg1: Ieee32) -> Option<Ieee32>;
    fn f32_div(&mut self, arg0: Ieee32, arg1: Ieee32) -> Option<Ieee32>;
    fn f32_sqrt(&mut self, arg0: Ieee32) -> Option<Ieee32>;
    fn f32_ceil(&mut self, arg0: Ieee32) -> Option<Ieee32>;
    fn f32_floor(&mut self, arg0: Ieee32) -> Option<Ieee32>;
    fn f32_trunc(&mut self, arg0: Ieee32) -> Option<Ieee32>;
    fn f32_nearest(&mut self, arg0: Ieee32) -> Option<Ieee32>;
    fn f32_min(&mut self, arg0: Ieee32, arg1: Ieee32) -> Option<Ieee32>;
    fn f32_max(&mut self, arg0: Ieee32, arg1: Ieee32) -> Option<Ieee32>;
    fn f32_neg(&mut self, arg0: Ieee32) -> Ieee32;
    fn f32_abs(&mut self, arg0: Ieee32) -> Ieee32;
    fn f32_copysign(&mut self, arg0: Ieee32, arg1: Ieee32) -> Ieee32;
    fn f64_add(&mut self, arg0: Ieee64, arg1: Ieee64) -> Option<Ieee64>;
    fn f64_sub(&mut self, arg0: Ieee64, arg1: Ieee64) -> Option<Ieee64>;
    fn f64_mul(&mut self, arg0: Ieee64, arg1: Ieee64) -> Option<Ieee64>;
    fn f64_div(&mut self, arg0: Ieee64, arg1: Ieee64) -> Option<Ieee64>;
    fn f64_sqrt(&mut self, arg0: Ieee64) -> Option<Ieee64>;
    fn f64_ceil(&mut self, arg0: Ieee64) -> Option<Ieee64>;
    fn f64_floor(&mut self, arg0: Ieee64) -> Option<Ieee64>;
    fn f64_trunc(&mut self, arg0: Ieee64) -> Option<Ieee64>;
    fn f64_nearest(&mut self, arg0: Ieee64) -> Option<Ieee64>;
    fn f64_min(&mut self, arg0: Ieee64, arg1: Ieee64) -> Option<Ieee64>;
    fn f64_max(&mut self, arg0: Ieee64, arg1: Ieee64) -> Option<Ieee64>;
    fn f64_neg(&mut self, arg0: Ieee64) -> Ieee64;
    fn f64_abs(&mut self, arg0: Ieee64) -> Ieee64;
    fn f64_copysign(&mut self, arg0: Ieee64, arg1: Ieee64) -> Ieee64;
    fn f128_min(&mut self, arg0: Ieee128, arg1: Ieee128) -> Option<Ieee128>;
    fn f128_max(&mut self, arg0: Ieee128, arg1: Ieee128) -> Option<Ieee128>;
    fn f128_neg(&mut self, arg0: Ieee128) -> Ieee128;
    fn f128_abs(&mut self, arg0: Ieee128) -> Ieee128;
    fn f128_copysign(&mut self, arg0: Ieee128, arg1: Ieee128) -> Ieee128;
    fn ty_umin(&mut self, arg0: Type) -> u64;
    fn ty_umax(&mut self, arg0: Type) -> u64;
    fn ty_smin(&mut self, arg0: Type) -> u64;
    fn ty_smax(&mut self, arg0: Type) -> u64;
    fn ty_bits(&mut self, arg0: Type) -> u8;
    fn ty_bits_u16(&mut self, arg0: Type) -> u16;
    fn ty_bits_u64(&mut self, arg0: Type) -> u64;
    fn ty_mask(&mut self, arg0: Type) -> u64;
    fn ty_lane_mask(&mut self, arg0: Type) -> u64;
    fn ty_lane_count(&mut self, arg0: Type) -> u64;
    fn ty_bytes(&mut self, arg0: Type) -> u16;
    fn lane_type(&mut self, arg0: Type) -> Type;
    fn ty_half_lanes(&mut self, arg0: Type) -> Option<Type>;
    fn ty_half_width(&mut self, arg0: Type) -> Option<Type>;
    fn ty_equal(&mut self, arg0: Type, arg1: Type) -> bool;
    fn mem_flags_trusted(&mut self, ) -> MemFlags;
    fn little_or_native_endian(&mut self, arg0: MemFlags) -> Option<MemFlags>;
    fn intcc_swap_args(&mut self, arg0: &IntCC) -> IntCC;
    fn intcc_complement(&mut self, arg0: &IntCC) -> IntCC;
    fn intcc_without_eq(&mut self, arg0: &IntCC) -> IntCC;
    fn floatcc_swap_args(&mut self, arg0: &FloatCC) -> FloatCC;
    fn floatcc_complement(&mut self, arg0: &FloatCC) -> FloatCC;
    fn floatcc_unordered(&mut self, arg0: &FloatCC) -> bool;
    fn fits_in_16(&mut self, arg0: Type) -> Option<Type>;
    fn fits_in_32(&mut self, arg0: Type) -> Option<Type>;
    fn lane_fits_in_32(&mut self, arg0: Type) -> Option<Type>;
    fn fits_in_64(&mut self, arg0: Type) -> Option<Type>;
    fn ty_16(&mut self, arg0: Type) -> Option<Type>;
    fn ty_32(&mut self, arg0: Type) -> Option<Type>;
    fn ty_64(&mut self, arg0: Type) -> Option<Type>;
    fn ty_128(&mut self, arg0: Type) -> Option<Type>;
    fn ty_int_ref_scalar_64_extract(&mut self, arg0: Type) -> Option<Type>;
    fn ty_int_ref_scalar_64(&mut self, arg0: Type) -> Option<Type>;
    fn ty_32_or_64(&mut self, arg0: Type) -> Option<Type>;
    fn ty_8_or_16(&mut self, arg0: Type) -> Option<Type>;
    fn ty_16_or_32(&mut self, arg0: Type) -> Option<Type>;
    fn int_fits_in_32(&mut self, arg0: Type) -> Option<Type>;
    fn ty_int_ref_64(&mut self, arg0: Type) -> Option<Type>;
    fn ty_int_ref_16_to_64(&mut self, arg0: Type) -> Option<Type>;
    fn ty_int(&mut self, arg0: Type) -> Option<Type>;
    fn ty_scalar(&mut self, arg0: Type) -> Option<Type>;
    fn ty_scalar_float(&mut self, arg0: Type) -> Option<Type>;
    fn ty_float_or_vec(&mut self, arg0: Type) -> Option<Type>;
    fn ty_vector_float(&mut self, arg0: Type) -> Option<Type>;
    fn ty_vector_not_float(&mut self, arg0: Type) -> Option<Type>;
    fn ty_vec64(&mut self, arg0: Type) -> Option<Type>;
    fn ty_vec64_ctor(&mut self, arg0: Type) -> Option<Type>;
    fn ty_vec128(&mut self, arg0: Type) -> Option<Type>;
    fn ty_dyn_vec64(&mut self, arg0: Type) -> Option<Type>;
    fn ty_dyn_vec128(&mut self, arg0: Type) -> Option<Type>;
    fn ty_vec64_int(&mut self, arg0: Type) -> Option<Type>;
    fn ty_vec128_int(&mut self, arg0: Type) -> Option<Type>;
    fn ty_addr64(&mut self, arg0: Type) -> Option<Type>;
    fn not_vec32x2(&mut self, arg0: Type) -> Option<Type>;
    fn not_i64x2(&mut self, arg0: Type) -> Option<()>;
    fn u8_from_uimm8(&mut self, arg0: Uimm8) -> u8;
    fn u64_from_bool(&mut self, arg0: bool) -> u64;
    fn u64_from_imm64(&mut self, arg0: Imm64) -> u64;
    fn nonzero_u64_from_imm64(&mut self, arg0: Imm64) -> Option<u64>;
    fn imm64_power_of_two(&mut self, arg0: Imm64) -> Option<u64>;
    fn imm64(&mut self, arg0: u64) -> Imm64;
    fn imm64_masked(&mut self, arg0: Type, arg1: u64) -> Imm64;
    fn u16_from_ieee16(&mut self, arg0: Ieee16) -> u16;
    fn u32_from_ieee32(&mut self, arg0: Ieee32) -> u32;
    fn u64_from_ieee64(&mut self, arg0: Ieee64) -> u64;
    fn multi_lane(&mut self, arg0: Type) -> Option<(u32, u32)>;
    fn dynamic_lane(&mut self, arg0: Type) -> Option<(u32, u32)>;
    fn ty_dyn64_int(&mut self, arg0: Type) -> Option<Type>;
    fn ty_dyn128_int(&mut self, arg0: Type) -> Option<Type>;
    fn offset32_to_i32(&mut self, arg0: Offset32) -> i32;
    fn i32_to_offset32(&mut self, arg0: i32) -> Offset32;
    fn intcc_unsigned(&mut self, arg0: &IntCC) -> IntCC;
    fn signed_cond_code(&mut self, arg0: &IntCC) -> Option<IntCC>;
    fn trap_code_division_by_zero(&mut self, ) -> TrapCode;
    fn trap_code_integer_overflow(&mut self, ) -> TrapCode;
    fn trap_code_bad_conversion_to_integer(&mut self, ) -> TrapCode;
    type inst_data_value_etor_returns: Default + IntoContextIter<Context = Self, Output = (Type, InstructionData)>;
    fn inst_data_value_etor(&mut self, arg0: Value, returns: &mut Self::inst_data_value_etor_returns) -> ();
    fn inst_data_etor(&mut self, arg0: Inst) -> Option<InstructionData>;
    type inst_data_value_tupled_etor_returns: Default + IntoContextIter<Context = Self, Output = TypeAndInstructionData>;
    fn inst_data_value_tupled_etor(&mut self, arg0: Value, returns: &mut Self::inst_data_value_tupled_etor_returns) -> ();
    fn make_inst_ctor(&mut self, arg0: Type, arg1: &InstructionData) -> Value;
    fn make_skeleton_inst_ctor(&mut self, arg0: &InstructionData) -> Inst;
    fn value_array_2_ctor(&mut self, arg0: Value, arg1: Value) -> ValueArray2;
    fn value_array_3_ctor(&mut self, arg0: Value, arg1: Value, arg2: Value) -> ValueArray3;
    fn remat(&mut self, arg0: Value) -> Value;
    fn subsume(&mut self, arg0: Value) -> Value;
    fn iconst_sextend_etor(&mut self, arg0: TypeAndInstructionData) -> Option<(Type, i64)>;
    type sextend_maybe_etor_returns: Default + IntoContextIter<Context = Self, Output = (Type, Value)>;
    fn sextend_maybe_etor(&mut self, arg0: Value, returns: &mut Self::sextend_maybe_etor_returns) -> ();
    type uextend_maybe_etor_returns: Default + IntoContextIter<Context = Self, Output = (Type, Value)>;
    fn uextend_maybe_etor(&mut self, arg0: Value, returns: &mut Self::uextend_maybe_etor_returns) -> ();
    fn div_const_magic_u32(&mut self, arg0: u32) -> DivConstMagicU32;
    fn div_const_magic_u64(&mut self, arg0: u64) -> DivConstMagicU64;
    fn div_const_magic_s32(&mut self, arg0: i32) -> DivConstMagicS32;
    fn div_const_magic_s64(&mut self, arg0: i64) -> DivConstMagicS64;
    fn splat64(&mut self, arg0: u64) -> Constant;
    fn f32_from_uint(&mut self, arg0: u64) -> Ieee32;
    fn f64_from_uint(&mut self, arg0: u64) -> Ieee64;
    fn f32_from_sint(&mut self, arg0: i64) -> Ieee32;
    fn f64_from_sint(&mut self, arg0: i64) -> Ieee64;
    fn u64_bswap16(&mut self, arg0: u64) -> u64;
    fn u64_bswap32(&mut self, arg0: u64) -> u64;
    fn u64_bswap64(&mut self, arg0: u64) -> u64;
    fn ieee128_constant_extractor(&mut self, arg0: Constant) -> Option<Ieee128>;
    fn ieee128_constant(&mut self, arg0: Ieee128) -> Constant;
    fn i8_eq(&mut self, arg0: i8, arg1: i8) -> bool;
    fn i8_ne(&mut self, arg0: i8, arg1: i8) -> bool;
    fn i8_lt(&mut self, arg0: i8, arg1: i8) -> bool;
    fn i8_lt_eq(&mut self, arg0: i8, arg1: i8) -> bool;
    fn i8_gt(&mut self, arg0: i8, arg1: i8) -> bool;
    fn i8_gt_eq(&mut self, arg0: i8, arg1: i8) -> bool;
    fn i8_checked_add(&mut self, arg0: i8, arg1: i8) -> Option<i8>;
    fn i8_wrapping_add(&mut self, arg0: i8, arg1: i8) -> i8;
    fn i8_add(&mut self, arg0: i8, arg1: i8) -> i8;
    fn i8_checked_sub(&mut self, arg0: i8, arg1: i8) -> Option<i8>;
    fn i8_wrapping_sub(&mut self, arg0: i8, arg1: i8) -> i8;
    fn i8_sub(&mut self, arg0: i8, arg1: i8) -> i8;
    fn i8_checked_mul(&mut self, arg0: i8, arg1: i8) -> Option<i8>;
    fn i8_wrapping_mul(&mut self, arg0: i8, arg1: i8) -> i8;
    fn i8_mul(&mut self, arg0: i8, arg1: i8) -> i8;
    fn i8_checked_div(&mut self, arg0: i8, arg1: i8) -> Option<i8>;
    fn i8_wrapping_div(&mut self, arg0: i8, arg1: i8) -> i8;
    fn i8_div(&mut self, arg0: i8, arg1: i8) -> i8;
    fn i8_checked_rem(&mut self, arg0: i8, arg1: i8) -> Option<i8>;
    fn i8_rem(&mut self, arg0: i8, arg1: i8) -> i8;
    fn i8_and(&mut self, arg0: i8, arg1: i8) -> i8;
    fn i8_or(&mut self, arg0: i8, arg1: i8) -> i8;
    fn i8_xor(&mut self, arg0: i8, arg1: i8) -> i8;
    fn i8_not(&mut self, arg0: i8) -> i8;
    fn i8_checked_shl(&mut self, arg0: i8, arg1: u32) -> Option<i8>;
    fn i8_wrapping_shl(&mut self, arg0: i8, arg1: u32) -> i8;
    fn i8_shl(&mut self, arg0: i8, arg1: u32) -> i8;
    fn i8_checked_shr(&mut self, arg0: i8, arg1: u32) -> Option<i8>;
    fn i8_wrapping_shr(&mut self, arg0: i8, arg1: u32) -> i8;
    fn i8_shr(&mut self, arg0: i8, arg1: u32) -> i8;
    fn i8_is_zero(&mut self, arg0: i8) -> bool;
    fn i8_matches_zero(&mut self, arg0: i8) -> Option<bool>;
    fn i8_is_non_zero(&mut self, arg0: i8) -> bool;
    fn i8_matches_non_zero(&mut self, arg0: i8) -> Option<bool>;
    fn i8_is_odd(&mut self, arg0: i8) -> bool;
    fn i8_matches_odd(&mut self, arg0: i8) -> Option<bool>;
    fn i8_is_even(&mut self, arg0: i8) -> bool;
    fn i8_matches_even(&mut self, arg0: i8) -> Option<bool>;
    fn i8_checked_ilog2(&mut self, arg0: i8) -> Option<u32>;
    fn i8_ilog2(&mut self, arg0: i8) -> u32;
    fn i8_trailing_zeros(&mut self, arg0: i8) -> u32;
    fn i8_trailing_ones(&mut self, arg0: i8) -> u32;
    fn i8_leading_zeros(&mut self, arg0: i8) -> u32;
    fn i8_leading_ones(&mut self, arg0: i8) -> u32;
    fn i8_checked_neg(&mut self, arg0: i8) -> Option<i8>;
    fn i8_wrapping_neg(&mut self, arg0: i8) -> i8;
    fn i8_neg(&mut self, arg0: i8) -> i8;
    fn u8_eq(&mut self, arg0: u8, arg1: u8) -> bool;
    fn u8_ne(&mut self, arg0: u8, arg1: u8) -> bool;
    fn u8_lt(&mut self, arg0: u8, arg1: u8) -> bool;
    fn u8_lt_eq(&mut self, arg0: u8, arg1: u8) -> bool;
    fn u8_gt(&mut self, arg0: u8, arg1: u8) -> bool;
    fn u8_gt_eq(&mut self, arg0: u8, arg1: u8) -> bool;
    fn u8_checked_add(&mut self, arg0: u8, arg1: u8) -> Option<u8>;
    fn u8_wrapping_add(&mut self, arg0: u8, arg1: u8) -> u8;
    fn u8_add(&mut self, arg0: u8, arg1: u8) -> u8;
    fn u8_checked_sub(&mut self, arg0: u8, arg1: u8) -> Option<u8>;
    fn u8_wrapping_sub(&mut self, arg0: u8, arg1: u8) -> u8;
    fn u8_sub(&mut self, arg0: u8, arg1: u8) -> u8;
    fn u8_checked_mul(&mut self, arg0: u8, arg1: u8) -> Option<u8>;
    fn u8_wrapping_mul(&mut self, arg0: u8, arg1: u8) -> u8;
    fn u8_mul(&mut self, arg0: u8, arg1: u8) -> u8;
    fn u8_checked_div(&mut self, arg0: u8, arg1: u8) -> Option<u8>;
    fn u8_wrapping_div(&mut self, arg0: u8, arg1: u8) -> u8;
    fn u8_div(&mut self, arg0: u8, arg1: u8) -> u8;
    fn u8_checked_rem(&mut self, arg0: u8, arg1: u8) -> Option<u8>;
    fn u8_rem(&mut self, arg0: u8, arg1: u8) -> u8;
    fn u8_and(&mut self, arg0: u8, arg1: u8) -> u8;
    fn u8_or(&mut self, arg0: u8, arg1: u8) -> u8;
    fn u8_xor(&mut self, arg0: u8, arg1: u8) -> u8;
    fn u8_not(&mut self, arg0: u8) -> u8;
    fn u8_checked_shl(&mut self, arg0: u8, arg1: u32) -> Option<u8>;
    fn u8_wrapping_shl(&mut self, arg0: u8, arg1: u32) -> u8;
    fn u8_shl(&mut self, arg0: u8, arg1: u32) -> u8;
    fn u8_checked_shr(&mut self, arg0: u8, arg1: u32) -> Option<u8>;
    fn u8_wrapping_shr(&mut self, arg0: u8, arg1: u32) -> u8;
    fn u8_shr(&mut self, arg0: u8, arg1: u32) -> u8;
    fn u8_is_zero(&mut self, arg0: u8) -> bool;
    fn u8_matches_zero(&mut self, arg0: u8) -> Option<bool>;
    fn u8_is_non_zero(&mut self, arg0: u8) -> bool;
    fn u8_matches_non_zero(&mut self, arg0: u8) -> Option<bool>;
    fn u8_is_odd(&mut self, arg0: u8) -> bool;
    fn u8_matches_odd(&mut self, arg0: u8) -> Option<bool>;
    fn u8_is_even(&mut self, arg0: u8) -> bool;
    fn u8_matches_even(&mut self, arg0: u8) -> Option<bool>;
    fn u8_checked_ilog2(&mut self, arg0: u8) -> Option<u32>;
    fn u8_ilog2(&mut self, arg0: u8) -> u32;
    fn u8_trailing_zeros(&mut self, arg0: u8) -> u32;
    fn u8_trailing_ones(&mut self, arg0: u8) -> u32;
    fn u8_leading_zeros(&mut self, arg0: u8) -> u32;
    fn u8_leading_ones(&mut self, arg0: u8) -> u32;
    fn u8_is_power_of_two(&mut self, arg0: u8) -> bool;
    fn u8_matches_power_of_two(&mut self, arg0: u8) -> Option<bool>;
    fn i16_eq(&mut self, arg0: i16, arg1: i16) -> bool;
    fn i16_ne(&mut self, arg0: i16, arg1: i16) -> bool;
    fn i16_lt(&mut self, arg0: i16, arg1: i16) -> bool;
    fn i16_lt_eq(&mut self, arg0: i16, arg1: i16) -> bool;
    fn i16_gt(&mut self, arg0: i16, arg1: i16) -> bool;
    fn i16_gt_eq(&mut self, arg0: i16, arg1: i16) -> bool;
    fn i16_checked_add(&mut self, arg0: i16, arg1: i16) -> Option<i16>;
    fn i16_wrapping_add(&mut self, arg0: i16, arg1: i16) -> i16;
    fn i16_add(&mut self, arg0: i16, arg1: i16) -> i16;
    fn i16_checked_sub(&mut self, arg0: i16, arg1: i16) -> Option<i16>;
    fn i16_wrapping_sub(&mut self, arg0: i16, arg1: i16) -> i16;
    fn i16_sub(&mut self, arg0: i16, arg1: i16) -> i16;
    fn i16_checked_mul(&mut self, arg0: i16, arg1: i16) -> Option<i16>;
    fn i16_wrapping_mul(&mut self, arg0: i16, arg1: i16) -> i16;
    fn i16_mul(&mut self, arg0: i16, arg1: i16) -> i16;
    fn i16_checked_div(&mut self, arg0: i16, arg1: i16) -> Option<i16>;
    fn i16_wrapping_div(&mut self, arg0: i16, arg1: i16) -> i16;
    fn i16_div(&mut self, arg0: i16, arg1: i16) -> i16;
    fn i16_checked_rem(&mut self, arg0: i16, arg1: i16) -> Option<i16>;
    fn i16_rem(&mut self, arg0: i16, arg1: i16) -> i16;
    fn i16_and(&mut self, arg0: i16, arg1: i16) -> i16;
    fn i16_or(&mut self, arg0: i16, arg1: i16) -> i16;
    fn i16_xor(&mut self, arg0: i16, arg1: i16) -> i16;
    fn i16_not(&mut self, arg0: i16) -> i16;
    fn i16_checked_shl(&mut self, arg0: i16, arg1: u32) -> Option<i16>;
    fn i16_wrapping_shl(&mut self, arg0: i16, arg1: u32) -> i16;
    fn i16_shl(&mut self, arg0: i16, arg1: u32) -> i16;
    fn i16_checked_shr(&mut self, arg0: i16, arg1: u32) -> Option<i16>;
    fn i16_wrapping_shr(&mut self, arg0: i16, arg1: u32) -> i16;
    fn i16_shr(&mut self, arg0: i16, arg1: u32) -> i16;
    fn i16_is_zero(&mut self, arg0: i16) -> bool;
    fn i16_matches_zero(&mut self, arg0: i16) -> Option<bool>;
    fn i16_is_non_zero(&mut self, arg0: i16) -> bool;
    fn i16_matches_non_zero(&mut self, arg0: i16) -> Option<bool>;
    fn i16_is_odd(&mut self, arg0: i16) -> bool;
    fn i16_matches_odd(&mut self, arg0: i16) -> Option<bool>;
    fn i16_is_even(&mut self, arg0: i16) -> bool;
    fn i16_matches_even(&mut self, arg0: i16) -> Option<bool>;
    fn i16_checked_ilog2(&mut self, arg0: i16) -> Option<u32>;
    fn i16_ilog2(&mut self, arg0: i16) -> u32;
    fn i16_trailing_zeros(&mut self, arg0: i16) -> u32;
    fn i16_trailing_ones(&mut self, arg0: i16) -> u32;
    fn i16_leading_zeros(&mut self, arg0: i16) -> u32;
    fn i16_leading_ones(&mut self, arg0: i16) -> u32;
    fn i16_checked_neg(&mut self, arg0: i16) -> Option<i16>;
    fn i16_wrapping_neg(&mut self, arg0: i16) -> i16;
    fn i16_neg(&mut self, arg0: i16) -> i16;
    fn u16_eq(&mut self, arg0: u16, arg1: u16) -> bool;
    fn u16_ne(&mut self, arg0: u16, arg1: u16) -> bool;
    fn u16_lt(&mut self, arg0: u16, arg1: u16) -> bool;
    fn u16_lt_eq(&mut self, arg0: u16, arg1: u16) -> bool;
    fn u16_gt(&mut self, arg0: u16, arg1: u16) -> bool;
    fn u16_gt_eq(&mut self, arg0: u16, arg1: u16) -> bool;
    fn u16_checked_add(&mut self, arg0: u16, arg1: u16) -> Option<u16>;
    fn u16_wrapping_add(&mut self, arg0: u16, arg1: u16) -> u16;
    fn u16_add(&mut self, arg0: u16, arg1: u16) -> u16;
    fn u16_checked_sub(&mut self, arg0: u16, arg1: u16) -> Option<u16>;
    fn u16_wrapping_sub(&mut self, arg0: u16, arg1: u16) -> u16;
    fn u16_sub(&mut self, arg0: u16, arg1: u16) -> u16;
    fn u16_checked_mul(&mut self, arg0: u16, arg1: u16) -> Option<u16>;
    fn u16_wrapping_mul(&mut self, arg0: u16, arg1: u16) -> u16;
    fn u16_mul(&mut self, arg0: u16, arg1: u16) -> u16;
    fn u16_checked_div(&mut self, arg0: u16, arg1: u16) -> Option<u16>;
    fn u16_wrapping_div(&mut self, arg0: u16, arg1: u16) -> u16;
    fn u16_div(&mut self, arg0: u16, arg1: u16) -> u16;
    fn u16_checked_rem(&mut self, arg0: u16, arg1: u16) -> Option<u16>;
    fn u16_rem(&mut self, arg0: u16, arg1: u16) -> u16;
    fn u16_and(&mut self, arg0: u16, arg1: u16) -> u16;
    fn u16_or(&mut self, arg0: u16, arg1: u16) -> u16;
    fn u16_xor(&mut self, arg0: u16, arg1: u16) -> u16;
    fn u16_not(&mut self, arg0: u16) -> u16;
    fn u16_checked_shl(&mut self, arg0: u16, arg1: u32) -> Option<u16>;
    fn u16_wrapping_shl(&mut self, arg0: u16, arg1: u32) -> u16;
    fn u16_shl(&mut self, arg0: u16, arg1: u32) -> u16;
    fn u16_checked_shr(&mut self, arg0: u16, arg1: u32) -> Option<u16>;
    fn u16_wrapping_shr(&mut self, arg0: u16, arg1: u32) -> u16;
    fn u16_shr(&mut self, arg0: u16, arg1: u32) -> u16;
    fn u16_is_zero(&mut self, arg0: u16) -> bool;
    fn u16_matches_zero(&mut self, arg0: u16) -> Option<bool>;
    fn u16_is_non_zero(&mut self, arg0: u16) -> bool;
    fn u16_matches_non_zero(&mut self, arg0: u16) -> Option<bool>;
    fn u16_is_odd(&mut self, arg0: u16) -> bool;
    fn u16_matches_odd(&mut self, arg0: u16) -> Option<bool>;
    fn u16_is_even(&mut self, arg0: u16) -> bool;
    fn u16_matches_even(&mut self, arg0: u16) -> Option<bool>;
    fn u16_checked_ilog2(&mut self, arg0: u16) -> Option<u32>;
    fn u16_ilog2(&mut self, arg0: u16) -> u32;
    fn u16_trailing_zeros(&mut self, arg0: u16) -> u32;
    fn u16_trailing_ones(&mut self, arg0: u16) -> u32;
    fn u16_leading_zeros(&mut self, arg0: u16) -> u32;
    fn u16_leading_ones(&mut self, arg0: u16) -> u32;
    fn u16_is_power_of_two(&mut self, arg0: u16) -> bool;
    fn u16_matches_power_of_two(&mut self, arg0: u16) -> Option<bool>;
    fn i32_eq(&mut self, arg0: i32, arg1: i32) -> bool;
    fn i32_ne(&mut self, arg0: i32, arg1: i32) -> bool;
    fn i32_lt(&mut self, arg0: i32, arg1: i32) -> bool;
    fn i32_lt_eq(&mut self, arg0: i32, arg1: i32) -> bool;
    fn i32_gt(&mut self, arg0: i32, arg1: i32) -> bool;
    fn i32_gt_eq(&mut self, arg0: i32, arg1: i32) -> bool;
    fn i32_checked_add(&mut self, arg0: i32, arg1: i32) -> Option<i32>;
    fn i32_wrapping_add(&mut self, arg0: i32, arg1: i32) -> i32;
    fn i32_add(&mut self, arg0: i32, arg1: i32) -> i32;
    fn i32_checked_sub(&mut self, arg0: i32, arg1: i32) -> Option<i32>;
    fn i32_wrapping_sub(&mut self, arg0: i32, arg1: i32) -> i32;
    fn i32_sub(&mut self, arg0: i32, arg1: i32) -> i32;
    fn i32_checked_mul(&mut self, arg0: i32, arg1: i32) -> Option<i32>;
    fn i32_wrapping_mul(&mut self, arg0: i32, arg1: i32) -> i32;
    fn i32_mul(&mut self, arg0: i32, arg1: i32) -> i32;
    fn i32_checked_div(&mut self, arg0: i32, arg1: i32) -> Option<i32>;
    fn i32_wrapping_div(&mut self, arg0: i32, arg1: i32) -> i32;
    fn i32_div(&mut self, arg0: i32, arg1: i32) -> i32;
    fn i32_checked_rem(&mut self, arg0: i32, arg1: i32) -> Option<i32>;
    fn i32_rem(&mut self, arg0: i32, arg1: i32) -> i32;
    fn i32_and(&mut self, arg0: i32, arg1: i32) -> i32;
    fn i32_or(&mut self, arg0: i32, arg1: i32) -> i32;
    fn i32_xor(&mut self, arg0: i32, arg1: i32) -> i32;
    fn i32_not(&mut self, arg0: i32) -> i32;
    fn i32_checked_shl(&mut self, arg0: i32, arg1: u32) -> Option<i32>;
    fn i32_wrapping_shl(&mut self, arg0: i32, arg1: u32) -> i32;
    fn i32_shl(&mut self, arg0: i32, arg1: u32) -> i32;
    fn i32_checked_shr(&mut self, arg0: i32, arg1: u32) -> Option<i32>;
    fn i32_wrapping_shr(&mut self, arg0: i32, arg1: u32) -> i32;
    fn i32_shr(&mut self, arg0: i32, arg1: u32) -> i32;
    fn i32_is_zero(&mut self, arg0: i32) -> bool;
    fn i32_matches_zero(&mut self, arg0: i32) -> Option<bool>;
    fn i32_is_non_zero(&mut self, arg0: i32) -> bool;
    fn i32_matches_non_zero(&mut self, arg0: i32) -> Option<bool>;
    fn i32_is_odd(&mut self, arg0: i32) -> bool;
    fn i32_matches_odd(&mut self, arg0: i32) -> Option<bool>;
    fn i32_is_even(&mut self, arg0: i32) -> bool;
    fn i32_matches_even(&mut self, arg0: i32) -> Option<bool>;
    fn i32_checked_ilog2(&mut self, arg0: i32) -> Option<u32>;
    fn i32_ilog2(&mut self, arg0: i32) -> u32;
    fn i32_trailing_zeros(&mut self, arg0: i32) -> u32;
    fn i32_trailing_ones(&mut self, arg0: i32) -> u32;
    fn i32_leading_zeros(&mut self, arg0: i32) -> u32;
    fn i32_leading_ones(&mut self, arg0: i32) -> u32;
    fn i32_checked_neg(&mut self, arg0: i32) -> Option<i32>;
    fn i32_wrapping_neg(&mut self, arg0: i32) -> i32;
    fn i32_neg(&mut self, arg0: i32) -> i32;
    fn u32_eq(&mut self, arg0: u32, arg1: u32) -> bool;
    fn u32_ne(&mut self, arg0: u32, arg1: u32) -> bool;
    fn u32_lt(&mut self, arg0: u32, arg1: u32) -> bool;
    fn u32_lt_eq(&mut self, arg0: u32, arg1: u32) -> bool;
    fn u32_gt(&mut self, arg0: u32, arg1: u32) -> bool;
    fn u32_gt_eq(&mut self, arg0: u32, arg1: u32) -> bool;
    fn u32_checked_add(&mut self, arg0: u32, arg1: u32) -> Option<u32>;
    fn u32_wrapping_add(&mut self, arg0: u32, arg1: u32) -> u32;
    fn u32_add(&mut self, arg0: u32, arg1: u32) -> u32;
    fn u32_checked_sub(&mut self, arg0: u32, arg1: u32) -> Option<u32>;
    fn u32_wrapping_sub(&mut self, arg0: u32, arg1: u32) -> u32;
    fn u32_sub(&mut self, arg0: u32, arg1: u32) -> u32;
    fn u32_checked_mul(&mut self, arg0: u32, arg1: u32) -> Option<u32>;
    fn u32_wrapping_mul(&mut self, arg0: u32, arg1: u32) -> u32;
    fn u32_mul(&mut self, arg0: u32, arg1: u32) -> u32;
    fn u32_checked_div(&mut self, arg0: u32, arg1: u32) -> Option<u32>;
    fn u32_wrapping_div(&mut self, arg0: u32, arg1: u32) -> u32;
    fn u32_div(&mut self, arg0: u32, arg1: u32) -> u32;
    fn u32_checked_rem(&mut self, arg0: u32, arg1: u32) -> Option<u32>;
    fn u32_rem(&mut self, arg0: u32, arg1: u32) -> u32;
    fn u32_and(&mut self, arg0: u32, arg1: u32) -> u32;
    fn u32_or(&mut self, arg0: u32, arg1: u32) -> u32;
    fn u32_xor(&mut self, arg0: u32, arg1: u32) -> u32;
    fn u32_not(&mut self, arg0: u32) -> u32;
    fn u32_checked_shl(&mut self, arg0: u32, arg1: u32) -> Option<u32>;
    fn u32_wrapping_shl(&mut self, arg0: u32, arg1: u32) -> u32;
    fn u32_shl(&mut self, arg0: u32, arg1: u32) -> u32;
    fn u32_checked_shr(&mut self, arg0: u32, arg1: u32) -> Option<u32>;
    fn u32_wrapping_shr(&mut self, arg0: u32, arg1: u32) -> u32;
    fn u32_shr(&mut self, arg0: u32, arg1: u32) -> u32;
    fn u32_is_zero(&mut self, arg0: u32) -> bool;
    fn u32_matches_zero(&mut self, arg0: u32) -> Option<bool>;
    fn u32_is_non_zero(&mut self, arg0: u32) -> bool;
    fn u32_matches_non_zero(&mut self, arg0: u32) -> Option<bool>;
    fn u32_is_odd(&mut self, arg0: u32) -> bool;
    fn u32_matches_odd(&mut self, arg0: u32) -> Option<bool>;
    fn u32_is_even(&mut self, arg0: u32) -> bool;
    fn u32_matches_even(&mut self, arg0: u32) -> Option<bool>;
    fn u32_checked_ilog2(&mut self, arg0: u32) -> Option<u32>;
    fn u32_ilog2(&mut self, arg0: u32) -> u32;
    fn u32_trailing_zeros(&mut self, arg0: u32) -> u32;
    fn u32_trailing_ones(&mut self, arg0: u32) -> u32;
    fn u32_leading_zeros(&mut self, arg0: u32) -> u32;
    fn u32_leading_ones(&mut self, arg0: u32) -> u32;
    fn u32_is_power_of_two(&mut self, arg0: u32) -> bool;
    fn u32_matches_power_of_two(&mut self, arg0: u32) -> Option<bool>;
    fn i64_eq(&mut self, arg0: i64, arg1: i64) -> bool;
    fn i64_ne(&mut self, arg0: i64, arg1: i64) -> bool;
    fn i64_lt(&mut self, arg0: i64, arg1: i64) -> bool;
    fn i64_lt_eq(&mut self, arg0: i64, arg1: i64) -> bool;
    fn i64_gt(&mut self, arg0: i64, arg1: i64) -> bool;
    fn i64_gt_eq(&mut self, arg0: i64, arg1: i64) -> bool;
    fn i64_checked_add(&mut self, arg0: i64, arg1: i64) -> Option<i64>;
    fn i64_wrapping_add(&mut self, arg0: i64, arg1: i64) -> i64;
    fn i64_add(&mut self, arg0: i64, arg1: i64) -> i64;
    fn i64_checked_sub(&mut self, arg0: i64, arg1: i64) -> Option<i64>;
    fn i64_wrapping_sub(&mut self, arg0: i64, arg1: i64) -> i64;
    fn i64_sub(&mut self, arg0: i64, arg1: i64) -> i64;
    fn i64_checked_mul(&mut self, arg0: i64, arg1: i64) -> Option<i64>;
    fn i64_wrapping_mul(&mut self, arg0: i64, arg1: i64) -> i64;
    fn i64_mul(&mut self, arg0: i64, arg1: i64) -> i64;
    fn i64_checked_div(&mut self, arg0: i64, arg1: i64) -> Option<i64>;
    fn i64_wrapping_div(&mut self, arg0: i64, arg1: i64) -> i64;
    fn i64_div(&mut self, arg0: i64, arg1: i64) -> i64;
    fn i64_checked_rem(&mut self, arg0: i64, arg1: i64) -> Option<i64>;
    fn i64_rem(&mut self, arg0: i64, arg1: i64) -> i64;
    fn i64_and(&mut self, arg0: i64, arg1: i64) -> i64;
    fn i64_or(&mut self, arg0: i64, arg1: i64) -> i64;
    fn i64_xor(&mut self, arg0: i64, arg1: i64) -> i64;
    fn i64_not(&mut self, arg0: i64) -> i64;
    fn i64_checked_shl(&mut self, arg0: i64, arg1: u32) -> Option<i64>;
    fn i64_wrapping_shl(&mut self, arg0: i64, arg1: u32) -> i64;
    fn i64_shl(&mut self, arg0: i64, arg1: u32) -> i64;
    fn i64_checked_shr(&mut self, arg0: i64, arg1: u32) -> Option<i64>;
    fn i64_wrapping_shr(&mut self, arg0: i64, arg1: u32) -> i64;
    fn i64_shr(&mut self, arg0: i64, arg1: u32) -> i64;
    fn i64_is_zero(&mut self, arg0: i64) -> bool;
    fn i64_matches_zero(&mut self, arg0: i64) -> Option<bool>;
    fn i64_is_non_zero(&mut self, arg0: i64) -> bool;
    fn i64_matches_non_zero(&mut self, arg0: i64) -> Option<bool>;
    fn i64_is_odd(&mut self, arg0: i64) -> bool;
    fn i64_matches_odd(&mut self, arg0: i64) -> Option<bool>;
    fn i64_is_even(&mut self, arg0: i64) -> bool;
    fn i64_matches_even(&mut self, arg0: i64) -> Option<bool>;
    fn i64_checked_ilog2(&mut self, arg0: i64) -> Option<u32>;
    fn i64_ilog2(&mut self, arg0: i64) -> u32;
    fn i64_trailing_zeros(&mut self, arg0: i64) -> u32;
    fn i64_trailing_ones(&mut self, arg0: i64) -> u32;
    fn i64_leading_zeros(&mut self, arg0: i64) -> u32;
    fn i64_leading_ones(&mut self, arg0: i64) -> u32;
    fn i64_checked_neg(&mut self, arg0: i64) -> Option<i64>;
    fn i64_wrapping_neg(&mut self, arg0: i64) -> i64;
    fn i64_neg(&mut self, arg0: i64) -> i64;
    fn u64_eq(&mut self, arg0: u64, arg1: u64) -> bool;
    fn u64_ne(&mut self, arg0: u64, arg1: u64) -> bool;
    fn u64_lt(&mut self, arg0: u64, arg1: u64) -> bool;
    fn u64_lt_eq(&mut self, arg0: u64, arg1: u64) -> bool;
    fn u64_gt(&mut self, arg0: u64, arg1: u64) -> bool;
    fn u64_gt_eq(&mut self, arg0: u64, arg1: u64) -> bool;
    fn u64_checked_add(&mut self, arg0: u64, arg1: u64) -> Option<u64>;
    fn u64_wrapping_add(&mut self, arg0: u64, arg1: u64) -> u64;
    fn u64_add(&mut self, arg0: u64, arg1: u64) -> u64;
    fn u64_checked_sub(&mut self, arg0: u64, arg1: u64) -> Option<u64>;
    fn u64_wrapping_sub(&mut self, arg0: u64, arg1: u64) -> u64;
    fn u64_sub(&mut self, arg0: u64, arg1: u64) -> u64;
    fn u64_checked_mul(&mut self, arg0: u64, arg1: u64) -> Option<u64>;
    fn u64_wrapping_mul(&mut self, arg0: u64, arg1: u64) -> u64;
    fn u64_mul(&mut self, arg0: u64, arg1: u64) -> u64;
    fn u64_checked_div(&mut self, arg0: u64, arg1: u64) -> Option<u64>;
    fn u64_wrapping_div(&mut self, arg0: u64, arg1: u64) -> u64;
    fn u64_div(&mut self, arg0: u64, arg1: u64) -> u64;
    fn u64_checked_rem(&mut self, arg0: u64, arg1: u64) -> Option<u64>;
    fn u64_rem(&mut self, arg0: u64, arg1: u64) -> u64;
    fn u64_and(&mut self, arg0: u64, arg1: u64) -> u64;
    fn u64_or(&mut self, arg0: u64, arg1: u64) -> u64;
    fn u64_xor(&mut self, arg0: u64, arg1: u64) -> u64;
    fn u64_not(&mut self, arg0: u64) -> u64;
    fn u64_checked_shl(&mut self, arg0: u64, arg1: u32) -> Option<u64>;
    fn u64_wrapping_shl(&mut self, arg0: u64, arg1: u32) -> u64;
    fn u64_shl(&mut self, arg0: u64, arg1: u32) -> u64;
    fn u64_checked_shr(&mut self, arg0: u64, arg1: u32) -> Option<u64>;
    fn u64_wrapping_shr(&mut self, arg0: u64, arg1: u32) -> u64;
    fn u64_shr(&mut self, arg0: u64, arg1: u32) -> u64;
    fn u64_is_zero(&mut self, arg0: u64) -> bool;
    fn u64_matches_zero(&mut self, arg0: u64) -> Option<bool>;
    fn u64_is_non_zero(&mut self, arg0: u64) -> bool;
    fn u64_matches_non_zero(&mut self, arg0: u64) -> Option<bool>;
    fn u64_is_odd(&mut self, arg0: u64) -> bool;
    fn u64_matches_odd(&mut self, arg0: u64) -> Option<bool>;
    fn u64_is_even(&mut self, arg0: u64) -> bool;
    fn u64_matches_even(&mut self, arg0: u64) -> Option<bool>;
    fn u64_checked_ilog2(&mut self, arg0: u64) -> Option<u32>;
    fn u64_ilog2(&mut self, arg0: u64) -> u32;
    fn u64_trailing_zeros(&mut self, arg0: u64) -> u32;
    fn u64_trailing_ones(&mut self, arg0: u64) -> u32;
    fn u64_leading_zeros(&mut self, arg0: u64) -> u32;
    fn u64_leading_ones(&mut self, arg0: u64) -> u32;
    fn u64_is_power_of_two(&mut self, arg0: u64) -> bool;
    fn u64_matches_power_of_two(&mut self, arg0: u64) -> Option<bool>;
    fn i128_eq(&mut self, arg0: i128, arg1: i128) -> bool;
    fn i128_ne(&mut self, arg0: i128, arg1: i128) -> bool;
    fn i128_lt(&mut self, arg0: i128, arg1: i128) -> bool;
    fn i128_lt_eq(&mut self, arg0: i128, arg1: i128) -> bool;
    fn i128_gt(&mut self, arg0: i128, arg1: i128) -> bool;
    fn i128_gt_eq(&mut self, arg0: i128, arg1: i128) -> bool;
    fn i128_checked_add(&mut self, arg0: i128, arg1: i128) -> Option<i128>;
    fn i128_wrapping_add(&mut self, arg0: i128, arg1: i128) -> i128;
    fn i128_add(&mut self, arg0: i128, arg1: i128) -> i128;
    fn i128_checked_sub(&mut self, arg0: i128, arg1: i128) -> Option<i128>;
    fn i128_wrapping_sub(&mut self, arg0: i128, arg1: i128) -> i128;
    fn i128_sub(&mut self, arg0: i128, arg1: i128) -> i128;
    fn i128_checked_mul(&mut self, arg0: i128, arg1: i128) -> Option<i128>;
    fn i128_wrapping_mul(&mut self, arg0: i128, arg1: i128) -> i128;
    fn i128_mul(&mut self, arg0: i128, arg1: i128) -> i128;
    fn i128_checked_div(&mut self, arg0: i128, arg1: i128) -> Option<i128>;
    fn i128_wrapping_div(&mut self, arg0: i128, arg1: i128) -> i128;
    fn i128_div(&mut self, arg0: i128, arg1: i128) -> i128;
    fn i128_checked_rem(&mut self, arg0: i128, arg1: i128) -> Option<i128>;
    fn i128_rem(&mut self, arg0: i128, arg1: i128) -> i128;
    fn i128_and(&mut self, arg0: i128, arg1: i128) -> i128;
    fn i128_or(&mut self, arg0: i128, arg1: i128) -> i128;
    fn i128_xor(&mut self, arg0: i128, arg1: i128) -> i128;
    fn i128_not(&mut self, arg0: i128) -> i128;
    fn i128_checked_shl(&mut self, arg0: i128, arg1: u32) -> Option<i128>;
    fn i128_wrapping_shl(&mut self, arg0: i128, arg1: u32) -> i128;
    fn i128_shl(&mut self, arg0: i128, arg1: u32) -> i128;
    fn i128_checked_shr(&mut self, arg0: i128, arg1: u32) -> Option<i128>;
    fn i128_wrapping_shr(&mut self, arg0: i128, arg1: u32) -> i128;
    fn i128_shr(&mut self, arg0: i128, arg1: u32) -> i128;
    fn i128_is_zero(&mut self, arg0: i128) -> bool;
    fn i128_matches_zero(&mut self, arg0: i128) -> Option<bool>;
    fn i128_is_non_zero(&mut self, arg0: i128) -> bool;
    fn i128_matches_non_zero(&mut self, arg0: i128) -> Option<bool>;
    fn i128_is_odd(&mut self, arg0: i128) -> bool;
    fn i128_matches_odd(&mut self, arg0: i128) -> Option<bool>;
    fn i128_is_even(&mut self, arg0: i128) -> bool;
    fn i128_matches_even(&mut self, arg0: i128) -> Option<bool>;
    fn i128_checked_ilog2(&mut self, arg0: i128) -> Option<u32>;
    fn i128_ilog2(&mut self, arg0: i128) -> u32;
    fn i128_trailing_zeros(&mut self, arg0: i128) -> u32;
    fn i128_trailing_ones(&mut self, arg0: i128) -> u32;
    fn i128_leading_zeros(&mut self, arg0: i128) -> u32;
    fn i128_leading_ones(&mut self, arg0: i128) -> u32;
    fn i128_checked_neg(&mut self, arg0: i128) -> Option<i128>;
    fn i128_wrapping_neg(&mut self, arg0: i128) -> i128;
    fn i128_neg(&mut self, arg0: i128) -> i128;
    fn u128_eq(&mut self, arg0: u128, arg1: u128) -> bool;
    fn u128_ne(&mut self, arg0: u128, arg1: u128) -> bool;
    fn u128_lt(&mut self, arg0: u128, arg1: u128) -> bool;
    fn u128_lt_eq(&mut self, arg0: u128, arg1: u128) -> bool;
    fn u128_gt(&mut self, arg0: u128, arg1: u128) -> bool;
    fn u128_gt_eq(&mut self, arg0: u128, arg1: u128) -> bool;
    fn u128_checked_add(&mut self, arg0: u128, arg1: u128) -> Option<u128>;
    fn u128_wrapping_add(&mut self, arg0: u128, arg1: u128) -> u128;
    fn u128_add(&mut self, arg0: u128, arg1: u128) -> u128;
    fn u128_checked_sub(&mut self, arg0: u128, arg1: u128) -> Option<u128>;
    fn u128_wrapping_sub(&mut self, arg0: u128, arg1: u128) -> u128;
    fn u128_sub(&mut self, arg0: u128, arg1: u128) -> u128;
    fn u128_checked_mul(&mut self, arg0: u128, arg1: u128) -> Option<u128>;
    fn u128_wrapping_mul(&mut self, arg0: u128, arg1: u128) -> u128;
    fn u128_mul(&mut self, arg0: u128, arg1: u128) -> u128;
    fn u128_checked_div(&mut self, arg0: u128, arg1: u128) -> Option<u128>;
    fn u128_wrapping_div(&mut self, arg0: u128, arg1: u128) -> u128;
    fn u128_div(&mut self, arg0: u128, arg1: u128) -> u128;
    fn u128_checked_rem(&mut self, arg0: u128, arg1: u128) -> Option<u128>;
    fn u128_rem(&mut self, arg0: u128, arg1: u128) -> u128;
    fn u128_and(&mut self, arg0: u128, arg1: u128) -> u128;
    fn u128_or(&mut self, arg0: u128, arg1: u128) -> u128;
    fn u128_xor(&mut self, arg0: u128, arg1: u128) -> u128;
    fn u128_not(&mut self, arg0: u128) -> u128;
    fn u128_checked_shl(&mut self, arg0: u128, arg1: u32) -> Option<u128>;
    fn u128_wrapping_shl(&mut self, arg0: u128, arg1: u32) -> u128;
    fn u128_shl(&mut self, arg0: u128, arg1: u32) -> u128;
    fn u128_checked_shr(&mut self, arg0: u128, arg1: u32) -> Option<u128>;
    fn u128_wrapping_shr(&mut self, arg0: u128, arg1: u32) -> u128;
    fn u128_shr(&mut self, arg0: u128, arg1: u32) -> u128;
    fn u128_is_zero(&mut self, arg0: u128) -> bool;
    fn u128_matches_zero(&mut self, arg0: u128) -> Option<bool>;
    fn u128_is_non_zero(&mut self, arg0: u128) -> bool;
    fn u128_matches_non_zero(&mut self, arg0: u128) -> Option<bool>;
    fn u128_is_odd(&mut self, arg0: u128) -> bool;
    fn u128_matches_odd(&mut self, arg0: u128) -> Option<bool>;
    fn u128_is_even(&mut self, arg0: u128) -> bool;
    fn u128_matches_even(&mut self, arg0: u128) -> Option<bool>;
    fn u128_checked_ilog2(&mut self, arg0: u128) -> Option<u32>;
    fn u128_ilog2(&mut self, arg0: u128) -> u32;
    fn u128_trailing_zeros(&mut self, arg0: u128) -> u32;
    fn u128_trailing_ones(&mut self, arg0: u128) -> u32;
    fn u128_leading_zeros(&mut self, arg0: u128) -> u32;
    fn u128_leading_ones(&mut self, arg0: u128) -> u32;
    fn u128_is_power_of_two(&mut self, arg0: u128) -> bool;
    fn u128_matches_power_of_two(&mut self, arg0: u128) -> Option<bool>;
    fn i8_try_into_u8(&mut self, arg0: i8) -> Option<u8>;
    fn i8_unwrap_into_u8(&mut self, arg0: i8) -> u8;
    fn i8_cast_unsigned(&mut self, arg0: i8) -> u8;
    fn i8_from_u8(&mut self, arg0: i8) -> Option<u8>;
    fn i8_into_i16(&mut self, arg0: i8) -> i16;
    fn i8_from_i16(&mut self, arg0: i8) -> Option<i16>;
    fn i8_try_into_u16(&mut self, arg0: i8) -> Option<u16>;
    fn i8_unwrap_into_u16(&mut self, arg0: i8) -> u16;
    fn i8_from_u16(&mut self, arg0: i8) -> Option<u16>;
    fn i8_into_i32(&mut self, arg0: i8) -> i32;
    fn i8_from_i32(&mut self, arg0: i8) -> Option<i32>;
    fn i8_try_into_u32(&mut self, arg0: i8) -> Option<u32>;
    fn i8_unwrap_into_u32(&mut self, arg0: i8) -> u32;
    fn i8_from_u32(&mut self, arg0: i8) -> Option<u32>;
    fn i8_into_i64(&mut self, arg0: i8) -> i64;
    fn i8_from_i64(&mut self, arg0: i8) -> Option<i64>;
    fn i8_try_into_u64(&mut self, arg0: i8) -> Option<u64>;
    fn i8_unwrap_into_u64(&mut self, arg0: i8) -> u64;
    fn i8_from_u64(&mut self, arg0: i8) -> Option<u64>;
    fn i8_into_i128(&mut self, arg0: i8) -> i128;
    fn i8_from_i128(&mut self, arg0: i8) -> Option<i128>;
    fn i8_try_into_u128(&mut self, arg0: i8) -> Option<u128>;
    fn i8_unwrap_into_u128(&mut self, arg0: i8) -> u128;
    fn i8_from_u128(&mut self, arg0: i8) -> Option<u128>;
    fn u8_try_into_i8(&mut self, arg0: u8) -> Option<i8>;
    fn u8_unwrap_into_i8(&mut self, arg0: u8) -> i8;
    fn u8_cast_signed(&mut self, arg0: u8) -> i8;
    fn u8_from_i8(&mut self, arg0: u8) -> Option<i8>;
    fn u8_into_i16(&mut self, arg0: u8) -> i16;
    fn u8_from_i16(&mut self, arg0: u8) -> Option<i16>;
    fn u8_into_u16(&mut self, arg0: u8) -> u16;
    fn u8_from_u16(&mut self, arg0: u8) -> Option<u16>;
    fn u8_into_i32(&mut self, arg0: u8) -> i32;
    fn u8_from_i32(&mut self, arg0: u8) -> Option<i32>;
    fn u8_into_u32(&mut self, arg0: u8) -> u32;
    fn u8_from_u32(&mut self, arg0: u8) -> Option<u32>;
    fn u8_into_i64(&mut self, arg0: u8) -> i64;
    fn u8_from_i64(&mut self, arg0: u8) -> Option<i64>;
    fn u8_into_u64(&mut self, arg0: u8) -> u64;
    fn u8_from_u64(&mut self, arg0: u8) -> Option<u64>;
    fn u8_into_i128(&mut self, arg0: u8) -> i128;
    fn u8_from_i128(&mut self, arg0: u8) -> Option<i128>;
    fn u8_into_u128(&mut self, arg0: u8) -> u128;
    fn u8_from_u128(&mut self, arg0: u8) -> Option<u128>;
    fn i16_try_into_i8(&mut self, arg0: i16) -> Option<i8>;
    fn i16_unwrap_into_i8(&mut self, arg0: i16) -> i8;
    fn i16_truncate_into_i8(&mut self, arg0: i16) -> i8;
    fn i16_from_i8(&mut self, arg0: i16) -> Option<i8>;
    fn i16_try_into_u8(&mut self, arg0: i16) -> Option<u8>;
    fn i16_unwrap_into_u8(&mut self, arg0: i16) -> u8;
    fn i16_from_u8(&mut self, arg0: i16) -> Option<u8>;
    fn i16_try_into_u16(&mut self, arg0: i16) -> Option<u16>;
    fn i16_unwrap_into_u16(&mut self, arg0: i16) -> u16;
    fn i16_cast_unsigned(&mut self, arg0: i16) -> u16;
    fn i16_from_u16(&mut self, arg0: i16) -> Option<u16>;
    fn i16_into_i32(&mut self, arg0: i16) -> i32;
    fn i16_from_i32(&mut self, arg0: i16) -> Option<i32>;
    fn i16_try_into_u32(&mut self, arg0: i16) -> Option<u32>;
    fn i16_unwrap_into_u32(&mut self, arg0: i16) -> u32;
    fn i16_from_u32(&mut self, arg0: i16) -> Option<u32>;
    fn i16_into_i64(&mut self, arg0: i16) -> i64;
    fn i16_from_i64(&mut self, arg0: i16) -> Option<i64>;
    fn i16_try_into_u64(&mut self, arg0: i16) -> Option<u64>;
    fn i16_unwrap_into_u64(&mut self, arg0: i16) -> u64;
    fn i16_from_u64(&mut self, arg0: i16) -> Option<u64>;
    fn i16_into_i128(&mut self, arg0: i16) -> i128;
    fn i16_from_i128(&mut self, arg0: i16) -> Option<i128>;
    fn i16_try_into_u128(&mut self, arg0: i16) -> Option<u128>;
    fn i16_unwrap_into_u128(&mut self, arg0: i16) -> u128;
    fn i16_from_u128(&mut self, arg0: i16) -> Option<u128>;
    fn u16_try_into_i8(&mut self, arg0: u16) -> Option<i8>;
    fn u16_unwrap_into_i8(&mut self, arg0: u16) -> i8;
    fn u16_from_i8(&mut self, arg0: u16) -> Option<i8>;
    fn u16_try_into_u8(&mut self, arg0: u16) -> Option<u8>;
    fn u16_unwrap_into_u8(&mut self, arg0: u16) -> u8;
    fn u16_truncate_into_u8(&mut self, arg0: u16) -> u8;
    fn u16_from_u8(&mut self, arg0: u16) -> Option<u8>;
    fn u16_try_into_i16(&mut self, arg0: u16) -> Option<i16>;
    fn u16_unwrap_into_i16(&mut self, arg0: u16) -> i16;
    fn u16_cast_signed(&mut self, arg0: u16) -> i16;
    fn u16_from_i16(&mut self, arg0: u16) -> Option<i16>;
    fn u16_into_i32(&mut self, arg0: u16) -> i32;
    fn u16_from_i32(&mut self, arg0: u16) -> Option<i32>;
    fn u16_into_u32(&mut self, arg0: u16) -> u32;
    fn u16_from_u32(&mut self, arg0: u16) -> Option<u32>;
    fn u16_into_i64(&mut self, arg0: u16) -> i64;
    fn u16_from_i64(&mut self, arg0: u16) -> Option<i64>;
    fn u16_into_u64(&mut self, arg0: u16) -> u64;
    fn u16_from_u64(&mut self, arg0: u16) -> Option<u64>;
    fn u16_into_i128(&mut self, arg0: u16) -> i128;
    fn u16_from_i128(&mut self, arg0: u16) -> Option<i128>;
    fn u16_into_u128(&mut self, arg0: u16) -> u128;
    fn u16_from_u128(&mut self, arg0: u16) -> Option<u128>;
    fn i32_try_into_i8(&mut self, arg0: i32) -> Option<i8>;
    fn i32_unwrap_into_i8(&mut self, arg0: i32) -> i8;
    fn i32_truncate_into_i8(&mut self, arg0: i32) -> i8;
    fn i32_from_i8(&mut self, arg0: i32) -> Option<i8>;
    fn i32_try_into_u8(&mut self, arg0: i32) -> Option<u8>;
    fn i32_unwrap_into_u8(&mut self, arg0: i32) -> u8;
    fn i32_from_u8(&mut self, arg0: i32) -> Option<u8>;
    fn i32_try_into_i16(&mut self, arg0: i32) -> Option<i16>;
    fn i32_unwrap_into_i16(&mut self, arg0: i32) -> i16;
    fn i32_truncate_into_i16(&mut self, arg0: i32) -> i16;
    fn i32_from_i16(&mut self, arg0: i32) -> Option<i16>;
    fn i32_try_into_u16(&mut self, arg0: i32) -> Option<u16>;
    fn i32_unwrap_into_u16(&mut self, arg0: i32) -> u16;
    fn i32_from_u16(&mut self, arg0: i32) -> Option<u16>;
    fn i32_try_into_u32(&mut self, arg0: i32) -> Option<u32>;
    fn i32_unwrap_into_u32(&mut self, arg0: i32) -> u32;
    fn i32_cast_unsigned(&mut self, arg0: i32) -> u32;
    fn i32_from_u32(&mut self, arg0: i32) -> Option<u32>;
    fn i32_into_i64(&mut self, arg0: i32) -> i64;
    fn i32_from_i64(&mut self, arg0: i32) -> Option<i64>;
    fn i32_try_into_u64(&mut self, arg0: i32) -> Option<u64>;
    fn i32_unwrap_into_u64(&mut self, arg0: i32) -> u64;
    fn i32_from_u64(&mut self, arg0: i32) -> Option<u64>;
    fn i32_into_i128(&mut self, arg0: i32) -> i128;
    fn i32_from_i128(&mut self, arg0: i32) -> Option<i128>;
    fn i32_try_into_u128(&mut self, arg0: i32) -> Option<u128>;
    fn i32_unwrap_into_u128(&mut self, arg0: i32) -> u128;
    fn i32_from_u128(&mut self, arg0: i32) -> Option<u128>;
    fn u32_try_into_i8(&mut self, arg0: u32) -> Option<i8>;
    fn u32_unwrap_into_i8(&mut self, arg0: u32) -> i8;
    fn u32_from_i8(&mut self, arg0: u32) -> Option<i8>;
    fn u32_try_into_u8(&mut self, arg0: u32) -> Option<u8>;
    fn u32_unwrap_into_u8(&mut self, arg0: u32) -> u8;
    fn u32_truncate_into_u8(&mut self, arg0: u32) -> u8;
    fn u32_from_u8(&mut self, arg0: u32) -> Option<u8>;
    fn u32_try_into_i16(&mut self, arg0: u32) -> Option<i16>;
    fn u32_unwrap_into_i16(&mut self, arg0: u32) -> i16;
    fn u32_from_i16(&mut self, arg0: u32) -> Option<i16>;
    fn u32_try_into_u16(&mut self, arg0: u32) -> Option<u16>;
    fn u32_unwrap_into_u16(&mut self, arg0: u32) -> u16;
    fn u32_truncate_into_u16(&mut self, arg0: u32) -> u16;
    fn u32_from_u16(&mut self, arg0: u32) -> Option<u16>;
    fn u32_try_into_i32(&mut self, arg0: u32) -> Option<i32>;
    fn u32_unwrap_into_i32(&mut self, arg0: u32) -> i32;
    fn u32_cast_signed(&mut self, arg0: u32) -> i32;
    fn u32_from_i32(&mut self, arg0: u32) -> Option<i32>;
    fn u32_into_i64(&mut self, arg0: u32) -> i64;
    fn u32_from_i64(&mut self, arg0: u32) -> Option<i64>;
    fn u32_into_u64(&mut self, arg0: u32) -> u64;
    fn u32_from_u64(&mut self, arg0: u32) -> Option<u64>;
    fn u32_into_i128(&mut self, arg0: u32) -> i128;
    fn u32_from_i128(&mut self, arg0: u32) -> Option<i128>;
    fn u32_into_u128(&mut self, arg0: u32) -> u128;
    fn u32_from_u128(&mut self, arg0: u32) -> Option<u128>;
    fn i64_try_into_i8(&mut self, arg0: i64) -> Option<i8>;
    fn i64_unwrap_into_i8(&mut self, arg0: i64) -> i8;
    fn i64_truncate_into_i8(&mut self, arg0: i64) -> i8;
    fn i64_from_i8(&mut self, arg0: i64) -> Option<i8>;
    fn i64_try_into_u8(&mut self, arg0: i64) -> Option<u8>;
    fn i64_unwrap_into_u8(&mut self, arg0: i64) -> u8;
    fn i64_from_u8(&mut self, arg0: i64) -> Option<u8>;
    fn i64_try_into_i16(&mut self, arg0: i64) -> Option<i16>;
    fn i64_unwrap_into_i16(&mut self, arg0: i64) -> i16;
    fn i64_truncate_into_i16(&mut self, arg0: i64) -> i16;
    fn i64_from_i16(&mut self, arg0: i64) -> Option<i16>;
    fn i64_try_into_u16(&mut self, arg0: i64) -> Option<u16>;
    fn i64_unwrap_into_u16(&mut self, arg0: i64) -> u16;
    fn i64_from_u16(&mut self, arg0: i64) -> Option<u16>;
    fn i64_try_into_i32(&mut self, arg0: i64) -> Option<i32>;
    fn i64_unwrap_into_i32(&mut self, arg0: i64) -> i32;
    fn i64_truncate_into_i32(&mut self, arg0: i64) -> i32;
    fn i64_from_i32(&mut self, arg0: i64) -> Option<i32>;
    fn i64_try_into_u32(&mut self, arg0: i64) -> Option<u32>;
    fn i64_unwrap_into_u32(&mut self, arg0: i64) -> u32;
    fn i64_from_u32(&mut self, arg0: i64) -> Option<u32>;
    fn i64_try_into_u64(&mut self, arg0: i64) -> Option<u64>;
    fn i64_unwrap_into_u64(&mut self, arg0: i64) -> u64;
    fn i64_cast_unsigned(&mut self, arg0: i64) -> u64;
    fn i64_from_u64(&mut self, arg0: i64) -> Option<u64>;
    fn i64_into_i128(&mut self, arg0: i64) -> i128;
    fn i64_from_i128(&mut self, arg0: i64) -> Option<i128>;
    fn i64_try_into_u128(&mut self, arg0: i64) -> Option<u128>;
    fn i64_unwrap_into_u128(&mut self, arg0: i64) -> u128;
    fn i64_from_u128(&mut self, arg0: i64) -> Option<u128>;
    fn u64_try_into_i8(&mut self, arg0: u64) -> Option<i8>;
    fn u64_unwrap_into_i8(&mut self, arg0: u64) -> i8;
    fn u64_from_i8(&mut self, arg0: u64) -> Option<i8>;
    fn u64_try_into_u8(&mut self, arg0: u64) -> Option<u8>;
    fn u64_unwrap_into_u8(&mut self, arg0: u64) -> u8;
    fn u64_truncate_into_u8(&mut self, arg0: u64) -> u8;
    fn u64_from_u8(&mut self, arg0: u64) -> Option<u8>;
    fn u64_try_into_i16(&mut self, arg0: u64) -> Option<i16>;
    fn u64_unwrap_into_i16(&mut self, arg0: u64) -> i16;
    fn u64_from_i16(&mut self, arg0: u64) -> Option<i16>;
    fn u64_try_into_u16(&mut self, arg0: u64) -> Option<u16>;
    fn u64_unwrap_into_u16(&mut self, arg0: u64) -> u16;
    fn u64_truncate_into_u16(&mut self, arg0: u64) -> u16;
    fn u64_from_u16(&mut self, arg0: u64) -> Option<u16>;
    fn u64_try_into_i32(&mut self, arg0: u64) -> Option<i32>;
    fn u64_unwrap_into_i32(&mut self, arg0: u64) -> i32;
    fn u64_from_i32(&mut self, arg0: u64) -> Option<i32>;
    fn u64_try_into_u32(&mut self, arg0: u64) -> Option<u32>;
    fn u64_unwrap_into_u32(&mut self, arg0: u64) -> u32;
    fn u64_truncate_into_u32(&mut self, arg0: u64) -> u32;
    fn u64_from_u32(&mut self, arg0: u64) -> Option<u32>;
    fn u64_try_into_i64(&mut self, arg0: u64) -> Option<i64>;
    fn u64_unwrap_into_i64(&mut self, arg0: u64) -> i64;
    fn u64_cast_signed(&mut self, arg0: u64) -> i64;
    fn u64_from_i64(&mut self, arg0: u64) -> Option<i64>;
    fn u64_into_i128(&mut self, arg0: u64) -> i128;
    fn u64_from_i128(&mut self, arg0: u64) -> Option<i128>;
    fn u64_into_u128(&mut self, arg0: u64) -> u128;
    fn u64_from_u128(&mut self, arg0: u64) -> Option<u128>;
    fn i128_try_into_i8(&mut self, arg0: i128) -> Option<i8>;
    fn i128_unwrap_into_i8(&mut self, arg0: i128) -> i8;
    fn i128_truncate_into_i8(&mut self, arg0: i128) -> i8;
    fn i128_from_i8(&mut self, arg0: i128) -> Option<i8>;
    fn i128_try_into_u8(&mut self, arg0: i128) -> Option<u8>;
    fn i128_unwrap_into_u8(&mut self, arg0: i128) -> u8;
    fn i128_from_u8(&mut self, arg0: i128) -> Option<u8>;
    fn i128_try_into_i16(&mut self, arg0: i128) -> Option<i16>;
    fn i128_unwrap_into_i16(&mut self, arg0: i128) -> i16;
    fn i128_truncate_into_i16(&mut self, arg0: i128) -> i16;
    fn i128_from_i16(&mut self, arg0: i128) -> Option<i16>;
    fn i128_try_into_u16(&mut self, arg0: i128) -> Option<u16>;
    fn i128_unwrap_into_u16(&mut self, arg0: i128) -> u16;
    fn i128_from_u16(&mut self, arg0: i128) -> Option<u16>;
    fn i128_try_into_i32(&mut self, arg0: i128) -> Option<i32>;
    fn i128_unwrap_into_i32(&mut self, arg0: i128) -> i32;
    fn i128_truncate_into_i32(&mut self, arg0: i128) -> i32;
    fn i128_from_i32(&mut self, arg0: i128) -> Option<i32>;
    fn i128_try_into_u32(&mut self, arg0: i128) -> Option<u32>;
    fn i128_unwrap_into_u32(&mut self, arg0: i128) -> u32;
    fn i128_from_u32(&mut self, arg0: i128) -> Option<u32>;
    fn i128_try_into_i64(&mut self, arg0: i128) -> Option<i64>;
    fn i128_unwrap_into_i64(&mut self, arg0: i128) -> i64;
    fn i128_truncate_into_i64(&mut self, arg0: i128) -> i64;
    fn i128_from_i64(&mut self, arg0: i128) -> Option<i64>;
    fn i128_try_into_u64(&mut self, arg0: i128) -> Option<u64>;
    fn i128_unwrap_into_u64(&mut self, arg0: i128) -> u64;
    fn i128_from_u64(&mut self, arg0: i128) -> Option<u64>;
    fn i128_try_into_u128(&mut self, arg0: i128) -> Option<u128>;
    fn i128_unwrap_into_u128(&mut self, arg0: i128) -> u128;
    fn i128_cast_unsigned(&mut self, arg0: i128) -> u128;
    fn i128_from_u128(&mut self, arg0: i128) -> Option<u128>;
    fn u128_try_into_i8(&mut self, arg0: u128) -> Option<i8>;
    fn u128_unwrap_into_i8(&mut self, arg0: u128) -> i8;
    fn u128_from_i8(&mut self, arg0: u128) -> Option<i8>;
    fn u128_try_into_u8(&mut self, arg0: u128) -> Option<u8>;
    fn u128_unwrap_into_u8(&mut self, arg0: u128) -> u8;
    fn u128_truncate_into_u8(&mut self, arg0: u128) -> u8;
    fn u128_from_u8(&mut self, arg0: u128) -> Option<u8>;
    fn u128_try_into_i16(&mut self, arg0: u128) -> Option<i16>;
    fn u128_unwrap_into_i16(&mut self, arg0: u128) -> i16;
    fn u128_from_i16(&mut self, arg0: u128) -> Option<i16>;
    fn u128_try_into_u16(&mut self, arg0: u128) -> Option<u16>;
    fn u128_unwrap_into_u16(&mut self, arg0: u128) -> u16;
    fn u128_truncate_into_u16(&mut self, arg0: u128) -> u16;
    fn u128_from_u16(&mut self, arg0: u128) -> Option<u16>;
    fn u128_try_into_i32(&mut self, arg0: u128) -> Option<i32>;
    fn u128_unwrap_into_i32(&mut self, arg0: u128) -> i32;
    fn u128_from_i32(&mut self, arg0: u128) -> Option<i32>;
    fn u128_try_into_u32(&mut self, arg0: u128) -> Option<u32>;
    fn u128_unwrap_into_u32(&mut self, arg0: u128) -> u32;
    fn u128_truncate_into_u32(&mut self, arg0: u128) -> u32;
    fn u128_from_u32(&mut self, arg0: u128) -> Option<u32>;
    fn u128_try_into_i64(&mut self, arg0: u128) -> Option<i64>;
    fn u128_unwrap_into_i64(&mut self, arg0: u128) -> i64;
    fn u128_from_i64(&mut self, arg0: u128) -> Option<i64>;
    fn u128_try_into_u64(&mut self, arg0: u128) -> Option<u64>;
    fn u128_unwrap_into_u64(&mut self, arg0: u128) -> u64;
    fn u128_truncate_into_u64(&mut self, arg0: u128) -> u64;
    fn u128_from_u64(&mut self, arg0: u128) -> Option<u64>;
    fn u128_try_into_i128(&mut self, arg0: u128) -> Option<i128>;
    fn u128_unwrap_into_i128(&mut self, arg0: u128) -> i128;
    fn u128_cast_signed(&mut self, arg0: u128) -> i128;
    fn u128_from_i128(&mut self, arg0: u128) -> Option<i128>;
    fn unpack_value_array_2(&mut self, arg0: &ValueArray2) -> (Value, Value);
    fn pack_value_array_2(&mut self, arg0: Value, arg1: Value) -> ValueArray2;
    fn unpack_value_array_3(&mut self, arg0: &ValueArray3) -> (Value, Value, Value);
    fn pack_value_array_3(&mut self, arg0: Value, arg1: Value, arg2: Value) -> ValueArray3;
    fn unpack_block_array_2(&mut self, arg0: &BlockArray2) -> (BlockCall, BlockCall);
    fn pack_block_array_2(&mut self, arg0: BlockCall, arg1: BlockCall) -> BlockArray2;
}

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 SkeletonInstSimplification: defined at src/prelude_opt.isle line 63.
#[derive(Clone, Debug)]
pub enum SkeletonInstSimplification {
    Remove,
    RemoveWithVal {
        val: Value,
    },
    Replace {
        inst: Inst,
    },
    ReplaceWithVal {
        inst: Inst,
        val: Value,
    },
}

/// Internal type DivConstMagicU32: defined at src/prelude_opt.isle line 233.
#[derive(Clone, Debug)]
pub enum DivConstMagicU32 {
    U32 {
        mul_by: u32,
        do_add: bool,
        shift_by: u32,
    },
}

/// Internal type DivConstMagicU64: defined at src/prelude_opt.isle line 236.
#[derive(Clone, Debug)]
pub enum DivConstMagicU64 {
    U64 {
        mul_by: u64,
        do_add: bool,
        shift_by: u32,
    },
}

/// Internal type DivConstMagicS32: defined at src/prelude_opt.isle line 239.
#[derive(Clone, Debug)]
pub enum DivConstMagicS32 {
    S32 {
        mul_by: i32,
        shift_by: u32,
    },
}

/// Internal type DivConstMagicS64: defined at src/prelude_opt.isle line 241.
#[derive(Clone, Debug)]
pub enum DivConstMagicS64 {
    S64 {
        mul_by: i64,
        shift_by: u32,
    },
}

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

// Generated as internal constructor for term spaceship_s.
pub fn constructor_spaceship_s<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
) -> Value {
    let v4 = constructor_sgt(ctx, arg0, arg1, arg2);
    let v5 = constructor_slt(ctx, arg0, arg1, arg2);
    let v6 = constructor_isub(ctx, I8, v4, v5);
    // Rule at src/prelude_opt.isle line 51.
    return v6;
}

// Generated as internal constructor for term spaceship_u.
pub fn constructor_spaceship_u<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
) -> Value {
    let v4 = constructor_ugt(ctx, arg0, arg1, arg2);
    let v5 = constructor_ult(ctx, arg0, arg1, arg2);
    let v6 = constructor_isub(ctx, I8, v4, v5);
    // Rule at src/prelude_opt.isle line 54.
    return v6;
}

// Generated as internal constructor for term simplify.
pub fn constructor_simplify<C: Context>(
    ctx: &mut C,
    arg0: Value,
    returns: &mut (impl Extend<Value> + Length),
) -> () {
    let mut v1 = C::inst_data_value_etor_returns::default();
    C::inst_data_value_etor(ctx, arg0, &mut v1);
    let mut v1 = v1.into_context_iter();
    while let Some(v2) = v1.next(ctx) {
        match &v2.1 {
            &InstructionData::Binary {
                opcode: ref v5,
                args: ref v6,
            } => {
                match v5 {
                    &Opcode::Smin => {
                        let v7 = C::unpack_value_array_2(ctx, v6);
                        let mut v10 = C::inst_data_value_etor_returns::default();
                        C::inst_data_value_etor(ctx, v7.1, &mut v10);
                        let mut v10 = v10.into_context_iter();
                        while let Some(v11) = v10.next(ctx) {
                            if let &InstructionData::Unary {
                                opcode: ref v26,
                                arg: v27,
                            } = &v11.1 {
                                if let &Opcode::Splat = v26 {
                                    if v2.0 == v11.0 {
                                        let mut v18 = C::inst_data_value_etor_returns::default();
                                        C::inst_data_value_etor(ctx, v7.0, &mut v18);
                                        let mut v18 = v18.into_context_iter();
                                        while let Some(v19) = v18.next(ctx) {
                                            if let &InstructionData::Unary {
                                                opcode: ref v29,
                                                arg: v30,
                                            } = &v19.1 {
                                                if let &Opcode::Splat = v29 {
                                                    if v2.0 == v19.0 {
                                                        let v1425 = C::lane_type(ctx, v2.0);
                                                        let v1565 = constructor_smin(ctx, v1425, v30, v27);
                                                        let v1566 = constructor_splat(ctx, v2.0, v1565);
                                                        // Rule at src/opts/vector.isle line 54.
                                                        returns.extend(Some(v1566));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                    &Opcode::Umin => {
                        let v7 = C::unpack_value_array_2(ctx, v6);
                        let mut v10 = C::inst_data_value_etor_returns::default();
                        C::inst_data_value_etor(ctx, v7.1, &mut v10);
                        let mut v10 = v10.into_context_iter();
                        while let Some(v11) = v10.next(ctx) {
                            if let &InstructionData::Unary {
                                opcode: ref v26,
                                arg: v27,
                            } = &v11.1 {
                                if let &Opcode::Splat = v26 {
                                    if v2.0 == v11.0 {
                                        let mut v18 = C::inst_data_value_etor_returns::default();
                                        C::inst_data_value_etor(ctx, v7.0, &mut v18);
                                        let mut v18 = v18.into_context_iter();
                                        while let Some(v19) = v18.next(ctx) {
                                            if let &InstructionData::Unary {
                                                opcode: ref v29,
                                                arg: v30,
                                            } = &v19.1 {
                                                if let &Opcode::Splat = v29 {
                                                    if v2.0 == v19.0 {
                                                        let v1425 = C::lane_type(ctx, v2.0);
                                                        let v1567 = constructor_umin(ctx, v1425, v30, v27);
                                                        let v1568 = constructor_splat(ctx, v2.0, v1567);
                                                        // Rule at src/opts/vector.isle line 57.
                                                        returns.extend(Some(v1568));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                    &Opcode::Smax => {
                        let v7 = C::unpack_value_array_2(ctx, v6);
                        let mut v10 = C::inst_data_value_etor_returns::default();
                        C::inst_data_value_etor(ctx, v7.1, &mut v10);
                        let mut v10 = v10.into_context_iter();
                        while let Some(v11) = v10.next(ctx) {
                            if let &InstructionData::Unary {
                                opcode: ref v26,
                                arg: v27,
                            } = &v11.1 {
                                if let &Opcode::Splat = v26 {
                                    if v2.0 == v11.0 {
                                        let mut v18 = C::inst_data_value_etor_returns::default();
                                        C::inst_data_value_etor(ctx, v7.0, &mut v18);
                                        let mut v18 = v18.into_context_iter();
                                        while let Some(v19) = v18.next(ctx) {
                                            if let &InstructionData::Unary {
                                                opcode: ref v29,
                                                arg: v30,
                                            } = &v19.1 {
                                                if let &Opcode::Splat = v29 {
                                                    if v2.0 == v19.0 {
                                                        let v1425 = C::lane_type(ctx, v2.0);
                                                        let v1569 = constructor_smax(ctx, v1425, v30, v27);
                                                        let v1570 = constructor_splat(ctx, v2.0, v1569);
                                                        // Rule at src/opts/vector.isle line 60.
                                                        returns.extend(Some(v1570));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                    &Opcode::Umax => {
                        let v7 = C::unpack_value_array_2(ctx, v6);
                        let mut v10 = C::inst_data_value_etor_returns::default();
                        C::inst_data_value_etor(ctx, v7.1, &mut v10);
                        let mut v10 = v10.into_context_iter();
                        while let Some(v11) = v10.next(ctx) {
                            if let &InstructionData::Unary {
                                opcode: ref v26,
                                arg: v27,
                            } = &v11.1 {
                                if let &Opcode::Splat = v26 {
                                    if v2.0 == v11.0 {
                                        let mut v18 = C::inst_data_value_etor_returns::default();
                                        C::inst_data_value_etor(ctx, v7.0, &mut v18);
                                        let mut v18 = v18.into_context_iter();
                                        while let Some(v19) = v18.next(ctx) {
                                            if let &InstructionData::Unary {
                                                opcode: ref v29,
                                                arg: v30,
                                            } = &v19.1 {
                                                if let &Opcode::Splat = v29 {
                                                    if v2.0 == v19.0 {
                                                        let v1425 = C::lane_type(ctx, v2.0);
                                                        let v1571 = constructor_umax(ctx, v1425, v30, v27);
                                                        let v1572 = constructor_splat(ctx, v2.0, v1571);
                                                        // Rule at src/opts/vector.isle line 63.
                                                        returns.extend(Some(v1572));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                    &Opcode::Iadd => {
                        let v7 = C::unpack_value_array_2(ctx, v6);
                        let mut v18 = C::inst_data_value_etor_returns::default();
                        C::inst_data_value_etor(ctx, v7.0, &mut v18);
                        let mut v18 = v18.into_context_iter();
                        while let Some(v19) = v18.next(ctx) {
                            match &v19.1 {
                                &InstructionData::Binary {
                                    opcode: ref v104,
                                    args: ref v105,
                                } => {
                                    match v104 {
                                        &Opcode::Iadd => {
                                            if v2.0 == v19.0 {
                                                let mut v10 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v7.1, &mut v10);
                                                let mut v10 = v10.into_context_iter();
                                                while let Some(v11) = v10.next(ctx) {
                                                    match &v11.1 {
                                                        &InstructionData::Binary {
                                                            opcode: ref v147,
                                                            args: ref v148,
                                                        } => {
                                                            if let &Opcode::Iadd = v147 {
                                                                if v2.0 == v11.0 {
                                                                    let v106 = C::unpack_value_array_2(ctx, v105);
                                                                    let mut v116 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v106.1, &mut v116);
                                                                    let mut v116 = v116.into_context_iter();
                                                                    while let Some(v117) = v116.next(ctx) {
                                                                        if let &InstructionData::UnaryImm {
                                                                            opcode: ref v258,
                                                                            imm: v259,
                                                                        } = &v117.1 {
                                                                            if let &Opcode::Iconst = v258 {
                                                                                let v149 = C::unpack_value_array_2(ctx, v148);
                                                                                let mut v365 = C::inst_data_value_etor_returns::default();
                                                                                C::inst_data_value_etor(ctx, v149.1, &mut v365);
                                                                                let mut v365 = v365.into_context_iter();
                                                                                while let Some(v366) = v365.next(ctx) {
                                                                                    if let &InstructionData::UnaryImm {
                                                                                        opcode: ref v771,
                                                                                        imm: v772,
                                                                                    } = &v366.1 {
                                                                                        if let &Opcode::Iconst = v771 {
                                                                                            let v773 = constructor_iadd(ctx, v2.0, v106.0, v149.0);
                                                                                            let v774 = constructor_iadd(ctx, v2.0, v106.1, v149.1);
                                                                                            let v775 = constructor_iadd(ctx, v2.0, v773, v774);
                                                                                            // Rule at src/opts/cprop.isle line 264.
                                                                                            returns.extend(Some(v775));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        &InstructionData::UnaryImm {
                                                            opcode: ref v14,
                                                            imm: v15,
                                                        } => {
                                                            if let &Opcode::Iconst = v14 {
                                                                if v2.0 == v11.0 {
                                                                    let v106 = C::unpack_value_array_2(ctx, v105);
                                                                    let mut v116 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v106.1, &mut v116);
                                                                    let mut v116 = v116.into_context_iter();
                                                                    while let Some(v117) = v116.next(ctx) {
                                                                        if let &InstructionData::UnaryImm {
                                                                            opcode: ref v258,
                                                                            imm: v259,
                                                                        } = &v117.1 {
                                                                            if let &Opcode::Iconst = v258 {
                                                                                if v2.0 == v117.0 {
                                                                                    let v683 = constructor_iadd(ctx, v2.0, v106.1, v7.1);
                                                                                    let v684 = constructor_iadd(ctx, v2.0, v106.0, v683);
                                                                                    // Rule at src/opts/cprop.isle line 146.
                                                                                    returns.extend(Some(v684));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                            }
                                        }
                                        &Opcode::Isub => {
                                            if v2.0 == v19.0 {
                                                let mut v10 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v7.1, &mut v10);
                                                let mut v10 = v10.into_context_iter();
                                                while let Some(v11) = v10.next(ctx) {
                                                    if let &InstructionData::UnaryImm {
                                                        opcode: ref v14,
                                                        imm: v15,
                                                    } = &v11.1 {
                                                        if let &Opcode::Iconst = v14 {
                                                            if v2.0 == v11.0 {
                                                                let v106 = C::unpack_value_array_2(ctx, v105);
                                                                let mut v109 = C::inst_data_value_etor_returns::default();
                                                                C::inst_data_value_etor(ctx, v106.0, &mut v109);
                                                                let mut v109 = v109.into_context_iter();
                                                                while let Some(v110) = v109.next(ctx) {
                                                                    if let &InstructionData::UnaryImm {
                                                                        opcode: ref v689,
                                                                        imm: v690,
                                                                    } = &v110.1 {
                                                                        if let &Opcode::Iconst = v689 {
                                                                            if v2.0 == v110.0 {
                                                                                let v691 = C::u64_from_imm64(ctx, v690);
                                                                                let v16 = C::u64_from_imm64(ctx, v15);
                                                                                let v701 = C::u64_wrapping_add(ctx, v691, v16);
                                                                                let v702 = C::imm64_masked(ctx, v2.0, v701);
                                                                                let v703 = constructor_iconst(ctx, v2.0, v702);
                                                                                let v704 = constructor_isub(ctx, v2.0, v703, v106.1);
                                                                                // Rule at src/opts/cprop.isle line 172.
                                                                                returns.extend(Some(v704));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                let mut v116 = C::inst_data_value_etor_returns::default();
                                                                C::inst_data_value_etor(ctx, v106.1, &mut v116);
                                                                let mut v116 = v116.into_context_iter();
                                                                while let Some(v117) = v116.next(ctx) {
                                                                    if let &InstructionData::UnaryImm {
                                                                        opcode: ref v258,
                                                                        imm: v259,
                                                                    } = &v117.1 {
                                                                        if let &Opcode::Iconst = v258 {
                                                                            if v2.0 == v117.0 {
                                                                                let v16 = C::u64_from_imm64(ctx, v15);
                                                                                let v260 = C::u64_from_imm64(ctx, v259);
                                                                                let v696 = C::u64_wrapping_sub(ctx, v16, v260);
                                                                                let v697 = C::imm64_masked(ctx, v2.0, v696);
                                                                                let v698 = constructor_iconst(ctx, v2.0, v697);
                                                                                let v700 = constructor_iadd(ctx, v2.0, v106.0, v698);
                                                                                // Rule at src/opts/cprop.isle line 168.
                                                                                returns.extend(Some(v700));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                let v106 = C::unpack_value_array_2(ctx, v105);
                                                if v7.1 == v106.1 {
                                                    // Rule at src/opts/arithmetic.isle line 240.
                                                    returns.extend(Some(v106.0));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                        &Opcode::Band => {
                                            if v2.0 == v19.0 {
                                                let mut v10 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v7.1, &mut v10);
                                                let mut v10 = v10.into_context_iter();
                                                while let Some(v11) = v10.next(ctx) {
                                                    if let &InstructionData::Binary {
                                                        opcode: ref v147,
                                                        args: ref v148,
                                                    } = &v11.1 {
                                                        match v147 {
                                                            &Opcode::Bor => {
                                                                if v2.0 == v11.0 {
                                                                    let v106 = C::unpack_value_array_2(ctx, v105);
                                                                    let v149 = C::unpack_value_array_2(ctx, v148);
                                                                    if v106.0 == v149.0 {
                                                                        if v106.1 == v149.1 {
                                                                            let v571 = constructor_iadd(ctx, v2.0, v106.0, v106.1);
                                                                            // Rule at src/opts/bitops.isle line 209.
                                                                            returns.extend(Some(v571));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            &Opcode::Bxor => {
                                                                if v2.0 == v11.0 {
                                                                    let v106 = C::unpack_value_array_2(ctx, v105);
                                                                    let v149 = C::unpack_value_array_2(ctx, v148);
                                                                    if v106.0 == v149.0 {
                                                                        if v106.1 == v149.1 {
                                                                            let v255 = constructor_bor(ctx, v2.0, v106.0, v106.1);
                                                                            // Rule at src/opts/bitops.isle line 204.
                                                                            returns.extend(Some(v255));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            _ => {}
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        &Opcode::Bor => {
                                            if v2.0 == v19.0 {
                                                let mut v10 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v7.1, &mut v10);
                                                let mut v10 = v10.into_context_iter();
                                                while let Some(v11) = v10.next(ctx) {
                                                    match &v11.1 {
                                                        &InstructionData::Binary {
                                                            opcode: ref v147,
                                                            args: ref v148,
                                                        } => {
                                                            if let &Opcode::Band = v147 {
                                                                if v2.0 == v11.0 {
                                                                    let v106 = C::unpack_value_array_2(ctx, v105);
                                                                    let v149 = C::unpack_value_array_2(ctx, v148);
                                                                    if v106.0 == v149.0 {
                                                                        if v106.1 == v149.1 {
                                                                            let v571 = constructor_iadd(ctx, v2.0, v106.0, v106.1);
                                                                            // Rule at src/opts/bitops.isle line 208.
                                                                            returns.extend(Some(v571));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        &InstructionData::Unary {
                                                            opcode: ref v26,
                                                            arg: v27,
                                                        } => {
                                                            if let &Opcode::Ineg = v26 {
                                                                if v2.0 == v11.0 {
                                                                    let v106 = C::unpack_value_array_2(ctx, v105);
                                                                    if v27 == v106.0 {
                                                                        let v572 = constructor_bnot(ctx, v2.0, v106.0);
                                                                        let v606 = constructor_band(ctx, v2.0, v106.1, v572);
                                                                        // Rule at src/opts/bitops.isle line 243.
                                                                        returns.extend(Some(v606));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                    if v27 == v106.1 {
                                                                        let v603 = constructor_bnot(ctx, v2.0, v106.1);
                                                                        let v604 = constructor_band(ctx, v2.0, v106.0, v603);
                                                                        // Rule at src/opts/bitops.isle line 239.
                                                                        returns.extend(Some(v604));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                let mut v58 = C::inst_data_value_tupled_etor_returns::default();
                                                C::inst_data_value_tupled_etor(ctx, v7.1, &mut v58);
                                                let mut v58 = v58.into_context_iter();
                                                while let Some(v59) = v58.next(ctx) {
                                                    let v60 = C::iconst_sextend_etor(ctx, v59);
                                                    if let Some(v61) = v60 {
                                                        if v2.0 == v61.0 {
                                                            let v106 = C::unpack_value_array_2(ctx, v105);
                                                            let mut v134 = C::inst_data_value_tupled_etor_returns::default();
                                                            C::inst_data_value_tupled_etor(ctx, v106.1, &mut v134);
                                                            let mut v134 = v134.into_context_iter();
                                                            while let Some(v135) = v134.next(ctx) {
                                                                let v136 = C::iconst_sextend_etor(ctx, v135);
                                                                if let Some(v137) = v136 {
                                                                    let v140 = C::i64_checked_neg(ctx, v137.1);
                                                                    if let Some(v141) = v140 {
                                                                        if v2.0 == v137.0 {
                                                                            if v61.1 == v141 {
                                                                                let v142 = C::i64_not(ctx, v137.1);
                                                                                let v143 = C::i64_cast_unsigned(ctx, v142);
                                                                                let v144 = C::imm64_masked(ctx, v2.0, v143);
                                                                                let v145 = constructor_iconst(ctx, v2.0, v144);
                                                                                let v146 = constructor_band(ctx, v2.0, v106.0, v145);
                                                                                // Rule at src/opts/arithmetic.isle line 227.
                                                                                returns.extend(Some(v146));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        &Opcode::Bxor => {
                                            if v2.0 == v19.0 {
                                                let mut v10 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v7.1, &mut v10);
                                                let mut v10 = v10.into_context_iter();
                                                while let Some(v11) = v10.next(ctx) {
                                                    if let &InstructionData::Binary {
                                                        opcode: ref v147,
                                                        args: ref v148,
                                                    } = &v11.1 {
                                                        if let &Opcode::Band = v147 {
                                                            if v2.0 == v11.0 {
                                                                let v106 = C::unpack_value_array_2(ctx, v105);
                                                                let v149 = C::unpack_value_array_2(ctx, v148);
                                                                if v106.0 == v149.0 {
                                                                    if v106.1 == v149.1 {
                                                                        let v255 = constructor_bor(ctx, v2.0, v106.0, v106.1);
                                                                        // Rule at src/opts/bitops.isle line 205.
                                                                        returns.extend(Some(v255));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        &Opcode::Ishl => {
                                            if v2.0 == v19.0 {
                                                let mut v10 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v7.1, &mut v10);
                                                let mut v10 = v10.into_context_iter();
                                                while let Some(v11) = v10.next(ctx) {
                                                    if let &InstructionData::Binary {
                                                        opcode: ref v147,
                                                        args: ref v148,
                                                    } = &v11.1 {
                                                        if let &Opcode::Ishl = v147 {
                                                            if v2.0 == v11.0 {
                                                                let v106 = C::unpack_value_array_2(ctx, v105);
                                                                let v149 = C::unpack_value_array_2(ctx, v148);
                                                                if v106.1 == v149.1 {
                                                                    let v773 = constructor_iadd(ctx, v2.0, v106.0, v149.0);
                                                                    let v1460 = constructor_ishl(ctx, v2.0, v773, v106.1);
                                                                    // Rule at src/opts/shifts.isle line 310.
                                                                    returns.extend(Some(v1460));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        _ => {}
                                    }
                                }
                                &InstructionData::Ternary {
                                    opcode: ref v1334,
                                    args: ref v1335,
                                } => {
                                    if let &Opcode::Select = v1334 {
                                        if v2.0 == v19.0 {
                                            let mut v10 = C::inst_data_value_etor_returns::default();
                                            C::inst_data_value_etor(ctx, v7.1, &mut v10);
                                            let mut v10 = v10.into_context_iter();
                                            while let Some(v11) = v10.next(ctx) {
                                                if let &InstructionData::UnaryImm {
                                                    opcode: ref v14,
                                                    imm: v15,
                                                } = &v11.1 {
                                                    if let &Opcode::Iconst = v14 {
                                                        if v2.0 == v11.0 {
                                                            let v1336 = C::unpack_value_array_3(ctx, v1335);
                                                            let mut v1340 = C::inst_data_value_etor_returns::default();
                                                            C::inst_data_value_etor(ctx, v1336.1, &mut v1340);
                                                            let mut v1340 = v1340.into_context_iter();
                                                            while let Some(v1341) = v1340.next(ctx) {
                                                                if let &InstructionData::UnaryImm {
                                                                    opcode: ref v1344,
                                                                    imm: v1345,
                                                                } = &v1341.1 {
                                                                    if let &Opcode::Iconst = v1344 {
                                                                        if v2.0 == v1341.0 {
                                                                            let mut v1347 = C::inst_data_value_etor_returns::default();
                                                                            C::inst_data_value_etor(ctx, v1336.2, &mut v1347);
                                                                            let mut v1347 = v1347.into_context_iter();
                                                                            while let Some(v1348) = v1347.next(ctx) {
                                                                                if let &InstructionData::UnaryImm {
                                                                                    opcode: ref v1351,
                                                                                    imm: v1352,
                                                                                } = &v1348.1 {
                                                                                    if let &Opcode::Iconst = v1351 {
                                                                                        if v2.0 == v1348.0 {
                                                                                            let v1346 = C::u64_from_imm64(ctx, v1345);
                                                                                            let v16 = C::u64_from_imm64(ctx, v15);
                                                                                            let v1354 = C::u64_wrapping_add(ctx, v1346, v16);
                                                                                            let v1355 = C::imm64_masked(ctx, v2.0, v1354);
                                                                                            let v1356 = constructor_iconst(ctx, v2.0, v1355);
                                                                                            let v1353 = C::u64_from_imm64(ctx, v1352);
                                                                                            let v1357 = C::u64_wrapping_add(ctx, v1353, v16);
                                                                                            let v1358 = C::imm64_masked(ctx, v2.0, v1357);
                                                                                            let v1359 = constructor_iconst(ctx, v2.0, v1358);
                                                                                            let v1360 = constructor_select(ctx, v2.0, v1336.0, v1356, v1359);
                                                                                            // Rule at src/opts/selects.isle line 95.
                                                                                            returns.extend(Some(v1360));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v29,
                                    arg: v30,
                                } => {
                                    match v29 {
                                        &Opcode::Splat => {
                                            if v2.0 == v19.0 {
                                                let mut v10 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v7.1, &mut v10);
                                                let mut v10 = v10.into_context_iter();
                                                while let Some(v11) = v10.next(ctx) {
                                                    if let &InstructionData::Unary {
                                                        opcode: ref v26,
                                                        arg: v27,
                                                    } = &v11.1 {
                                                        if let &Opcode::Splat = v26 {
                                                            if v2.0 == v11.0 {
                                                                let v1425 = C::lane_type(ctx, v2.0);
                                                                let v1549 = constructor_iadd(ctx, v1425, v30, v27);
                                                                let v1550 = constructor_splat(ctx, v2.0, v1549);
                                                                // Rule at src/opts/vector.isle line 30.
                                                                returns.extend(Some(v1550));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        &Opcode::Ineg => {
                                            if v2.0 == v19.0 {
                                                let mut v10 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v7.1, &mut v10);
                                                let mut v10 = v10.into_context_iter();
                                                while let Some(v11) = v10.next(ctx) {
                                                    if let &InstructionData::Binary {
                                                        opcode: ref v147,
                                                        args: ref v148,
                                                    } = &v11.1 {
                                                        if let &Opcode::Bor = v147 {
                                                            if v2.0 == v11.0 {
                                                                let v149 = C::unpack_value_array_2(ctx, v148);
                                                                if v30 == v149.0 {
                                                                    let v574 = constructor_bnot(ctx, v2.0, v30);
                                                                    let v607 = constructor_band(ctx, v2.0, v149.1, v574);
                                                                    // Rule at src/opts/bitops.isle line 245.
                                                                    returns.extend(Some(v607));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                if v30 == v149.1 {
                                                                    let v574 = constructor_bnot(ctx, v2.0, v30);
                                                                    let v605 = constructor_band(ctx, v2.0, v149.0, v574);
                                                                    // Rule at src/opts/bitops.isle line 241.
                                                                    returns.extend(Some(v605));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                let v31 = constructor_isub(ctx, v2.0, v7.1, v30);
                                                // Rule at src/opts/arithmetic.isle line 25.
                                                returns.extend(Some(v31));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                        &Opcode::Bnot => {
                                            if v2.0 == v19.0 {
                                                let mut v10 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v7.1, &mut v10);
                                                let mut v10 = v10.into_context_iter();
                                                while let Some(v11) = v10.next(ctx) {
                                                    if let &InstructionData::UnaryImm {
                                                        opcode: ref v14,
                                                        imm: v15,
                                                    } = &v11.1 {
                                                        if let &Opcode::Iconst = v14 {
                                                            let v16 = C::u64_from_imm64(ctx, v15);
                                                            if v16 == 0x1_u64 {
                                                                if v2.0 == v11.0 {
                                                                    let v65 = constructor_ineg(ctx, v2.0, v30);
                                                                    // Rule at src/opts/arithmetic.isle line 68.
                                                                    returns.extend(Some(v65));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        _ => {}
                                    }
                                }
                                &InstructionData::UnaryImm {
                                    opcode: ref v22,
                                    imm: v23,
                                } => {
                                    if let &Opcode::Iconst = v22 {
                                        let v608 = C::fits_in_64(ctx, v2.0);
                                        if let Some(v609) = v608 {
                                            if v19.0 == v609 {
                                                let mut v10 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v7.1, &mut v10);
                                                let mut v10 = v10.into_context_iter();
                                                while let Some(v11) = v10.next(ctx) {
                                                    if let &InstructionData::UnaryImm {
                                                        opcode: ref v14,
                                                        imm: v15,
                                                    } = &v11.1 {
                                                        if let &Opcode::Iconst = v14 {
                                                            if v11.0 == v19.0 {
                                                                let v24 = C::u64_from_imm64(ctx, v23);
                                                                let v16 = C::u64_from_imm64(ctx, v15);
                                                                let v618 = C::u64_wrapping_add(ctx, v24, v16);
                                                                let v619 = C::imm64_masked(ctx, v609, v618);
                                                                let v620 = constructor_iconst(ctx, v609, v619);
                                                                let v621 = C::subsume(ctx, v620);
                                                                // Rule at src/opts/cprop.isle line 13.
                                                                returns.extend(Some(v621));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        if v2.0 == v19.0 {
                                            let v674 = constructor_iadd(ctx, v2.0, v7.1, v7.0);
                                            // Rule at src/opts/cprop.isle line 115.
                                            returns.extend(Some(v674));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        let v1270 = C::remat(ctx, arg0);
                                        // Rule at src/opts/remat.isle line 3.
                                        returns.extend(Some(v1270));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                                _ => {}
                            }
                        }
                        let mut v10 = C::inst_data_value_etor_returns::default();
                        C::inst_data_value_etor(ctx, v7.1, &mut v10);
                        let mut v10 = v10.into_context_iter();
                        while let Some(v11) = v10.next(ctx) {
                            match &v11.1 {
                                &InstructionData::Binary {
                                    opcode: ref v147,
                                    args: ref v148,
                                } => {
                                    if let &Opcode::Isub = v147 {
                                        if v2.0 == v11.0 {
                                            let v149 = C::unpack_value_array_2(ctx, v148);
                                            if v7.0 == v149.1 {
                                                // Rule at src/opts/arithmetic.isle line 241.
                                                returns.extend(Some(v149.0));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v26,
                                    arg: v27,
                                } => {
                                    if let &Opcode::Ineg = v26 {
                                        if v2.0 == v11.0 {
                                            let v28 = constructor_isub(ctx, v2.0, v7.0, v27);
                                            // Rule at src/opts/arithmetic.isle line 23.
                                            returns.extend(Some(v28));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                    }
                                }
                                &InstructionData::UnaryImm {
                                    opcode: ref v14,
                                    imm: v15,
                                } => {
                                    if let &Opcode::Iconst = v14 {
                                        let v16 = C::u64_from_imm64(ctx, v15);
                                        if v16 == 0x0_u64 {
                                            if v2.0 == v11.0 {
                                                let v17 = C::subsume(ctx, v7.0);
                                                // Rule at src/opts/arithmetic.isle line 7.
                                                returns.extend(Some(v17));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                        let v1270 = C::remat(ctx, arg0);
                                        // Rule at src/opts/remat.isle line 5.
                                        returns.extend(Some(v1270));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                                _ => {}
                            }
                        }
                    }
                    &Opcode::Isub => {
                        let v7 = C::unpack_value_array_2(ctx, v6);
                        let mut v18 = C::inst_data_value_etor_returns::default();
                        C::inst_data_value_etor(ctx, v7.0, &mut v18);
                        let mut v18 = v18.into_context_iter();
                        while let Some(v19) = v18.next(ctx) {
                            match &v19.1 {
                                &InstructionData::Binary {
                                    opcode: ref v104,
                                    args: ref v105,
                                } => {
                                    match v104 {
                                        &Opcode::Iadd => {
                                            if v2.0 == v19.0 {
                                                let mut v10 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v7.1, &mut v10);
                                                let mut v10 = v10.into_context_iter();
                                                while let Some(v11) = v10.next(ctx) {
                                                    match &v11.1 {
                                                        &InstructionData::Binary {
                                                            opcode: ref v147,
                                                            args: ref v148,
                                                        } => {
                                                            if let &Opcode::Bor = v147 {
                                                                if v2.0 == v11.0 {
                                                                    let v106 = C::unpack_value_array_2(ctx, v105);
                                                                    let v149 = C::unpack_value_array_2(ctx, v148);
                                                                    if v106.0 == v149.0 {
                                                                        if v106.1 == v149.1 {
                                                                            let v152 = constructor_band(ctx, v2.0, v106.0, v106.1);
                                                                            // Rule at src/opts/arithmetic.isle line 234.
                                                                            returns.extend(Some(v152));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        &InstructionData::UnaryImm {
                                                            opcode: ref v14,
                                                            imm: v15,
                                                        } => {
                                                            if let &Opcode::Iconst = v14 {
                                                                if v2.0 == v11.0 {
                                                                    let v106 = C::unpack_value_array_2(ctx, v105);
                                                                    let mut v116 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v106.1, &mut v116);
                                                                    let mut v116 = v116.into_context_iter();
                                                                    while let Some(v117) = v116.next(ctx) {
                                                                        if let &InstructionData::UnaryImm {
                                                                            opcode: ref v258,
                                                                            imm: v259,
                                                                        } = &v117.1 {
                                                                            if let &Opcode::Iconst = v258 {
                                                                                if v2.0 == v117.0 {
                                                                                    let v16 = C::u64_from_imm64(ctx, v15);
                                                                                    let v260 = C::u64_from_imm64(ctx, v259);
                                                                                    let v696 = C::u64_wrapping_sub(ctx, v16, v260);
                                                                                    let v697 = C::imm64_masked(ctx, v2.0, v696);
                                                                                    let v698 = constructor_iconst(ctx, v2.0, v697);
                                                                                    let v699 = constructor_isub(ctx, v2.0, v106.0, v698);
                                                                                    // Rule at src/opts/cprop.isle line 164.
                                                                                    returns.extend(Some(v699));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                let v106 = C::unpack_value_array_2(ctx, v105);
                                                if v7.1 == v106.0 {
                                                    // Rule at src/opts/arithmetic.isle line 244.
                                                    returns.extend(Some(v106.1));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v7.1 == v106.1 {
                                                    // Rule at src/opts/arithmetic.isle line 245.
                                                    returns.extend(Some(v106.0));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                        &Opcode::Isub => {
                                            if v2.0 == v19.0 {
                                                let mut v10 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v7.1, &mut v10);
                                                let mut v10 = v10.into_context_iter();
                                                while let Some(v11) = v10.next(ctx) {
                                                    if let &InstructionData::UnaryImm {
                                                        opcode: ref v14,
                                                        imm: v15,
                                                    } = &v11.1 {
                                                        if let &Opcode::Iconst = v14 {
                                                            if v2.0 == v11.0 {
                                                                let v106 = C::unpack_value_array_2(ctx, v105);
                                                                let mut v109 = C::inst_data_value_etor_returns::default();
                                                                C::inst_data_value_etor(ctx, v106.0, &mut v109);
                                                                let mut v109 = v109.into_context_iter();
                                                                while let Some(v110) = v109.next(ctx) {
                                                                    if let &InstructionData::UnaryImm {
                                                                        opcode: ref v689,
                                                                        imm: v690,
                                                                    } = &v110.1 {
                                                                        if let &Opcode::Iconst = v689 {
                                                                            if v2.0 == v110.0 {
                                                                                let v691 = C::u64_from_imm64(ctx, v690);
                                                                                let v16 = C::u64_from_imm64(ctx, v15);
                                                                                let v692 = C::u64_wrapping_sub(ctx, v691, v16);
                                                                                let v693 = C::imm64_masked(ctx, v2.0, v692);
                                                                                let v694 = constructor_iconst(ctx, v2.0, v693);
                                                                                let v695 = constructor_isub(ctx, v2.0, v694, v106.1);
                                                                                // Rule at src/opts/cprop.isle line 160.
                                                                                returns.extend(Some(v695));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                let mut v116 = C::inst_data_value_etor_returns::default();
                                                                C::inst_data_value_etor(ctx, v106.1, &mut v116);
                                                                let mut v116 = v116.into_context_iter();
                                                                while let Some(v117) = v116.next(ctx) {
                                                                    if let &InstructionData::UnaryImm {
                                                                        opcode: ref v258,
                                                                        imm: v259,
                                                                    } = &v117.1 {
                                                                        if let &Opcode::Iconst = v258 {
                                                                            if v2.0 == v117.0 {
                                                                                let v260 = C::u64_from_imm64(ctx, v259);
                                                                                let v16 = C::u64_from_imm64(ctx, v15);
                                                                                let v685 = C::u64_wrapping_add(ctx, v260, v16);
                                                                                let v686 = C::imm64_masked(ctx, v2.0, v685);
                                                                                let v687 = constructor_iconst(ctx, v2.0, v686);
                                                                                let v688 = constructor_isub(ctx, v2.0, v106.0, v687);
                                                                                // Rule at src/opts/cprop.isle line 156.
                                                                                returns.extend(Some(v688));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                let v106 = C::unpack_value_array_2(ctx, v105);
                                                if v7.1 == v106.0 {
                                                    let v160 = constructor_ineg(ctx, v2.0, v106.1);
                                                    // Rule at src/opts/arithmetic.isle line 248.
                                                    returns.extend(Some(v160));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                        &Opcode::Ishl => {
                                            if v2.0 == v19.0 {
                                                let mut v10 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v7.1, &mut v10);
                                                let mut v10 = v10.into_context_iter();
                                                while let Some(v11) = v10.next(ctx) {
                                                    if let &InstructionData::Binary {
                                                        opcode: ref v147,
                                                        args: ref v148,
                                                    } = &v11.1 {
                                                        if let &Opcode::Ishl = v147 {
                                                            if v2.0 == v11.0 {
                                                                let v106 = C::unpack_value_array_2(ctx, v105);
                                                                let v149 = C::unpack_value_array_2(ctx, v148);
                                                                if v106.1 == v149.1 {
                                                                    let v1458 = constructor_isub(ctx, v2.0, v106.0, v149.0);
                                                                    let v1459 = constructor_ishl(ctx, v2.0, v1458, v106.1);
                                                                    // Rule at src/opts/shifts.isle line 309.
                                                                    returns.extend(Some(v1459));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        _ => {}
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v29,
                                    arg: v30,
                                } => {
                                    if let &Opcode::Splat = v29 {
                                        if v2.0 == v19.0 {
                                            let mut v10 = C::inst_data_value_etor_returns::default();
                                            C::inst_data_value_etor(ctx, v7.1, &mut v10);
                                            let mut v10 = v10.into_context_iter();
                                            while let Some(v11) = v10.next(ctx) {
                                                if let &InstructionData::Unary {
                                                    opcode: ref v26,
                                                    arg: v27,
                                                } = &v11.1 {
                                                    if let &Opcode::Splat = v26 {
                                                        if v2.0 == v11.0 {
                                                            let v1425 = C::lane_type(ctx, v2.0);
                                                            let v1551 = constructor_isub(ctx, v1425, v30, v27);
                                                            let v1552 = constructor_splat(ctx, v2.0, v1551);
                                                            // Rule at src/opts/vector.isle line 33.
                                                            returns.extend(Some(v1552));
                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::UnaryImm {
                                    opcode: ref v22,
                                    imm: v23,
                                } => {
                                    if let &Opcode::Iconst = v22 {
                                        if v2.0 == v19.0 {
                                            let v24 = C::u64_from_imm64(ctx, v23);
                                            if v24 == 0x0_u64 {
                                                let v25 = constructor_ineg(ctx, v2.0, v7.1);
                                                // Rule at src/opts/arithmetic.isle line 17.
                                                returns.extend(Some(v25));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                            let v675 = constructor_isub(ctx, v2.0, v7.1, v7.0);
                                            let v676 = constructor_ineg(ctx, v2.0, v675);
                                            // Rule at src/opts/cprop.isle line 120.
                                            returns.extend(Some(v676));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        let v608 = C::fits_in_64(ctx, v2.0);
                                        if let Some(v609) = v608 {
                                            if v19.0 == v609 {
                                                let mut v10 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v7.1, &mut v10);
                                                let mut v10 = v10.into_context_iter();
                                                while let Some(v11) = v10.next(ctx) {
                                                    if let &InstructionData::UnaryImm {
                                                        opcode: ref v14,
                                                        imm: v15,
                                                    } = &v11.1 {
                                                        if let &Opcode::Iconst = v14 {
                                                            if v11.0 == v19.0 {
                                                                let v24 = C::u64_from_imm64(ctx, v23);
                                                                let v16 = C::u64_from_imm64(ctx, v15);
                                                                let v622 = C::u64_wrapping_sub(ctx, v24, v16);
                                                                let v623 = C::imm64_masked(ctx, v609, v622);
                                                                let v624 = constructor_iconst(ctx, v609, v623);
                                                                let v625 = C::subsume(ctx, v624);
                                                                // Rule at src/opts/cprop.isle line 19.
                                                                returns.extend(Some(v625));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        let v1270 = C::remat(ctx, arg0);
                                        // Rule at src/opts/remat.isle line 7.
                                        returns.extend(Some(v1270));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                                _ => {}
                            }
                        }
                        let mut v10 = C::inst_data_value_etor_returns::default();
                        C::inst_data_value_etor(ctx, v7.1, &mut v10);
                        let mut v10 = v10.into_context_iter();
                        while let Some(v11) = v10.next(ctx) {
                            match &v11.1 {
                                &InstructionData::Unary {
                                    opcode: ref v26,
                                    arg: v27,
                                } => {
                                    if let &Opcode::Ineg = v26 {
                                        if v2.0 == v11.0 {
                                            let v44 = constructor_iadd(ctx, v2.0, v7.0, v27);
                                            // Rule at src/opts/arithmetic.isle line 30.
                                            returns.extend(Some(v44));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                    }
                                }
                                &InstructionData::UnaryImm {
                                    opcode: ref v14,
                                    imm: v15,
                                } => {
                                    if let &Opcode::Iconst = v14 {
                                        let v16 = C::u64_from_imm64(ctx, v15);
                                        if v16 == 0x0_u64 {
                                            if v2.0 == v11.0 {
                                                let v17 = C::subsume(ctx, v7.0);
                                                // Rule at src/opts/arithmetic.isle line 12.
                                                returns.extend(Some(v17));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                        let v1270 = C::remat(ctx, arg0);
                                        // Rule at src/opts/remat.isle line 9.
                                        returns.extend(Some(v1270));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                                _ => {}
                            }
                        }
                        if v7.0 == v7.1 {
                            let v52 = C::ty_int(ctx, v2.0);
                            if let Some(v53) = v52 {
                                let v55 = constructor_iconst_u(ctx, v53, 0x0_u64);
                                let v56 = C::subsume(ctx, v55);
                                // Rule at src/opts/arithmetic.isle line 49.
                                returns.extend(Some(v56));
                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                            }
                        }
                        let mut v58 = C::inst_data_value_tupled_etor_returns::default();
                        C::inst_data_value_tupled_etor(ctx, v7.1, &mut v58);
                        let mut v58 = v58.into_context_iter();
                        while let Some(v59) = v58.next(ctx) {
                            let v60 = C::iconst_sextend_etor(ctx, v59);
                            if let Some(v61) = v60 {
                                let v730 = C::i64_wrapping_neg(ctx, v61.1);
                                let v731 = C::i64_cast_unsigned(ctx, v730);
                                let v732 = C::i64_cast_unsigned(ctx, v61.1);
                                let v733 = C::u64_lt(ctx, v731, v732);
                                if v733 == true {
                                    if v2.0 == v61.0 {
                                        let v734 = C::imm64_masked(ctx, v2.0, v731);
                                        let v735 = constructor_iconst(ctx, v2.0, v734);
                                        let v736 = constructor_iadd(ctx, v2.0, v7.0, v735);
                                        // Rule at src/opts/cprop.isle line 219.
                                        returns.extend(Some(v736));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                            }
                        }
                    }
                    &Opcode::Imul => {
                        let v7 = C::unpack_value_array_2(ctx, v6);
                        let mut v10 = C::inst_data_value_etor_returns::default();
                        C::inst_data_value_etor(ctx, v7.1, &mut v10);
                        let mut v10 = v10.into_context_iter();
                        while let Some(v11) = v10.next(ctx) {
                            match &v11.1 {
                                &InstructionData::Binary {
                                    opcode: ref v147,
                                    args: ref v148,
                                } => {
                                    match v147 {
                                        &Opcode::Imul => {
                                            if v2.0 == v11.0 {
                                                let mut v18 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v7.0, &mut v18);
                                                let mut v18 = v18.into_context_iter();
                                                while let Some(v19) = v18.next(ctx) {
                                                    if let &InstructionData::Binary {
                                                        opcode: ref v104,
                                                        args: ref v105,
                                                    } = &v19.1 {
                                                        if let &Opcode::Imul = v104 {
                                                            if v2.0 == v19.0 {
                                                                let v106 = C::unpack_value_array_2(ctx, v105);
                                                                let mut v116 = C::inst_data_value_etor_returns::default();
                                                                C::inst_data_value_etor(ctx, v106.1, &mut v116);
                                                                let mut v116 = v116.into_context_iter();
                                                                while let Some(v117) = v116.next(ctx) {
                                                                    if let &InstructionData::UnaryImm {
                                                                        opcode: ref v258,
                                                                        imm: v259,
                                                                    } = &v117.1 {
                                                                        if let &Opcode::Iconst = v258 {
                                                                            let v149 = C::unpack_value_array_2(ctx, v148);
                                                                            let mut v365 = C::inst_data_value_etor_returns::default();
                                                                            C::inst_data_value_etor(ctx, v149.1, &mut v365);
                                                                            let mut v365 = v365.into_context_iter();
                                                                            while let Some(v366) = v365.next(ctx) {
                                                                                if let &InstructionData::UnaryImm {
                                                                                    opcode: ref v771,
                                                                                    imm: v772,
                                                                                } = &v366.1 {
                                                                                    if let &Opcode::Iconst = v771 {
                                                                                        let v776 = constructor_imul(ctx, v2.0, v106.0, v149.0);
                                                                                        let v777 = constructor_imul(ctx, v2.0, v106.1, v149.1);
                                                                                        let v778 = constructor_imul(ctx, v2.0, v776, v777);
                                                                                        // Rule at src/opts/cprop.isle line 268.
                                                                                        returns.extend(Some(v778));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        &Opcode::Ishl => {
                                            if v2.0 == v11.0 {
                                                let v149 = C::unpack_value_array_2(ctx, v148);
                                                let mut v153 = C::inst_data_value_tupled_etor_returns::default();
                                                C::inst_data_value_tupled_etor(ctx, v149.0, &mut v153);
                                                let mut v153 = v153.into_context_iter();
                                                while let Some(v154) = v153.next(ctx) {
                                                    let v155 = C::iconst_sextend_etor(ctx, v154);
                                                    if let Some(v156) = v155 {
                                                        if v156.1 == 1_i64 {
                                                            if v2.0 == v156.0 {
                                                                let v159 = constructor_ishl(ctx, v2.0, v7.0, v149.1);
                                                                // Rule at src/opts/arithmetic.isle line 237.
                                                                returns.extend(Some(v159));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        _ => {}
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v26,
                                    arg: v27,
                                } => {
                                    match v26 {
                                        &Opcode::Splat => {
                                            if v2.0 == v11.0 {
                                                let mut v18 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v7.0, &mut v18);
                                                let mut v18 = v18.into_context_iter();
                                                while let Some(v19) = v18.next(ctx) {
                                                    if let &InstructionData::Unary {
                                                        opcode: ref v29,
                                                        arg: v30,
                                                    } = &v19.1 {
                                                        if let &Opcode::Splat = v29 {
                                                            if v2.0 == v19.0 {
                                                                let v1425 = C::lane_type(ctx, v2.0);
                                                                let v1553 = constructor_imul(ctx, v1425, v30, v27);
                                                                let v1554 = constructor_splat(ctx, v2.0, v1553);
                                                                // Rule at src/opts/vector.isle line 36.
                                                                returns.extend(Some(v1554));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        &Opcode::Ineg => {
                                            if v2.0 == v11.0 {
                                                let mut v18 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v7.0, &mut v18);
                                                let mut v18 = v18.into_context_iter();
                                                while let Some(v19) = v18.next(ctx) {
                                                    if let &InstructionData::Unary {
                                                        opcode: ref v29,
                                                        arg: v30,
                                                    } = &v19.1 {
                                                        if let &Opcode::Ineg = v29 {
                                                            if v2.0 == v19.0 {
                                                                let v48 = constructor_imul(ctx, v2.0, v30, v27);
                                                                let v49 = C::subsume(ctx, v48);
                                                                // Rule at src/opts/arithmetic.isle line 37.
                                                                returns.extend(Some(v49));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        _ => {}
                                    }
                                }
                                &InstructionData::UnaryImm {
                                    opcode: ref v14,
                                    imm: v15,
                                } => {
                                    if let &Opcode::Iconst = v14 {
                                        let v16 = C::u64_from_imm64(ctx, v15);
                                        match v16 {
                                            0x0_u64 => {
                                                if v2.0 == v11.0 {
                                                    let v57 = C::subsume(ctx, v7.1);
                                                    // Rule at src/opts/arithmetic.isle line 58.
                                                    returns.extend(Some(v57));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                            0x1_u64 => {
                                                if v2.0 == v11.0 {
                                                    let v17 = C::subsume(ctx, v7.0);
                                                    // Rule at src/opts/arithmetic.isle line 52.
                                                    returns.extend(Some(v17));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                            0x2_u64 => {
                                                let v73 = constructor_iadd(ctx, v2.0, v7.0, v7.0);
                                                // Rule at src/opts/arithmetic.isle line 172.
                                                returns.extend(Some(v73));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                            _ => {}
                                        }
                                        let mut v18 = C::inst_data_value_etor_returns::default();
                                        C::inst_data_value_etor(ctx, v7.0, &mut v18);
                                        let mut v18 = v18.into_context_iter();
                                        while let Some(v19) = v18.next(ctx) {
                                            match &v19.1 {
                                                &InstructionData::Binary {
                                                    opcode: ref v104,
                                                    args: ref v105,
                                                } => {
                                                    if let &Opcode::Imul = v104 {
                                                        if v2.0 == v11.0 {
                                                            if v2.0 == v19.0 {
                                                                let v106 = C::unpack_value_array_2(ctx, v105);
                                                                let mut v116 = C::inst_data_value_etor_returns::default();
                                                                C::inst_data_value_etor(ctx, v106.1, &mut v116);
                                                                let mut v116 = v116.into_context_iter();
                                                                while let Some(v117) = v116.next(ctx) {
                                                                    if let &InstructionData::UnaryImm {
                                                                        opcode: ref v258,
                                                                        imm: v259,
                                                                    } = &v117.1 {
                                                                        if let &Opcode::Iconst = v258 {
                                                                            if v2.0 == v117.0 {
                                                                                let v705 = constructor_imul(ctx, v2.0, v106.1, v7.1);
                                                                                let v706 = constructor_imul(ctx, v2.0, v106.0, v705);
                                                                                // Rule at src/opts/cprop.isle line 177.
                                                                                returns.extend(Some(v706));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                &InstructionData::UnaryImm {
                                                    opcode: ref v22,
                                                    imm: v23,
                                                } => {
                                                    if let &Opcode::Iconst = v22 {
                                                        let v608 = C::fits_in_64(ctx, v2.0);
                                                        if let Some(v609) = v608 {
                                                            if v11.0 == v19.0 {
                                                                if v11.0 == v609 {
                                                                    let v24 = C::u64_from_imm64(ctx, v23);
                                                                    let v626 = C::u64_wrapping_mul(ctx, v24, v16);
                                                                    let v627 = C::imm64_masked(ctx, v609, v626);
                                                                    let v628 = constructor_iconst(ctx, v609, v627);
                                                                    let v629 = C::subsume(ctx, v628);
                                                                    // Rule at src/opts/cprop.isle line 25.
                                                                    returns.extend(Some(v629));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                _ => {}
                                            }
                                        }
                                        let v74 = C::imm64_power_of_two(ctx, v15);
                                        if let Some(v75) = v74 {
                                            let v76 = C::imm64(ctx, v75);
                                            let v77 = constructor_iconst(ctx, v2.0, v76);
                                            let v78 = constructor_ishl(ctx, v2.0, v7.0, v77);
                                            // Rule at src/opts/arithmetic.isle line 180.
                                            returns.extend(Some(v78));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                    }
                                }
                                _ => {}
                            }
                        }
                        let mut v18 = C::inst_data_value_etor_returns::default();
                        C::inst_data_value_etor(ctx, v7.0, &mut v18);
                        let mut v18 = v18.into_context_iter();
                        while let Some(v19) = v18.next(ctx) {
                            if let &InstructionData::UnaryImm {
                                opcode: ref v22,
                                imm: v23,
                            } = &v19.1 {
                                if let &Opcode::Iconst = v22 {
                                    let v79 = C::imm64_power_of_two(ctx, v23);
                                    if let Some(v80) = v79 {
                                        let v81 = C::imm64(ctx, v80);
                                        let v82 = constructor_iconst(ctx, v2.0, v81);
                                        let v83 = constructor_ishl(ctx, v2.0, v7.1, v82);
                                        // Rule at src/opts/arithmetic.isle line 182.
                                        returns.extend(Some(v83));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                    if v2.0 == v19.0 {
                                        let v677 = constructor_imul(ctx, v2.0, v7.1, v7.0);
                                        // Rule at src/opts/cprop.isle line 123.
                                        returns.extend(Some(v677));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                            }
                        }
                        let mut v58 = C::inst_data_value_tupled_etor_returns::default();
                        C::inst_data_value_tupled_etor(ctx, v7.1, &mut v58);
                        let mut v58 = v58.into_context_iter();
                        while let Some(v59) = v58.next(ctx) {
                            let v60 = C::iconst_sextend_etor(ctx, v59);
                            if let Some(v61) = v60 {
                                if v61.1 == -1_i64 {
                                    if v2.0 == v61.0 {
                                        let v64 = constructor_ineg(ctx, v2.0, v7.0);
                                        // Rule at src/opts/arithmetic.isle line 64.
                                        returns.extend(Some(v64));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                            }
                        }
                    }
                    &Opcode::Umulhi => {
                        let v7 = C::unpack_value_array_2(ctx, v6);
                        let mut v10 = C::inst_data_value_etor_returns::default();
                        C::inst_data_value_etor(ctx, v7.1, &mut v10);
                        let mut v10 = v10.into_context_iter();
                        while let Some(v11) = v10.next(ctx) {
                            if let &InstructionData::Unary {
                                opcode: ref v26,
                                arg: v27,
                            } = &v11.1 {
                                if let &Opcode::Splat = v26 {
                                    if v2.0 == v11.0 {
                                        let mut v18 = C::inst_data_value_etor_returns::default();
                                        C::inst_data_value_etor(ctx, v7.0, &mut v18);
                                        let mut v18 = v18.into_context_iter();
                                        while let Some(v19) = v18.next(ctx) {
                                            if let &InstructionData::Unary {
                                                opcode: ref v29,
                                                arg: v30,
                                            } = &v19.1 {
                                                if let &Opcode::Splat = v29 {
                                                    if v2.0 == v19.0 {
                                                        let v1425 = C::lane_type(ctx, v2.0);
                                                        let v1557 = constructor_umulhi(ctx, v1425, v30, v27);
                                                        let v1558 = constructor_splat(ctx, v2.0, v1557);
                                                        // Rule at src/opts/vector.isle line 42.
                                                        returns.extend(Some(v1558));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                    &Opcode::Smulhi => {
                        let v7 = C::unpack_value_array_2(ctx, v6);
                        let mut v10 = C::inst_data_value_etor_returns::default();
                        C::inst_data_value_etor(ctx, v7.1, &mut v10);
                        let mut v10 = v10.into_context_iter();
                        while let Some(v11) = v10.next(ctx) {
                            if let &InstructionData::Unary {
                                opcode: ref v26,
                                arg: v27,
                            } = &v11.1 {
                                if let &Opcode::Splat = v26 {
                                    if v2.0 == v11.0 {
                                        let mut v18 = C::inst_data_value_etor_returns::default();
                                        C::inst_data_value_etor(ctx, v7.0, &mut v18);
                                        let mut v18 = v18.into_context_iter();
                                        while let Some(v19) = v18.next(ctx) {
                                            if let &InstructionData::Unary {
                                                opcode: ref v29,
                                                arg: v30,
                                            } = &v19.1 {
                                                if let &Opcode::Splat = v29 {
                                                    if v2.0 == v19.0 {
                                                        let v1425 = C::lane_type(ctx, v2.0);
                                                        let v1555 = constructor_smulhi(ctx, v1425, v30, v27);
                                                        let v1556 = constructor_splat(ctx, v2.0, v1555);
                                                        // Rule at src/opts/vector.isle line 39.
                                                        returns.extend(Some(v1556));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                    &Opcode::Band => {
                        let v7 = C::unpack_value_array_2(ctx, v6);
                        let mut v10 = C::inst_data_value_etor_returns::default();
                        C::inst_data_value_etor(ctx, v7.1, &mut v10);
                        let mut v10 = v10.into_context_iter();
                        while let Some(v11) = v10.next(ctx) {
                            match &v11.1 {
                                &InstructionData::Binary {
                                    opcode: ref v147,
                                    args: ref v148,
                                } => {
                                    match v147 {
                                        &Opcode::Band => {
                                            if v2.0 == v11.0 {
                                                let v149 = C::unpack_value_array_2(ctx, v148);
                                                if v7.0 == v149.0 {
                                                    let v561 = constructor_band(ctx, v2.0, v7.0, v149.1);
                                                    // Rule at src/opts/bitops.isle line 194.
                                                    returns.extend(Some(v561));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v7.0 == v149.1 {
                                                    let v562 = constructor_band(ctx, v2.0, v149.0, v7.0);
                                                    // Rule at src/opts/bitops.isle line 195.
                                                    returns.extend(Some(v562));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                let mut v18 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v7.0, &mut v18);
                                                let mut v18 = v18.into_context_iter();
                                                while let Some(v19) = v18.next(ctx) {
                                                    if let &InstructionData::Binary {
                                                        opcode: ref v104,
                                                        args: ref v105,
                                                    } = &v19.1 {
                                                        if let &Opcode::Band = v104 {
                                                            if v2.0 == v19.0 {
                                                                let v106 = C::unpack_value_array_2(ctx, v105);
                                                                let mut v116 = C::inst_data_value_etor_returns::default();
                                                                C::inst_data_value_etor(ctx, v106.1, &mut v116);
                                                                let mut v116 = v116.into_context_iter();
                                                                while let Some(v117) = v116.next(ctx) {
                                                                    if let &InstructionData::UnaryImm {
                                                                        opcode: ref v258,
                                                                        imm: v259,
                                                                    } = &v117.1 {
                                                                        if let &Opcode::Iconst = v258 {
                                                                            let mut v365 = C::inst_data_value_etor_returns::default();
                                                                            C::inst_data_value_etor(ctx, v149.1, &mut v365);
                                                                            let mut v365 = v365.into_context_iter();
                                                                            while let Some(v366) = v365.next(ctx) {
                                                                                if let &InstructionData::UnaryImm {
                                                                                    opcode: ref v771,
                                                                                    imm: v772,
                                                                                } = &v366.1 {
                                                                                    if let &Opcode::Iconst = v771 {
                                                                                        let v779 = constructor_band(ctx, v2.0, v106.0, v149.0);
                                                                                        let v780 = constructor_band(ctx, v2.0, v106.1, v149.1);
                                                                                        let v781 = constructor_band(ctx, v2.0, v779, v780);
                                                                                        // Rule at src/opts/cprop.isle line 272.
                                                                                        returns.extend(Some(v781));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        &Opcode::Bxor => {
                                            if v2.0 == v11.0 {
                                                let v149 = C::unpack_value_array_2(ctx, v148);
                                                if v7.0 == v149.0 {
                                                    let mut v365 = C::inst_data_value_etor_returns::default();
                                                    C::inst_data_value_etor(ctx, v149.1, &mut v365);
                                                    let mut v365 = v365.into_context_iter();
                                                    while let Some(v366) = v365.next(ctx) {
                                                        if let &InstructionData::Unary {
                                                            opcode: ref v565,
                                                            arg: v566,
                                                        } = &v366.1 {
                                                            if let &Opcode::Bnot = v565 {
                                                                if v2.0 == v366.0 {
                                                                    let v567 = constructor_band(ctx, v2.0, v7.0, v566);
                                                                    // Rule at src/opts/bitops.isle line 200.
                                                                    returns.extend(Some(v567));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                if v7.0 == v149.1 {
                                                    let mut v333 = C::inst_data_value_etor_returns::default();
                                                    C::inst_data_value_etor(ctx, v149.0, &mut v333);
                                                    let mut v333 = v333.into_context_iter();
                                                    while let Some(v334) = v333.next(ctx) {
                                                        if let &InstructionData::Unary {
                                                            opcode: ref v568,
                                                            arg: v569,
                                                        } = &v334.1 {
                                                            if let &Opcode::Bnot = v568 {
                                                                if v2.0 == v334.0 {
                                                                    let v570 = constructor_band(ctx, v2.0, v7.0, v569);
                                                                    // Rule at src/opts/bitops.isle line 201.
                                                                    returns.extend(Some(v570));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        &Opcode::Ishl => {
                                            if v2.0 == v11.0 {
                                                let mut v18 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v7.0, &mut v18);
                                                let mut v18 = v18.into_context_iter();
                                                while let Some(v19) = v18.next(ctx) {
                                                    if let &InstructionData::Binary {
                                                        opcode: ref v104,
                                                        args: ref v105,
                                                    } = &v19.1 {
                                                        if let &Opcode::Ishl = v104 {
                                                            if v2.0 == v19.0 {
                                                                let v106 = C::unpack_value_array_2(ctx, v105);
                                                                let v149 = C::unpack_value_array_2(ctx, v148);
                                                                if v106.1 == v149.1 {
                                                                    let v779 = constructor_band(ctx, v2.0, v106.0, v149.0);
                                                                    let v1457 = constructor_ishl(ctx, v2.0, v779, v106.1);
                                                                    // Rule at src/opts/shifts.isle line 308.
                                                                    returns.extend(Some(v1457));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        _ => {}
                                    }
                                }
                                &InstructionData::IntCompare {
                                    opcode: ref v1126,
                                    args: ref v1127,
                                    cond: ref v1128,
                                } => {
                                    if let &Opcode::Icmp = v1126 {
                                        let mut v18 = C::inst_data_value_etor_returns::default();
                                        C::inst_data_value_etor(ctx, v7.0, &mut v18);
                                        let mut v18 = v18.into_context_iter();
                                        while let Some(v19) = v18.next(ctx) {
                                            if let &InstructionData::IntCompare {
                                                opcode: ref v1100,
                                                args: ref v1101,
                                                cond: ref v1102,
                                            } = &v19.1 {
                                                if let &Opcode::Icmp = v1100 {
                                                    if v11.0 == v19.0 {
                                                        match v1102 {
                                                            &IntCC::NotEqual => {
                                                                match v1128 {
                                                                    &IntCC::UnsignedGreaterThan => {
                                                                        if v2.0 == v11.0 {
                                                                            let v1103 = C::unpack_value_array_2(ctx, v1101);
                                                                            let v1129 = C::unpack_value_array_2(ctx, v1127);
                                                                            if v1103.0 == v1129.1 {
                                                                                let mut v1217 = C::inst_data_value_tupled_etor_returns::default();
                                                                                C::inst_data_value_tupled_etor(ctx, v1103.1, &mut v1217);
                                                                                let mut v1217 = v1217.into_context_iter();
                                                                                while let Some(v1218) = v1217.next(ctx) {
                                                                                    let v1219 = C::iconst_sextend_etor(ctx, v1218);
                                                                                    if let Some(v1220) = v1219 {
                                                                                        if v1220.1 == -1_i64 {
                                                                                            let v1245 = constructor_ult(ctx, v2.0, v1103.0, v1129.0);
                                                                                            // Rule at src/opts/icmp.isle line 361.
                                                                                            returns.extend(Some(v1245));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                            if v1103.1 == v1129.1 {
                                                                                let mut v1230 = C::inst_data_value_tupled_etor_returns::default();
                                                                                C::inst_data_value_tupled_etor(ctx, v1103.0, &mut v1230);
                                                                                let mut v1230 = v1230.into_context_iter();
                                                                                while let Some(v1231) = v1230.next(ctx) {
                                                                                    let v1232 = C::iconst_sextend_etor(ctx, v1231);
                                                                                    if let Some(v1233) = v1232 {
                                                                                        if v1233.1 == -1_i64 {
                                                                                            let v1247 = constructor_ult(ctx, v2.0, v1103.1, v1129.0);
                                                                                            // Rule at src/opts/icmp.isle line 367.
                                                                                            returns.extend(Some(v1247));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::UnsignedLessThan => {
                                                                        if v2.0 == v11.0 {
                                                                            let v1103 = C::unpack_value_array_2(ctx, v1101);
                                                                            let v1129 = C::unpack_value_array_2(ctx, v1127);
                                                                            if v1103.0 == v1129.0 {
                                                                                let mut v1217 = C::inst_data_value_tupled_etor_returns::default();
                                                                                C::inst_data_value_tupled_etor(ctx, v1103.1, &mut v1217);
                                                                                let mut v1217 = v1217.into_context_iter();
                                                                                while let Some(v1218) = v1217.next(ctx) {
                                                                                    let v1219 = C::iconst_sextend_etor(ctx, v1218);
                                                                                    if let Some(v1220) = v1219 {
                                                                                        if v1220.1 == -1_i64 {
                                                                                            let v1246 = constructor_ult(ctx, v2.0, v1103.0, v1129.1);
                                                                                            // Rule at src/opts/icmp.isle line 364.
                                                                                            returns.extend(Some(v1246));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                            if v1103.1 == v1129.0 {
                                                                                let mut v1230 = C::inst_data_value_tupled_etor_returns::default();
                                                                                C::inst_data_value_tupled_etor(ctx, v1103.0, &mut v1230);
                                                                                let mut v1230 = v1230.into_context_iter();
                                                                                while let Some(v1231) = v1230.next(ctx) {
                                                                                    let v1232 = C::iconst_sextend_etor(ctx, v1231);
                                                                                    if let Some(v1233) = v1232 {
                                                                                        if v1233.1 == -1_i64 {
                                                                                            let v1248 = constructor_ult(ctx, v2.0, v1103.1, v1129.1);
                                                                                            // Rule at src/opts/icmp.isle line 370.
                                                                                            returns.extend(Some(v1248));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    _ => {}
                                                                }
                                                            }
                                                            &IntCC::SignedGreaterThan => {
                                                                match v1128 {
                                                                    &IntCC::SignedLessThan => {
                                                                        let v608 = C::fits_in_64(ctx, v2.0);
                                                                        if let Some(v609) = v608 {
                                                                            if v11.0 == v609 {
                                                                                let v1103 = C::unpack_value_array_2(ctx, v1101);
                                                                                let v1129 = C::unpack_value_array_2(ctx, v1127);
                                                                                if v1103.0 == v1129.0 {
                                                                                    if v1103.1 == v1129.1 {
                                                                                        let v1216 = constructor_iconst_u(ctx, v609, 0x0_u64);
                                                                                        // Rule at src/opts/icmp.isle line 322.
                                                                                        returns.extend(Some(v1216));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::UnsignedLessThan => {
                                                                        if v2.0 == v11.0 {
                                                                            let v1103 = C::unpack_value_array_2(ctx, v1101);
                                                                            let v1129 = C::unpack_value_array_2(ctx, v1127);
                                                                            if v1103.0 == v1129.0 {
                                                                                let mut v1217 = C::inst_data_value_tupled_etor_returns::default();
                                                                                C::inst_data_value_tupled_etor(ctx, v1103.1, &mut v1217);
                                                                                let mut v1217 = v1217.into_context_iter();
                                                                                while let Some(v1218) = v1217.next(ctx) {
                                                                                    let v1219 = C::iconst_sextend_etor(ctx, v1218);
                                                                                    if let Some(v1220) = v1219 {
                                                                                        let v1229 = C::i64_gt_eq(ctx, v1220.1, 0_i64);
                                                                                        if v1229 == true {
                                                                                            let mut v1223 = C::inst_data_value_tupled_etor_returns::default();
                                                                                            C::inst_data_value_tupled_etor(ctx, v1129.1, &mut v1223);
                                                                                            let mut v1223 = v1223.into_context_iter();
                                                                                            while let Some(v1224) = v1223.next(ctx) {
                                                                                                let v1225 = C::iconst_sextend_etor(ctx, v1224);
                                                                                                if let Some(v1226) = v1225 {
                                                                                                    if v1220.1 == v1226.1 {
                                                                                                        let v995 = constructor_iconst_u(ctx, v2.0, 0x0_u64);
                                                                                                        // Rule at src/opts/icmp.isle line 327.
                                                                                                        returns.extend(Some(v995));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                            if v1103.1 == v1129.1 {
                                                                                let mut v1230 = C::inst_data_value_tupled_etor_returns::default();
                                                                                C::inst_data_value_tupled_etor(ctx, v1103.0, &mut v1230);
                                                                                let mut v1230 = v1230.into_context_iter();
                                                                                while let Some(v1231) = v1230.next(ctx) {
                                                                                    let v1232 = C::iconst_sextend_etor(ctx, v1231);
                                                                                    if let Some(v1233) = v1232 {
                                                                                        let v1242 = C::i64_lt(ctx, v1233.1, 0_i64);
                                                                                        if v1242 == true {
                                                                                            let mut v1236 = C::inst_data_value_tupled_etor_returns::default();
                                                                                            C::inst_data_value_tupled_etor(ctx, v1129.0, &mut v1236);
                                                                                            let mut v1236 = v1236.into_context_iter();
                                                                                            while let Some(v1237) = v1236.next(ctx) {
                                                                                                let v1238 = C::iconst_sextend_etor(ctx, v1237);
                                                                                                if let Some(v1239) = v1238 {
                                                                                                    if v1233.1 == v1239.1 {
                                                                                                        let v995 = constructor_iconst_u(ctx, v2.0, 0x0_u64);
                                                                                                        // Rule at src/opts/icmp.isle line 331.
                                                                                                        returns.extend(Some(v995));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    _ => {}
                                                                }
                                                            }
                                                            &IntCC::SignedLessThan => {
                                                                match v1128 {
                                                                    &IntCC::SignedGreaterThan => {
                                                                        let v608 = C::fits_in_64(ctx, v2.0);
                                                                        if let Some(v609) = v608 {
                                                                            if v11.0 == v609 {
                                                                                let v1103 = C::unpack_value_array_2(ctx, v1101);
                                                                                let v1129 = C::unpack_value_array_2(ctx, v1127);
                                                                                if v1103.0 == v1129.0 {
                                                                                    if v1103.1 == v1129.1 {
                                                                                        let v1216 = constructor_iconst_u(ctx, v609, 0x0_u64);
                                                                                        // Rule at src/opts/icmp.isle line 323.
                                                                                        returns.extend(Some(v1216));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::UnsignedGreaterThan => {
                                                                        if v2.0 == v11.0 {
                                                                            let v1103 = C::unpack_value_array_2(ctx, v1101);
                                                                            let v1129 = C::unpack_value_array_2(ctx, v1127);
                                                                            if v1103.0 == v1129.0 {
                                                                                let mut v1217 = C::inst_data_value_tupled_etor_returns::default();
                                                                                C::inst_data_value_tupled_etor(ctx, v1103.1, &mut v1217);
                                                                                let mut v1217 = v1217.into_context_iter();
                                                                                while let Some(v1218) = v1217.next(ctx) {
                                                                                    let v1219 = C::iconst_sextend_etor(ctx, v1218);
                                                                                    if let Some(v1220) = v1219 {
                                                                                        let v1243 = C::i64_lt(ctx, v1220.1, 0_i64);
                                                                                        if v1243 == true {
                                                                                            let mut v1223 = C::inst_data_value_tupled_etor_returns::default();
                                                                                            C::inst_data_value_tupled_etor(ctx, v1129.1, &mut v1223);
                                                                                            let mut v1223 = v1223.into_context_iter();
                                                                                            while let Some(v1224) = v1223.next(ctx) {
                                                                                                let v1225 = C::iconst_sextend_etor(ctx, v1224);
                                                                                                if let Some(v1226) = v1225 {
                                                                                                    if v1220.1 == v1226.1 {
                                                                                                        let v995 = constructor_iconst_u(ctx, v2.0, 0x0_u64);
                                                                                                        // Rule at src/opts/icmp.isle line 335.
                                                                                                        returns.extend(Some(v995));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                            if v1103.1 == v1129.1 {
                                                                                let mut v1230 = C::inst_data_value_tupled_etor_returns::default();
                                                                                C::inst_data_value_tupled_etor(ctx, v1103.0, &mut v1230);
                                                                                let mut v1230 = v1230.into_context_iter();
                                                                                while let Some(v1231) = v1230.next(ctx) {
                                                                                    let v1232 = C::iconst_sextend_etor(ctx, v1231);
                                                                                    if let Some(v1233) = v1232 {
                                                                                        let v1244 = C::i64_gt_eq(ctx, v1233.1, 0_i64);
                                                                                        if v1244 == true {
                                                                                            let mut v1236 = C::inst_data_value_tupled_etor_returns::default();
                                                                                            C::inst_data_value_tupled_etor(ctx, v1129.0, &mut v1236);
                                                                                            let mut v1236 = v1236.into_context_iter();
                                                                                            while let Some(v1237) = v1236.next(ctx) {
                                                                                                let v1238 = C::iconst_sextend_etor(ctx, v1237);
                                                                                                if let Some(v1239) = v1238 {
                                                                                                    if v1233.1 == v1239.1 {
                                                                                                        let v995 = constructor_iconst_u(ctx, v2.0, 0x0_u64);
                                                                                                        // Rule at src/opts/icmp.isle line 339.
                                                                                                        returns.extend(Some(v995));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    _ => {}
                                                                }
                                                            }
                                                            &IntCC::UnsignedGreaterThan => {
                                                                match v1128 {
                                                                    &IntCC::NotEqual => {
                                                                        if v2.0 == v11.0 {
                                                                            let v1103 = C::unpack_value_array_2(ctx, v1101);
                                                                            let v1129 = C::unpack_value_array_2(ctx, v1127);
                                                                            if v1103.1 == v1129.0 {
                                                                                let mut v1223 = C::inst_data_value_tupled_etor_returns::default();
                                                                                C::inst_data_value_tupled_etor(ctx, v1129.1, &mut v1223);
                                                                                let mut v1223 = v1223.into_context_iter();
                                                                                while let Some(v1224) = v1223.next(ctx) {
                                                                                    let v1225 = C::iconst_sextend_etor(ctx, v1224);
                                                                                    if let Some(v1226) = v1225 {
                                                                                        if v1226.1 == -1_i64 {
                                                                                            let v1249 = constructor_ult(ctx, v2.0, v1103.1, v1103.0);
                                                                                            // Rule at src/opts/icmp.isle line 373.
                                                                                            returns.extend(Some(v1249));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                            if v1103.1 == v1129.1 {
                                                                                let mut v1236 = C::inst_data_value_tupled_etor_returns::default();
                                                                                C::inst_data_value_tupled_etor(ctx, v1129.0, &mut v1236);
                                                                                let mut v1236 = v1236.into_context_iter();
                                                                                while let Some(v1237) = v1236.next(ctx) {
                                                                                    let v1238 = C::iconst_sextend_etor(ctx, v1237);
                                                                                    if let Some(v1239) = v1238 {
                                                                                        if v1239.1 == -1_i64 {
                                                                                            let v1249 = constructor_ult(ctx, v2.0, v1103.1, v1103.0);
                                                                                            // Rule at src/opts/icmp.isle line 376.
                                                                                            returns.extend(Some(v1249));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::SignedLessThan => {
                                                                        if v2.0 == v11.0 {
                                                                            let v1103 = C::unpack_value_array_2(ctx, v1101);
                                                                            let v1129 = C::unpack_value_array_2(ctx, v1127);
                                                                            if v1103.0 == v1129.0 {
                                                                                let mut v1217 = C::inst_data_value_tupled_etor_returns::default();
                                                                                C::inst_data_value_tupled_etor(ctx, v1103.1, &mut v1217);
                                                                                let mut v1217 = v1217.into_context_iter();
                                                                                while let Some(v1218) = v1217.next(ctx) {
                                                                                    let v1219 = C::iconst_sextend_etor(ctx, v1218);
                                                                                    if let Some(v1220) = v1219 {
                                                                                        let v1243 = C::i64_lt(ctx, v1220.1, 0_i64);
                                                                                        if v1243 == true {
                                                                                            let mut v1223 = C::inst_data_value_tupled_etor_returns::default();
                                                                                            C::inst_data_value_tupled_etor(ctx, v1129.1, &mut v1223);
                                                                                            let mut v1223 = v1223.into_context_iter();
                                                                                            while let Some(v1224) = v1223.next(ctx) {
                                                                                                let v1225 = C::iconst_sextend_etor(ctx, v1224);
                                                                                                if let Some(v1226) = v1225 {
                                                                                                    if v1220.1 == v1226.1 {
                                                                                                        let v995 = constructor_iconst_u(ctx, v2.0, 0x0_u64);
                                                                                                        // Rule at src/opts/icmp.isle line 343.
                                                                                                        returns.extend(Some(v995));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                            if v1103.1 == v1129.1 {
                                                                                let mut v1230 = C::inst_data_value_tupled_etor_returns::default();
                                                                                C::inst_data_value_tupled_etor(ctx, v1103.0, &mut v1230);
                                                                                let mut v1230 = v1230.into_context_iter();
                                                                                while let Some(v1231) = v1230.next(ctx) {
                                                                                    let v1232 = C::iconst_sextend_etor(ctx, v1231);
                                                                                    if let Some(v1233) = v1232 {
                                                                                        let v1244 = C::i64_gt_eq(ctx, v1233.1, 0_i64);
                                                                                        if v1244 == true {
                                                                                            let mut v1236 = C::inst_data_value_tupled_etor_returns::default();
                                                                                            C::inst_data_value_tupled_etor(ctx, v1129.0, &mut v1236);
                                                                                            let mut v1236 = v1236.into_context_iter();
                                                                                            while let Some(v1237) = v1236.next(ctx) {
                                                                                                let v1238 = C::iconst_sextend_etor(ctx, v1237);
                                                                                                if let Some(v1239) = v1238 {
                                                                                                    if v1233.1 == v1239.1 {
                                                                                                        let v995 = constructor_iconst_u(ctx, v2.0, 0x0_u64);
                                                                                                        // Rule at src/opts/icmp.isle line 347.
                                                                                                        returns.extend(Some(v995));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::UnsignedLessThan => {
                                                                        let v608 = C::fits_in_64(ctx, v2.0);
                                                                        if let Some(v609) = v608 {
                                                                            if v11.0 == v609 {
                                                                                let v1103 = C::unpack_value_array_2(ctx, v1101);
                                                                                let v1129 = C::unpack_value_array_2(ctx, v1127);
                                                                                if v1103.0 == v1129.0 {
                                                                                    if v1103.1 == v1129.1 {
                                                                                        let v1216 = constructor_iconst_u(ctx, v609, 0x0_u64);
                                                                                        // Rule at src/opts/icmp.isle line 324.
                                                                                        returns.extend(Some(v1216));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    _ => {}
                                                                }
                                                            }
                                                            &IntCC::UnsignedLessThan => {
                                                                match v1128 {
                                                                    &IntCC::NotEqual => {
                                                                        if v2.0 == v11.0 {
                                                                            let v1103 = C::unpack_value_array_2(ctx, v1101);
                                                                            let v1129 = C::unpack_value_array_2(ctx, v1127);
                                                                            if v1103.0 == v1129.0 {
                                                                                let mut v1223 = C::inst_data_value_tupled_etor_returns::default();
                                                                                C::inst_data_value_tupled_etor(ctx, v1129.1, &mut v1223);
                                                                                let mut v1223 = v1223.into_context_iter();
                                                                                while let Some(v1224) = v1223.next(ctx) {
                                                                                    let v1225 = C::iconst_sextend_etor(ctx, v1224);
                                                                                    if let Some(v1226) = v1225 {
                                                                                        if v1226.1 == -1_i64 {
                                                                                            let v1250 = constructor_ult(ctx, v2.0, v1103.0, v1103.1);
                                                                                            // Rule at src/opts/icmp.isle line 379.
                                                                                            returns.extend(Some(v1250));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                            if v1103.0 == v1129.1 {
                                                                                let mut v1236 = C::inst_data_value_tupled_etor_returns::default();
                                                                                C::inst_data_value_tupled_etor(ctx, v1129.0, &mut v1236);
                                                                                let mut v1236 = v1236.into_context_iter();
                                                                                while let Some(v1237) = v1236.next(ctx) {
                                                                                    let v1238 = C::iconst_sextend_etor(ctx, v1237);
                                                                                    if let Some(v1239) = v1238 {
                                                                                        if v1239.1 == -1_i64 {
                                                                                            let v1250 = constructor_ult(ctx, v2.0, v1103.0, v1103.1);
                                                                                            // Rule at src/opts/icmp.isle line 382.
                                                                                            returns.extend(Some(v1250));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::SignedGreaterThan => {
                                                                        if v2.0 == v11.0 {
                                                                            let v1103 = C::unpack_value_array_2(ctx, v1101);
                                                                            let v1129 = C::unpack_value_array_2(ctx, v1127);
                                                                            if v1103.0 == v1129.0 {
                                                                                let mut v1217 = C::inst_data_value_tupled_etor_returns::default();
                                                                                C::inst_data_value_tupled_etor(ctx, v1103.1, &mut v1217);
                                                                                let mut v1217 = v1217.into_context_iter();
                                                                                while let Some(v1218) = v1217.next(ctx) {
                                                                                    let v1219 = C::iconst_sextend_etor(ctx, v1218);
                                                                                    if let Some(v1220) = v1219 {
                                                                                        let v1229 = C::i64_gt_eq(ctx, v1220.1, 0_i64);
                                                                                        if v1229 == true {
                                                                                            let mut v1223 = C::inst_data_value_tupled_etor_returns::default();
                                                                                            C::inst_data_value_tupled_etor(ctx, v1129.1, &mut v1223);
                                                                                            let mut v1223 = v1223.into_context_iter();
                                                                                            while let Some(v1224) = v1223.next(ctx) {
                                                                                                let v1225 = C::iconst_sextend_etor(ctx, v1224);
                                                                                                if let Some(v1226) = v1225 {
                                                                                                    if v1220.1 == v1226.1 {
                                                                                                        let v995 = constructor_iconst_u(ctx, v2.0, 0x0_u64);
                                                                                                        // Rule at src/opts/icmp.isle line 351.
                                                                                                        returns.extend(Some(v995));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                            if v1103.1 == v1129.1 {
                                                                                let mut v1230 = C::inst_data_value_tupled_etor_returns::default();
                                                                                C::inst_data_value_tupled_etor(ctx, v1103.0, &mut v1230);
                                                                                let mut v1230 = v1230.into_context_iter();
                                                                                while let Some(v1231) = v1230.next(ctx) {
                                                                                    let v1232 = C::iconst_sextend_etor(ctx, v1231);
                                                                                    if let Some(v1233) = v1232 {
                                                                                        let v1242 = C::i64_lt(ctx, v1233.1, 0_i64);
                                                                                        if v1242 == true {
                                                                                            let mut v1236 = C::inst_data_value_tupled_etor_returns::default();
                                                                                            C::inst_data_value_tupled_etor(ctx, v1129.0, &mut v1236);
                                                                                            let mut v1236 = v1236.into_context_iter();
                                                                                            while let Some(v1237) = v1236.next(ctx) {
                                                                                                let v1238 = C::iconst_sextend_etor(ctx, v1237);
                                                                                                if let Some(v1239) = v1238 {
                                                                                                    if v1233.1 == v1239.1 {
                                                                                                        let v995 = constructor_iconst_u(ctx, v2.0, 0x0_u64);
                                                                                                        // Rule at src/opts/icmp.isle line 355.
                                                                                                        returns.extend(Some(v995));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::UnsignedGreaterThan => {
                                                                        let v608 = C::fits_in_64(ctx, v2.0);
                                                                        if let Some(v609) = v608 {
                                                                            if v11.0 == v609 {
                                                                                let v1103 = C::unpack_value_array_2(ctx, v1101);
                                                                                let v1129 = C::unpack_value_array_2(ctx, v1127);
                                                                                if v1103.0 == v1129.0 {
                                                                                    if v1103.1 == v1129.1 {
                                                                                        let v1216 = constructor_iconst_u(ctx, v609, 0x0_u64);
                                                                                        // Rule at src/opts/icmp.isle line 325.
                                                                                        returns.extend(Some(v1216));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    _ => {}
                                                                }
                                                            }
                                                            _ => {}
                                                        }
                                                        let v608 = C::fits_in_64(ctx, v2.0);
                                                        if let Some(v609) = v608 {
                                                            if v11.0 == v609 {
                                                                let v1132 = constructor_intcc_comparable(ctx, v1102, v1128);
                                                                if let Some(v1133) = v1132 {
                                                                    let v1103 = C::unpack_value_array_2(ctx, v1101);
                                                                    let v1129 = C::unpack_value_array_2(ctx, v1127);
                                                                    if v1103.0 == v1129.0 {
                                                                        if v1103.1 == v1129.1 {
                                                                            let v1134 = constructor_decompose_intcc(ctx, v1102);
                                                                            let v1135 = constructor_decompose_intcc(ctx, v1128);
                                                                            let v1136 = C::u64_and(ctx, v1134, v1135);
                                                                            let v1137 = constructor_compose_icmp(ctx, v609, v1136, v1133, v1103.0, v1103.1);
                                                                            // Rule at src/opts/icmp.isle line 182.
                                                                            returns.extend(Some(v1137));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v26,
                                    arg: v27,
                                } => {
                                    match v26 {
                                        &Opcode::Splat => {
                                            let v1539 = C::ty_vector_not_float(ctx, v2.0);
                                            if let Some(v1540) = v1539 {
                                                if v2.0 == v11.0 {
                                                    let mut v18 = C::inst_data_value_etor_returns::default();
                                                    C::inst_data_value_etor(ctx, v7.0, &mut v18);
                                                    let mut v18 = v18.into_context_iter();
                                                    while let Some(v19) = v18.next(ctx) {
                                                        if let &InstructionData::Unary {
                                                            opcode: ref v29,
                                                            arg: v30,
                                                        } = &v19.1 {
                                                            if let &Opcode::Splat = v29 {
                                                                if v2.0 == v19.0 {
                                                                    let v1425 = C::lane_type(ctx, v2.0);
                                                                    let v1541 = constructor_band(ctx, v1425, v30, v27);
                                                                    let v1542 = constructor_splat(ctx, v2.0, v1541);
                                                                    // Rule at src/opts/vector.isle line 14.
                                                                    returns.extend(Some(v1542));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        &Opcode::Bnot => {
                                            let v52 = C::ty_int(ctx, v2.0);
                                            if let Some(v53) = v52 {
                                                if v7.0 == v27 {
                                                    if v11.0 == v53 {
                                                        let v55 = constructor_iconst_u(ctx, v53, 0x0_u64);
                                                        let v56 = C::subsume(ctx, v55);
                                                        // Rule at src/opts/bitops.isle line 34.
                                                        returns.extend(Some(v56));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                        }
                                        &Opcode::Uextend => {
                                            let mut v18 = C::inst_data_value_etor_returns::default();
                                            C::inst_data_value_etor(ctx, v7.0, &mut v18);
                                            let mut v18 = v18.into_context_iter();
                                            while let Some(v19) = v18.next(ctx) {
                                                if let &InstructionData::Unary {
                                                    opcode: ref v29,
                                                    arg: v30,
                                                } = &v19.1 {
                                                    if let &Opcode::Uextend = v29 {
                                                        let v986 = C::value_type(ctx, v30);
                                                        let v1021 = C::value_type(ctx, v27);
                                                        if v986 == v1021 {
                                                            let v1022 = constructor_band(ctx, v986, v30, v27);
                                                            let v1023 = constructor_uextend(ctx, v2.0, v1022);
                                                            // Rule at src/opts/extends.isle line 70.
                                                            returns.extend(Some(v1023));
                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        _ => {}
                                    }
                                }
                                &InstructionData::UnaryImm {
                                    opcode: ref v14,
                                    imm: v15,
                                } => {
                                    if let &Opcode::Iconst = v14 {
                                        let mut v18 = C::inst_data_value_etor_returns::default();
                                        C::inst_data_value_etor(ctx, v7.0, &mut v18);
                                        let mut v18 = v18.into_context_iter();
                                        while let Some(v19) = v18.next(ctx) {
                                            match &v19.1 {
                                                &InstructionData::Binary {
                                                    opcode: ref v104,
                                                    args: ref v105,
                                                } => {
                                                    if let &Opcode::Band = v104 {
                                                        if v2.0 == v11.0 {
                                                            if v2.0 == v19.0 {
                                                                let v106 = C::unpack_value_array_2(ctx, v105);
                                                                let mut v116 = C::inst_data_value_etor_returns::default();
                                                                C::inst_data_value_etor(ctx, v106.1, &mut v116);
                                                                let mut v116 = v116.into_context_iter();
                                                                while let Some(v117) = v116.next(ctx) {
                                                                    if let &InstructionData::UnaryImm {
                                                                        opcode: ref v258,
                                                                        imm: v259,
                                                                    } = &v117.1 {
                                                                        if let &Opcode::Iconst = v258 {
                                                                            if v2.0 == v117.0 {
                                                                                let v709 = constructor_band(ctx, v2.0, v106.1, v7.1);
                                                                                let v710 = constructor_band(ctx, v2.0, v106.0, v709);
                                                                                // Rule at src/opts/cprop.isle line 183.
                                                                                returns.extend(Some(v710));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                &InstructionData::IntCompare {
                                                    opcode: ref v1100,
                                                    args: ref v1101,
                                                    cond: ref v1102,
                                                } => {
                                                    if let &Opcode::Icmp = v1100 {
                                                        let v16 = C::u64_from_imm64(ctx, v15);
                                                        if v16 == 0x1_u64 {
                                                            let v52 = C::ty_int(ctx, v2.0);
                                                            if let Some(v53) = v52 {
                                                                // Rule at src/opts/icmp.isle line 93.
                                                                returns.extend(Some(v7.0));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                                &InstructionData::Unary {
                                                    opcode: ref v29,
                                                    arg: v30,
                                                } => {
                                                    match v29 {
                                                        &Opcode::Uextend => {
                                                            let v16 = C::u64_from_imm64(ctx, v15);
                                                            if v16 == 0x1_u64 {
                                                                let v52 = C::ty_int(ctx, v2.0);
                                                                if let Some(v53) = v52 {
                                                                    let mut v588 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v30, &mut v588);
                                                                    let mut v588 = v588.into_context_iter();
                                                                    while let Some(v589) = v588.next(ctx) {
                                                                        if let &InstructionData::IntCompare {
                                                                            opcode: ref v1106,
                                                                            args: ref v1107,
                                                                            cond: ref v1108,
                                                                        } = &v589.1 {
                                                                            if let &Opcode::Icmp = v1106 {
                                                                                // Rule at src/opts/icmp.isle line 98.
                                                                                returns.extend(Some(v7.0));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            let v986 = C::value_type(ctx, v30);
                                                            let v987 = C::ty_mask(ctx, v986);
                                                            let v988 = C::u64_and(ctx, v16, v987);
                                                            let v989 = C::u64_eq(ctx, v987, v988);
                                                            if v989 == true {
                                                                // Rule at src/opts/extends.isle line 16.
                                                                returns.extend(Some(v7.0));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                        &Opcode::Sextend => {
                                                            let v16 = C::u64_from_imm64(ctx, v15);
                                                            let v986 = C::value_type(ctx, v30);
                                                            let v987 = C::ty_mask(ctx, v986);
                                                            let v990 = C::u64_eq(ctx, v16, v987);
                                                            if v990 == true {
                                                                let v991 = constructor_uextend(ctx, v2.0, v30);
                                                                // Rule at src/opts/extends.isle line 22.
                                                                returns.extend(Some(v991));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                &InstructionData::UnaryImm {
                                                    opcode: ref v22,
                                                    imm: v23,
                                                } => {
                                                    if let &Opcode::Iconst = v22 {
                                                        let v608 = C::fits_in_64(ctx, v2.0);
                                                        if let Some(v609) = v608 {
                                                            if v11.0 == v19.0 {
                                                                if v11.0 == v609 {
                                                                    let v24 = C::u64_from_imm64(ctx, v23);
                                                                    let v16 = C::u64_from_imm64(ctx, v15);
                                                                    let v634 = C::u64_and(ctx, v24, v16);
                                                                    let v635 = C::imm64_masked(ctx, v609, v634);
                                                                    let v636 = constructor_iconst(ctx, v609, v635);
                                                                    let v637 = C::subsume(ctx, v636);
                                                                    // Rule at src/opts/cprop.isle line 61.
                                                                    returns.extend(Some(v637));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                _ => {}
                                            }
                                        }
                                        let v16 = C::u64_from_imm64(ctx, v15);
                                        if v16 == 0x0_u64 {
                                            if v2.0 == v11.0 {
                                                let v57 = C::subsume(ctx, v7.1);
                                                // Rule at src/opts/bitops.isle line 33.
                                                returns.extend(Some(v57));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                        let v1270 = C::remat(ctx, arg0);
                                        // Rule at src/opts/remat.isle line 13.
                                        returns.extend(Some(v1270));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                                _ => {}
                            }
                        }
                        let mut v18 = C::inst_data_value_etor_returns::default();
                        C::inst_data_value_etor(ctx, v7.0, &mut v18);
                        let mut v18 = v18.into_context_iter();
                        while let Some(v19) = v18.next(ctx) {
                            match &v19.1 {
                                &InstructionData::Binary {
                                    opcode: ref v104,
                                    args: ref v105,
                                } => {
                                    match v104 {
                                        &Opcode::Band => {
                                            if v2.0 == v19.0 {
                                                let v106 = C::unpack_value_array_2(ctx, v105);
                                                if v7.1 == v106.0 {
                                                    let v152 = constructor_band(ctx, v2.0, v106.0, v106.1);
                                                    // Rule at src/opts/bitops.isle line 192.
                                                    returns.extend(Some(v152));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v7.1 == v106.1 {
                                                    let v152 = constructor_band(ctx, v2.0, v106.0, v106.1);
                                                    // Rule at src/opts/bitops.isle line 193.
                                                    returns.extend(Some(v152));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                        &Opcode::Bxor => {
                                            if v2.0 == v19.0 {
                                                let v106 = C::unpack_value_array_2(ctx, v105);
                                                if v7.1 == v106.0 {
                                                    let mut v116 = C::inst_data_value_etor_returns::default();
                                                    C::inst_data_value_etor(ctx, v106.1, &mut v116);
                                                    let mut v116 = v116.into_context_iter();
                                                    while let Some(v117) = v116.next(ctx) {
                                                        if let &InstructionData::Unary {
                                                            opcode: ref v120,
                                                            arg: v121,
                                                        } = &v117.1 {
                                                            if let &Opcode::Bnot = v120 {
                                                                if v2.0 == v117.0 {
                                                                    let v563 = constructor_band(ctx, v2.0, v106.0, v121);
                                                                    // Rule at src/opts/bitops.isle line 198.
                                                                    returns.extend(Some(v563));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                if v7.1 == v106.1 {
                                                    let mut v109 = C::inst_data_value_etor_returns::default();
                                                    C::inst_data_value_etor(ctx, v106.0, &mut v109);
                                                    let mut v109 = v109.into_context_iter();
                                                    while let Some(v110) = v109.next(ctx) {
                                                        if let &InstructionData::Unary {
                                                            opcode: ref v113,
                                                            arg: v114,
                                                        } = &v110.1 {
                                                            if let &Opcode::Bnot = v113 {
                                                                if v2.0 == v110.0 {
                                                                    let v564 = constructor_band(ctx, v2.0, v106.1, v114);
                                                                    // Rule at src/opts/bitops.isle line 199.
                                                                    returns.extend(Some(v564));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        _ => {}
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v29,
                                    arg: v30,
                                } => {
                                    if let &Opcode::Bnot = v29 {
                                        if v7.1 == v30 {
                                            let v52 = C::ty_int(ctx, v2.0);
                                            if let Some(v53) = v52 {
                                                if v19.0 == v53 {
                                                    let v55 = constructor_iconst_u(ctx, v53, 0x0_u64);
                                                    let v56 = C::subsume(ctx, v55);
                                                    // Rule at src/opts/bitops.isle line 35.
                                                    returns.extend(Some(v56));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::UnaryImm {
                                    opcode: ref v22,
                                    imm: v23,
                                } => {
                                    if let &Opcode::Iconst = v22 {
                                        if v2.0 == v19.0 {
                                            let v679 = constructor_band(ctx, v2.0, v7.1, v7.0);
                                            // Rule at src/opts/cprop.isle line 130.
                                            returns.extend(Some(v679));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        let v1270 = C::remat(ctx, arg0);
                                        // Rule at src/opts/remat.isle line 11.
                                        returns.extend(Some(v1270));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                                _ => {}
                            }
                        }
                        if v7.0 == v7.1 {
                            let v17 = C::subsume(ctx, v7.0);
                            // Rule at src/opts/bitops.isle line 28.
                            returns.extend(Some(v17));
                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                        }
                        let mut v58 = C::inst_data_value_tupled_etor_returns::default();
                        C::inst_data_value_tupled_etor(ctx, v7.1, &mut v58);
                        let mut v58 = v58.into_context_iter();
                        while let Some(v59) = v58.next(ctx) {
                            let v60 = C::iconst_sextend_etor(ctx, v59);
                            if let Some(v61) = v60 {
                                if v61.1 == -1_i64 {
                                    if v2.0 == v61.0 {
                                        let v17 = C::subsume(ctx, v7.0);
                                        // Rule at src/opts/bitops.isle line 29.
                                        returns.extend(Some(v17));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                            }
                        }
                    }
                    &Opcode::Bor => {
                        let v7 = C::unpack_value_array_2(ctx, v6);
                        let mut v10 = C::inst_data_value_etor_returns::default();
                        C::inst_data_value_etor(ctx, v7.1, &mut v10);
                        let mut v10 = v10.into_context_iter();
                        while let Some(v11) = v10.next(ctx) {
                            match &v11.1 {
                                &InstructionData::Binary {
                                    opcode: ref v147,
                                    args: ref v148,
                                } => {
                                    match v147 {
                                        &Opcode::Band => {
                                            let mut v18 = C::inst_data_value_etor_returns::default();
                                            C::inst_data_value_etor(ctx, v7.0, &mut v18);
                                            let mut v18 = v18.into_context_iter();
                                            while let Some(v19) = v18.next(ctx) {
                                                match &v19.1 {
                                                    &InstructionData::Binary {
                                                        opcode: ref v104,
                                                        args: ref v105,
                                                    } => {
                                                        if let &Opcode::Band = v104 {
                                                            let v737 = C::ty_vec128(ctx, v2.0);
                                                            if let Some(v738) = v737 {
                                                                if v11.0 == v19.0 {
                                                                    if v11.0 == v738 {
                                                                        let v106 = C::unpack_value_array_2(ctx, v105);
                                                                        let mut v109 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v106.0, &mut v109);
                                                                        let mut v109 = v109.into_context_iter();
                                                                        while let Some(v110) = v109.next(ctx) {
                                                                            if let &InstructionData::Unary {
                                                                                opcode: ref v113,
                                                                                arg: v114,
                                                                            } = &v110.1 {
                                                                                if let &Opcode::Bnot = v113 {
                                                                                    if v11.0 == v110.0 {
                                                                                        let v149 = C::unpack_value_array_2(ctx, v148);
                                                                                        if v114 == v149.0 {
                                                                                            let v1314 = constructor_bitselect(ctx, v738, v114, v149.1, v106.1);
                                                                                            // Rule at src/opts/selects.isle line 73.
                                                                                            returns.extend(Some(v1314));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                        if v114 == v149.1 {
                                                                                            let v1315 = constructor_bitselect(ctx, v738, v114, v149.0, v106.1);
                                                                                            // Rule at src/opts/selects.isle line 74.
                                                                                            returns.extend(Some(v1315));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                        let mut v116 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v106.1, &mut v116);
                                                                        let mut v116 = v116.into_context_iter();
                                                                        while let Some(v117) = v116.next(ctx) {
                                                                            if let &InstructionData::Unary {
                                                                                opcode: ref v120,
                                                                                arg: v121,
                                                                            } = &v117.1 {
                                                                                if let &Opcode::Bnot = v120 {
                                                                                    if v11.0 == v117.0 {
                                                                                        let v149 = C::unpack_value_array_2(ctx, v148);
                                                                                        if v121 == v149.0 {
                                                                                            let v1316 = constructor_bitselect(ctx, v738, v121, v149.1, v106.0);
                                                                                            // Rule at src/opts/selects.isle line 75.
                                                                                            returns.extend(Some(v1316));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                        if v121 == v149.1 {
                                                                                            let v1317 = constructor_bitselect(ctx, v738, v121, v149.0, v106.0);
                                                                                            // Rule at src/opts/selects.isle line 76.
                                                                                            returns.extend(Some(v1317));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                        let v149 = C::unpack_value_array_2(ctx, v148);
                                                                        let mut v333 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v149.0, &mut v333);
                                                                        let mut v333 = v333.into_context_iter();
                                                                        while let Some(v334) = v333.next(ctx) {
                                                                            if let &InstructionData::Unary {
                                                                                opcode: ref v568,
                                                                                arg: v569,
                                                                            } = &v334.1 {
                                                                                if let &Opcode::Bnot = v568 {
                                                                                    if v11.0 == v334.0 {
                                                                                        if v106.0 == v569 {
                                                                                            let v1310 = constructor_bitselect(ctx, v738, v106.0, v106.1, v149.1);
                                                                                            // Rule at src/opts/selects.isle line 69.
                                                                                            returns.extend(Some(v1310));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                        if v106.1 == v569 {
                                                                                            let v1312 = constructor_bitselect(ctx, v738, v106.1, v106.0, v149.1);
                                                                                            // Rule at src/opts/selects.isle line 71.
                                                                                            returns.extend(Some(v1312));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                        let mut v365 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v149.1, &mut v365);
                                                                        let mut v365 = v365.into_context_iter();
                                                                        while let Some(v366) = v365.next(ctx) {
                                                                            if let &InstructionData::Unary {
                                                                                opcode: ref v565,
                                                                                arg: v566,
                                                                            } = &v366.1 {
                                                                                if let &Opcode::Bnot = v565 {
                                                                                    if v11.0 == v366.0 {
                                                                                        if v106.0 == v566 {
                                                                                            let v1311 = constructor_bitselect(ctx, v738, v106.0, v106.1, v149.0);
                                                                                            // Rule at src/opts/selects.isle line 70.
                                                                                            returns.extend(Some(v1311));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                        if v106.1 == v566 {
                                                                                            let v1313 = constructor_bitselect(ctx, v738, v106.1, v106.0, v149.0);
                                                                                            // Rule at src/opts/selects.isle line 72.
                                                                                            returns.extend(Some(v1313));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                    &InstructionData::Unary {
                                                        opcode: ref v29,
                                                        arg: v30,
                                                    } => {
                                                        if let &Opcode::Bnot = v29 {
                                                            if v2.0 == v11.0 {
                                                                if v2.0 == v19.0 {
                                                                    let mut v588 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v30, &mut v588);
                                                                    let mut v588 = v588.into_context_iter();
                                                                    while let Some(v589) = v588.next(ctx) {
                                                                        if let &InstructionData::Binary {
                                                                            opcode: ref v592,
                                                                            args: ref v593,
                                                                        } = &v589.1 {
                                                                            if let &Opcode::Bxor = v592 {
                                                                                if v2.0 == v589.0 {
                                                                                    let v149 = C::unpack_value_array_2(ctx, v148);
                                                                                    let v594 = C::unpack_value_array_2(ctx, v593);
                                                                                    if v149.0 == v594.0 {
                                                                                        if v149.1 == v594.1 {
                                                                                            let v597 = constructor_bxor(ctx, v2.0, v594.0, v594.1);
                                                                                            let v598 = constructor_bnot(ctx, v2.0, v597);
                                                                                            // Rule at src/opts/bitops.isle line 230.
                                                                                            returns.extend(Some(v598));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            let v599 = constructor_bxor(ctx, v2.0, v594.1, v594.0);
                                                                                            let v600 = constructor_bnot(ctx, v2.0, v599);
                                                                                            // Rule at src/opts/bitops.isle line 236.
                                                                                            returns.extend(Some(v600));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                    if v149.0 == v594.1 {
                                                                                        if v149.1 == v594.0 {
                                                                                            let v599 = constructor_bxor(ctx, v2.0, v594.1, v594.0);
                                                                                            let v600 = constructor_bnot(ctx, v2.0, v599);
                                                                                            // Rule at src/opts/bitops.isle line 232.
                                                                                            returns.extend(Some(v600));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            let v597 = constructor_bxor(ctx, v2.0, v594.0, v594.1);
                                                                                            let v598 = constructor_bnot(ctx, v2.0, v597);
                                                                                            // Rule at src/opts/bitops.isle line 234.
                                                                                            returns.extend(Some(v598));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    let v149 = C::unpack_value_array_2(ctx, v148);
                                                                    if v30 == v149.0 {
                                                                        let v574 = constructor_bnot(ctx, v2.0, v30);
                                                                        let v575 = constructor_bor(ctx, v2.0, v149.1, v574);
                                                                        // Rule at src/opts/bitops.isle line 221.
                                                                        returns.extend(Some(v575));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                    if v30 == v149.1 {
                                                                        let v257 = constructor_bor(ctx, v2.0, v149.0, v7.0);
                                                                        // Rule at src/opts/bitops.isle line 53.
                                                                        returns.extend(Some(v257));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                    _ => {}
                                                }
                                            }
                                            if v2.0 == v11.0 {
                                                let v149 = C::unpack_value_array_2(ctx, v148);
                                                if v7.0 == v149.0 {
                                                    // Rule at src/opts/bitops.isle line 213.
                                                    returns.extend(Some(v7.0));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                        &Opcode::Bor => {
                                            if v2.0 == v11.0 {
                                                let v149 = C::unpack_value_array_2(ctx, v148);
                                                if v7.0 == v149.0 {
                                                    let v560 = constructor_bor(ctx, v2.0, v7.0, v149.1);
                                                    // Rule at src/opts/bitops.isle line 189.
                                                    returns.extend(Some(v560));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v7.0 == v149.1 {
                                                    let v257 = constructor_bor(ctx, v2.0, v149.0, v7.0);
                                                    // Rule at src/opts/bitops.isle line 190.
                                                    returns.extend(Some(v257));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                let mut v18 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v7.0, &mut v18);
                                                let mut v18 = v18.into_context_iter();
                                                while let Some(v19) = v18.next(ctx) {
                                                    if let &InstructionData::Binary {
                                                        opcode: ref v104,
                                                        args: ref v105,
                                                    } = &v19.1 {
                                                        if let &Opcode::Bor = v104 {
                                                            if v2.0 == v19.0 {
                                                                let v106 = C::unpack_value_array_2(ctx, v105);
                                                                let mut v116 = C::inst_data_value_etor_returns::default();
                                                                C::inst_data_value_etor(ctx, v106.1, &mut v116);
                                                                let mut v116 = v116.into_context_iter();
                                                                while let Some(v117) = v116.next(ctx) {
                                                                    if let &InstructionData::UnaryImm {
                                                                        opcode: ref v258,
                                                                        imm: v259,
                                                                    } = &v117.1 {
                                                                        if let &Opcode::Iconst = v258 {
                                                                            let mut v365 = C::inst_data_value_etor_returns::default();
                                                                            C::inst_data_value_etor(ctx, v149.1, &mut v365);
                                                                            let mut v365 = v365.into_context_iter();
                                                                            while let Some(v366) = v365.next(ctx) {
                                                                                if let &InstructionData::UnaryImm {
                                                                                    opcode: ref v771,
                                                                                    imm: v772,
                                                                                } = &v366.1 {
                                                                                    if let &Opcode::Iconst = v771 {
                                                                                        let v782 = constructor_bor(ctx, v2.0, v106.0, v149.0);
                                                                                        let v783 = constructor_bor(ctx, v2.0, v106.1, v149.1);
                                                                                        let v784 = constructor_bor(ctx, v2.0, v782, v783);
                                                                                        // Rule at src/opts/cprop.isle line 276.
                                                                                        returns.extend(Some(v784));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                            match v2.0 {
                                                I32 => {
                                                    if v11.0 == I32 {
                                                        let mut v18 = C::inst_data_value_etor_returns::default();
                                                        C::inst_data_value_etor(ctx, v7.0, &mut v18);
                                                        let mut v18 = v18.into_context_iter();
                                                        while let Some(v19) = v18.next(ctx) {
                                                            if v19.0 == I32 {
                                                                if let &InstructionData::Binary {
                                                                    opcode: ref v104,
                                                                    args: ref v105,
                                                                } = &v19.1 {
                                                                    if let &Opcode::Bor = v104 {
                                                                        let v106 = C::unpack_value_array_2(ctx, v105);
                                                                        let mut v109 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v106.0, &mut v109);
                                                                        let mut v109 = v109.into_context_iter();
                                                                        while let Some(v110) = v109.next(ctx) {
                                                                            if v110.0 == I32 {
                                                                                if let &InstructionData::Binary {
                                                                                    opcode: ref v293,
                                                                                    args: ref v294,
                                                                                } = &v110.1 {
                                                                                    if let &Opcode::Ishl = v293 {
                                                                                        let mut v116 = C::inst_data_value_etor_returns::default();
                                                                                        C::inst_data_value_etor(ctx, v106.1, &mut v116);
                                                                                        let mut v116 = v116.into_context_iter();
                                                                                        while let Some(v117) = v116.next(ctx) {
                                                                                            if v117.0 == I32 {
                                                                                                if let &InstructionData::Binary {
                                                                                                    opcode: ref v305,
                                                                                                    args: ref v306,
                                                                                                } = &v117.1 {
                                                                                                    if let &Opcode::Ishl = v305 {
                                                                                                        let v295 = C::unpack_value_array_2(ctx, v294);
                                                                                                        let mut v298 = C::inst_data_value_etor_returns::default();
                                                                                                        C::inst_data_value_etor(ctx, v295.1, &mut v298);
                                                                                                        let mut v298 = v298.into_context_iter();
                                                                                                        while let Some(v299) = v298.next(ctx) {
                                                                                                            if v299.0 == I32 {
                                                                                                                if let &InstructionData::UnaryImm {
                                                                                                                    opcode: ref v302,
                                                                                                                    imm: v303,
                                                                                                                } = &v299.1 {
                                                                                                                    if let &Opcode::Iconst = v302 {
                                                                                                                        let v304 = C::u64_from_imm64(ctx, v303);
                                                                                                                        if v304 == 0x18_u64 {
                                                                                                                            let v307 = C::unpack_value_array_2(ctx, v306);
                                                                                                                            let mut v310 = C::inst_data_value_etor_returns::default();
                                                                                                                            C::inst_data_value_etor(ctx, v307.0, &mut v310);
                                                                                                                            let mut v310 = v310.into_context_iter();
                                                                                                                            while let Some(v311) = v310.next(ctx) {
                                                                                                                                if v311.0 == I32 {
                                                                                                                                    if let &InstructionData::Binary {
                                                                                                                                        opcode: ref v314,
                                                                                                                                        args: ref v315,
                                                                                                                                    } = &v311.1 {
                                                                                                                                        if let &Opcode::Band = v314 {
                                                                                                                                            let v316 = C::unpack_value_array_2(ctx, v315);
                                                                                                                                            if v295.0 == v316.0 {
                                                                                                                                                let mut v319 = C::inst_data_value_etor_returns::default();
                                                                                                                                                C::inst_data_value_etor(ctx, v316.1, &mut v319);
                                                                                                                                                let mut v319 = v319.into_context_iter();
                                                                                                                                                while let Some(v320) = v319.next(ctx) {
                                                                                                                                                    if v320.0 == I32 {
                                                                                                                                                        if let &InstructionData::UnaryImm {
                                                                                                                                                            opcode: ref v323,
                                                                                                                                                            imm: v324,
                                                                                                                                                        } = &v320.1 {
                                                                                                                                                            if let &Opcode::Iconst = v323 {
                                                                                                                                                                let v325 = C::u64_from_imm64(ctx, v324);
                                                                                                                                                                if v325 == 0xff00_u64 {
                                                                                                                                                                    let mut v326 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                    C::inst_data_value_etor(ctx, v307.1, &mut v326);
                                                                                                                                                                    let mut v326 = v326.into_context_iter();
                                                                                                                                                                    while let Some(v327) = v326.next(ctx) {
                                                                                                                                                                        if v327.0 == I32 {
                                                                                                                                                                            if let &InstructionData::UnaryImm {
                                                                                                                                                                                opcode: ref v330,
                                                                                                                                                                                imm: v331,
                                                                                                                                                                            } = &v327.1 {
                                                                                                                                                                                if let &Opcode::Iconst = v330 {
                                                                                                                                                                                    let v332 = C::u64_from_imm64(ctx, v331);
                                                                                                                                                                                    if v332 == 0x8_u64 {
                                                                                                                                                                                        let v149 = C::unpack_value_array_2(ctx, v148);
                                                                                                                                                                                        let mut v333 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                        C::inst_data_value_etor(ctx, v149.0, &mut v333);
                                                                                                                                                                                        let mut v333 = v333.into_context_iter();
                                                                                                                                                                                        while let Some(v334) = v333.next(ctx) {
                                                                                                                                                                                            if v334.0 == I32 {
                                                                                                                                                                                                if let &InstructionData::Binary {
                                                                                                                                                                                                    opcode: ref v337,
                                                                                                                                                                                                    args: ref v338,
                                                                                                                                                                                                } = &v334.1 {
                                                                                                                                                                                                    if let &Opcode::Band = v337 {
                                                                                                                                                                                                        let v339 = C::unpack_value_array_2(ctx, v338);
                                                                                                                                                                                                        let mut v342 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                        C::inst_data_value_etor(ctx, v339.0, &mut v342);
                                                                                                                                                                                                        let mut v342 = v342.into_context_iter();
                                                                                                                                                                                                        while let Some(v343) = v342.next(ctx) {
                                                                                                                                                                                                            if v343.0 == I32 {
                                                                                                                                                                                                                if let &InstructionData::Binary {
                                                                                                                                                                                                                    opcode: ref v346,
                                                                                                                                                                                                                    args: ref v347,
                                                                                                                                                                                                                } = &v343.1 {
                                                                                                                                                                                                                    if let &Opcode::Ushr = v346 {
                                                                                                                                                                                                                        let v348 = C::unpack_value_array_2(ctx, v347);
                                                                                                                                                                                                                        if v295.0 == v348.0 {
                                                                                                                                                                                                                            let mut v351 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                            C::inst_data_value_etor(ctx, v348.1, &mut v351);
                                                                                                                                                                                                                            let mut v351 = v351.into_context_iter();
                                                                                                                                                                                                                            while let Some(v352) = v351.next(ctx) {
                                                                                                                                                                                                                                if v352.0 == I32 {
                                                                                                                                                                                                                                    if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                                        opcode: ref v355,
                                                                                                                                                                                                                                        imm: v356,
                                                                                                                                                                                                                                    } = &v352.1 {
                                                                                                                                                                                                                                        if let &Opcode::Iconst = v355 {
                                                                                                                                                                                                                                            let v357 = C::u64_from_imm64(ctx, v356);
                                                                                                                                                                                                                                            if v357 == 0x8_u64 {
                                                                                                                                                                                                                                                let mut v358 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                C::inst_data_value_etor(ctx, v339.1, &mut v358);
                                                                                                                                                                                                                                                let mut v358 = v358.into_context_iter();
                                                                                                                                                                                                                                                while let Some(v359) = v358.next(ctx) {
                                                                                                                                                                                                                                                    if v359.0 == I32 {
                                                                                                                                                                                                                                                        if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                                                            opcode: ref v362,
                                                                                                                                                                                                                                                            imm: v363,
                                                                                                                                                                                                                                                        } = &v359.1 {
                                                                                                                                                                                                                                                            if let &Opcode::Iconst = v362 {
                                                                                                                                                                                                                                                                let v364 = C::u64_from_imm64(ctx, v363);
                                                                                                                                                                                                                                                                if v364 == 0xff00_u64 {
                                                                                                                                                                                                                                                                    let mut v365 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                    C::inst_data_value_etor(ctx, v149.1, &mut v365);
                                                                                                                                                                                                                                                                    let mut v365 = v365.into_context_iter();
                                                                                                                                                                                                                                                                    while let Some(v366) = v365.next(ctx) {
                                                                                                                                                                                                                                                                        if v366.0 == I32 {
                                                                                                                                                                                                                                                                            if let &InstructionData::Binary {
                                                                                                                                                                                                                                                                                opcode: ref v369,
                                                                                                                                                                                                                                                                                args: ref v370,
                                                                                                                                                                                                                                                                            } = &v366.1 {
                                                                                                                                                                                                                                                                                if let &Opcode::Ushr = v369 {
                                                                                                                                                                                                                                                                                    let v371 = C::unpack_value_array_2(ctx, v370);
                                                                                                                                                                                                                                                                                    if v295.0 == v371.0 {
                                                                                                                                                                                                                                                                                        let mut v374 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                        C::inst_data_value_etor(ctx, v371.1, &mut v374);
                                                                                                                                                                                                                                                                                        let mut v374 = v374.into_context_iter();
                                                                                                                                                                                                                                                                                        while let Some(v375) = v374.next(ctx) {
                                                                                                                                                                                                                                                                                            if v375.0 == I32 {
                                                                                                                                                                                                                                                                                                if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                                                                                                    opcode: ref v378,
                                                                                                                                                                                                                                                                                                    imm: v379,
                                                                                                                                                                                                                                                                                                } = &v375.1 {
                                                                                                                                                                                                                                                                                                    if let &Opcode::Iconst = v378 {
                                                                                                                                                                                                                                                                                                        let v380 = C::u64_from_imm64(ctx, v379);
                                                                                                                                                                                                                                                                                                        if v380 == 0x18_u64 {
                                                                                                                                                                                                                                                                                                            let v381 = constructor_bswap(ctx, v2.0, v295.0);
                                                                                                                                                                                                                                                                                                            // Rule at src/opts/bitops.isle line 142.
                                                                                                                                                                                                                                                                                                            returns.extend(Some(v381));
                                                                                                                                                                                                                                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                }
                                                                                                                                                                                                                            }
                                                                                                                                                                                                                        }
                                                                                                                                                                                                                    }
                                                                                                                                                                                                                }
                                                                                                                                                                                                            }
                                                                                                                                                                                                        }
                                                                                                                                                                                                    }
                                                                                                                                                                                                }
                                                                                                                                                                                            }
                                                                                                                                                                                        }
                                                                                                                                                                                    }
                                                                                                                                                                                }
                                                                                                                                                                            }
                                                                                                                                                                        }
                                                                                                                                                                    }
                                                                                                                                                                }
                                                                                                                                                            }
                                                                                                                                                        }
                                                                                                                                                    }
                                                                                                                                                }
                                                                                                                                            }
                                                                                                                                        }
                                                                                                                                    }
                                                                                                                                }
                                                                                                                            }
                                                                                                                        }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                I64 => {
                                                    if v11.0 == I64 {
                                                        let mut v18 = C::inst_data_value_etor_returns::default();
                                                        C::inst_data_value_etor(ctx, v7.0, &mut v18);
                                                        let mut v18 = v18.into_context_iter();
                                                        while let Some(v19) = v18.next(ctx) {
                                                            if v19.0 == I64 {
                                                                if let &InstructionData::Binary {
                                                                    opcode: ref v104,
                                                                    args: ref v105,
                                                                } = &v19.1 {
                                                                    if let &Opcode::Bor = v104 {
                                                                        let v106 = C::unpack_value_array_2(ctx, v105);
                                                                        let mut v109 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v106.0, &mut v109);
                                                                        let mut v109 = v109.into_context_iter();
                                                                        while let Some(v110) = v109.next(ctx) {
                                                                            if v110.0 == I64 {
                                                                                if let &InstructionData::Binary {
                                                                                    opcode: ref v293,
                                                                                    args: ref v294,
                                                                                } = &v110.1 {
                                                                                    if let &Opcode::Bor = v293 {
                                                                                        let mut v116 = C::inst_data_value_etor_returns::default();
                                                                                        C::inst_data_value_etor(ctx, v106.1, &mut v116);
                                                                                        let mut v116 = v116.into_context_iter();
                                                                                        while let Some(v117) = v116.next(ctx) {
                                                                                            if v117.0 == I64 {
                                                                                                if let &InstructionData::Binary {
                                                                                                    opcode: ref v305,
                                                                                                    args: ref v306,
                                                                                                } = &v117.1 {
                                                                                                    if let &Opcode::Bor = v305 {
                                                                                                        let v295 = C::unpack_value_array_2(ctx, v294);
                                                                                                        let mut v298 = C::inst_data_value_etor_returns::default();
                                                                                                        C::inst_data_value_etor(ctx, v295.1, &mut v298);
                                                                                                        let mut v298 = v298.into_context_iter();
                                                                                                        while let Some(v299) = v298.next(ctx) {
                                                                                                            if v299.0 == I64 {
                                                                                                                if let &InstructionData::Binary {
                                                                                                                    opcode: ref v398,
                                                                                                                    args: ref v399,
                                                                                                                } = &v299.1 {
                                                                                                                    if let &Opcode::Ishl = v398 {
                                                                                                                        let v307 = C::unpack_value_array_2(ctx, v306);
                                                                                                                        let mut v310 = C::inst_data_value_etor_returns::default();
                                                                                                                        C::inst_data_value_etor(ctx, v307.0, &mut v310);
                                                                                                                        let mut v310 = v310.into_context_iter();
                                                                                                                        while let Some(v311) = v310.next(ctx) {
                                                                                                                            if v311.0 == I64 {
                                                                                                                                if let &InstructionData::Binary {
                                                                                                                                    opcode: ref v314,
                                                                                                                                    args: ref v315,
                                                                                                                                } = &v311.1 {
                                                                                                                                    if let &Opcode::Ishl = v314 {
                                                                                                                                        let v316 = C::unpack_value_array_2(ctx, v315);
                                                                                                                                        let mut v319 = C::inst_data_value_etor_returns::default();
                                                                                                                                        C::inst_data_value_etor(ctx, v316.1, &mut v319);
                                                                                                                                        let mut v319 = v319.into_context_iter();
                                                                                                                                        while let Some(v320) = v319.next(ctx) {
                                                                                                                                            if v320.0 == I64 {
                                                                                                                                                if let &InstructionData::UnaryImm {
                                                                                                                                                    opcode: ref v323,
                                                                                                                                                    imm: v324,
                                                                                                                                                } = &v320.1 {
                                                                                                                                                    if let &Opcode::Iconst = v323 {
                                                                                                                                                        let v325 = C::u64_from_imm64(ctx, v324);
                                                                                                                                                        if v325 == 0x18_u64 {
                                                                                                                                                            let mut v326 = C::inst_data_value_etor_returns::default();
                                                                                                                                                            C::inst_data_value_etor(ctx, v307.1, &mut v326);
                                                                                                                                                            let mut v326 = v326.into_context_iter();
                                                                                                                                                            while let Some(v327) = v326.next(ctx) {
                                                                                                                                                                if v327.0 == I64 {
                                                                                                                                                                    if let &InstructionData::Binary {
                                                                                                                                                                        opcode: ref v442,
                                                                                                                                                                        args: ref v443,
                                                                                                                                                                    } = &v327.1 {
                                                                                                                                                                        if let &Opcode::Ishl = v442 {
                                                                                                                                                                            let v149 = C::unpack_value_array_2(ctx, v148);
                                                                                                                                                                            let mut v333 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                            C::inst_data_value_etor(ctx, v149.0, &mut v333);
                                                                                                                                                                            let mut v333 = v333.into_context_iter();
                                                                                                                                                                            while let Some(v334) = v333.next(ctx) {
                                                                                                                                                                                if v334.0 == I64 {
                                                                                                                                                                                    if let &InstructionData::Binary {
                                                                                                                                                                                        opcode: ref v337,
                                                                                                                                                                                        args: ref v338,
                                                                                                                                                                                    } = &v334.1 {
                                                                                                                                                                                        if let &Opcode::Bor = v337 {
                                                                                                                                                                                            let v339 = C::unpack_value_array_2(ctx, v338);
                                                                                                                                                                                            let mut v342 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                            C::inst_data_value_etor(ctx, v339.0, &mut v342);
                                                                                                                                                                                            let mut v342 = v342.into_context_iter();
                                                                                                                                                                                            while let Some(v343) = v342.next(ctx) {
                                                                                                                                                                                                if v343.0 == I64 {
                                                                                                                                                                                                    if let &InstructionData::Binary {
                                                                                                                                                                                                        opcode: ref v346,
                                                                                                                                                                                                        args: ref v347,
                                                                                                                                                                                                    } = &v343.1 {
                                                                                                                                                                                                        if let &Opcode::Band = v346 {
                                                                                                                                                                                                            let v348 = C::unpack_value_array_2(ctx, v347);
                                                                                                                                                                                                            let mut v351 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                            C::inst_data_value_etor(ctx, v348.1, &mut v351);
                                                                                                                                                                                                            let mut v351 = v351.into_context_iter();
                                                                                                                                                                                                            while let Some(v352) = v351.next(ctx) {
                                                                                                                                                                                                                if v352.0 == I64 {
                                                                                                                                                                                                                    if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                        opcode: ref v355,
                                                                                                                                                                                                                        imm: v356,
                                                                                                                                                                                                                    } = &v352.1 {
                                                                                                                                                                                                                        if let &Opcode::Iconst = v355 {
                                                                                                                                                                                                                            let v357 = C::u64_from_imm64(ctx, v356);
                                                                                                                                                                                                                            if v357 == 0xff000000_u64 {
                                                                                                                                                                                                                                let mut v358 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                C::inst_data_value_etor(ctx, v339.1, &mut v358);
                                                                                                                                                                                                                                let mut v358 = v358.into_context_iter();
                                                                                                                                                                                                                                while let Some(v359) = v358.next(ctx) {
                                                                                                                                                                                                                                    if v359.0 == I64 {
                                                                                                                                                                                                                                        if let &InstructionData::Binary {
                                                                                                                                                                                                                                            opcode: ref v486,
                                                                                                                                                                                                                                            args: ref v487,
                                                                                                                                                                                                                                        } = &v359.1 {
                                                                                                                                                                                                                                            if let &Opcode::Band = v486 {
                                                                                                                                                                                                                                                let mut v365 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                C::inst_data_value_etor(ctx, v149.1, &mut v365);
                                                                                                                                                                                                                                                let mut v365 = v365.into_context_iter();
                                                                                                                                                                                                                                                while let Some(v366) = v365.next(ctx) {
                                                                                                                                                                                                                                                    if v366.0 == I64 {
                                                                                                                                                                                                                                                        if let &InstructionData::Binary {
                                                                                                                                                                                                                                                            opcode: ref v369,
                                                                                                                                                                                                                                                            args: ref v370,
                                                                                                                                                                                                                                                        } = &v366.1 {
                                                                                                                                                                                                                                                            if let &Opcode::Bor = v369 {
                                                                                                                                                                                                                                                                let v371 = C::unpack_value_array_2(ctx, v370);
                                                                                                                                                                                                                                                                let mut v374 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                C::inst_data_value_etor(ctx, v371.1, &mut v374);
                                                                                                                                                                                                                                                                let mut v374 = v374.into_context_iter();
                                                                                                                                                                                                                                                                while let Some(v375) = v374.next(ctx) {
                                                                                                                                                                                                                                                                    if v375.0 == I64 {
                                                                                                                                                                                                                                                                        if let &InstructionData::Binary {
                                                                                                                                                                                                                                                                            opcode: ref v546,
                                                                                                                                                                                                                                                                            args: ref v547,
                                                                                                                                                                                                                                                                        } = &v375.1 {
                                                                                                                                                                                                                                                                            if let &Opcode::Ushr = v546 {
                                                                                                                                                                                                                                                                                let mut v382 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                C::inst_data_value_etor(ctx, v295.0, &mut v382);
                                                                                                                                                                                                                                                                                let mut v382 = v382.into_context_iter();
                                                                                                                                                                                                                                                                                while let Some(v383) = v382.next(ctx) {
                                                                                                                                                                                                                                                                                    if v383.0 == I64 {
                                                                                                                                                                                                                                                                                        if let &InstructionData::Binary {
                                                                                                                                                                                                                                                                                            opcode: ref v386,
                                                                                                                                                                                                                                                                                            args: ref v387,
                                                                                                                                                                                                                                                                                        } = &v383.1 {
                                                                                                                                                                                                                                                                                            if let &Opcode::Ishl = v386 {
                                                                                                                                                                                                                                                                                                let v388 = C::unpack_value_array_2(ctx, v387);
                                                                                                                                                                                                                                                                                                let v548 = C::unpack_value_array_2(ctx, v547);
                                                                                                                                                                                                                                                                                                if v388.0 == v548.0 {
                                                                                                                                                                                                                                                                                                    let mut v391 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                                    C::inst_data_value_etor(ctx, v388.1, &mut v391);
                                                                                                                                                                                                                                                                                                    let mut v391 = v391.into_context_iter();
                                                                                                                                                                                                                                                                                                    while let Some(v392) = v391.next(ctx) {
                                                                                                                                                                                                                                                                                                        if v392.0 == I64 {
                                                                                                                                                                                                                                                                                                            if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                                                                                                                opcode: ref v395,
                                                                                                                                                                                                                                                                                                                imm: v396,
                                                                                                                                                                                                                                                                                                            } = &v392.1 {
                                                                                                                                                                                                                                                                                                                if let &Opcode::Iconst = v395 {
                                                                                                                                                                                                                                                                                                                    let v397 = C::u64_from_imm64(ctx, v396);
                                                                                                                                                                                                                                                                                                                    if v397 == 0x38_u64 {
                                                                                                                                                                                                                                                                                                                        let v400 = C::unpack_value_array_2(ctx, v399);
                                                                                                                                                                                                                                                                                                                        let mut v403 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                                                        C::inst_data_value_etor(ctx, v400.0, &mut v403);
                                                                                                                                                                                                                                                                                                                        let mut v403 = v403.into_context_iter();
                                                                                                                                                                                                                                                                                                                        while let Some(v404) = v403.next(ctx) {
                                                                                                                                                                                                                                                                                                                            if v404.0 == I64 {
                                                                                                                                                                                                                                                                                                                                if let &InstructionData::Binary {
                                                                                                                                                                                                                                                                                                                                    opcode: ref v407,
                                                                                                                                                                                                                                                                                                                                    args: ref v408,
                                                                                                                                                                                                                                                                                                                                } = &v404.1 {
                                                                                                                                                                                                                                                                                                                                    if let &Opcode::Band = v407 {
                                                                                                                                                                                                                                                                                                                                        let v409 = C::unpack_value_array_2(ctx, v408);
                                                                                                                                                                                                                                                                                                                                        if v388.0 == v409.0 {
                                                                                                                                                                                                                                                                                                                                            let mut v412 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                            C::inst_data_value_etor(ctx, v409.1, &mut v412);
                                                                                                                                                                                                                                                                                                                                            let mut v412 = v412.into_context_iter();
                                                                                                                                                                                                                                                                                                                                            while let Some(v413) = v412.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                if v413.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                    if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                                                                                                                                                        opcode: ref v416,
                                                                                                                                                                                                                                                                                                                                                        imm: v417,
                                                                                                                                                                                                                                                                                                                                                    } = &v413.1 {
                                                                                                                                                                                                                                                                                                                                                        if let &Opcode::Iconst = v416 {
                                                                                                                                                                                                                                                                                                                                                            let v418 = C::u64_from_imm64(ctx, v417);
                                                                                                                                                                                                                                                                                                                                                            if v418 == 0xff00_u64 {
                                                                                                                                                                                                                                                                                                                                                                let mut v419 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                                C::inst_data_value_etor(ctx, v400.1, &mut v419);
                                                                                                                                                                                                                                                                                                                                                                let mut v419 = v419.into_context_iter();
                                                                                                                                                                                                                                                                                                                                                                while let Some(v420) = v419.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                                    if v420.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                                        if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                                                                                                                                                                            opcode: ref v423,
                                                                                                                                                                                                                                                                                                                                                                            imm: v424,
                                                                                                                                                                                                                                                                                                                                                                        } = &v420.1 {
                                                                                                                                                                                                                                                                                                                                                                            if let &Opcode::Iconst = v423 {
                                                                                                                                                                                                                                                                                                                                                                                let v425 = C::u64_from_imm64(ctx, v424);
                                                                                                                                                                                                                                                                                                                                                                                if v425 == 0x28_u64 {
                                                                                                                                                                                                                                                                                                                                                                                    let mut v426 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                                                    C::inst_data_value_etor(ctx, v316.0, &mut v426);
                                                                                                                                                                                                                                                                                                                                                                                    let mut v426 = v426.into_context_iter();
                                                                                                                                                                                                                                                                                                                                                                                    while let Some(v427) = v426.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                                                        if v427.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                                                            if let &InstructionData::Binary {
                                                                                                                                                                                                                                                                                                                                                                                                opcode: ref v430,
                                                                                                                                                                                                                                                                                                                                                                                                args: ref v431,
                                                                                                                                                                                                                                                                                                                                                                                            } = &v427.1 {
                                                                                                                                                                                                                                                                                                                                                                                                if let &Opcode::Band = v430 {
                                                                                                                                                                                                                                                                                                                                                                                                    let v432 = C::unpack_value_array_2(ctx, v431);
                                                                                                                                                                                                                                                                                                                                                                                                    if v388.0 == v432.0 {
                                                                                                                                                                                                                                                                                                                                                                                                        let mut v435 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                                                                        C::inst_data_value_etor(ctx, v432.1, &mut v435);
                                                                                                                                                                                                                                                                                                                                                                                                        let mut v435 = v435.into_context_iter();
                                                                                                                                                                                                                                                                                                                                                                                                        while let Some(v436) = v435.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                                                                            if v436.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                                                                                if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                                                                                                                                                                                                                    opcode: ref v439,
                                                                                                                                                                                                                                                                                                                                                                                                                    imm: v440,
                                                                                                                                                                                                                                                                                                                                                                                                                } = &v436.1 {
                                                                                                                                                                                                                                                                                                                                                                                                                    if let &Opcode::Iconst = v439 {
                                                                                                                                                                                                                                                                                                                                                                                                                        let v441 = C::u64_from_imm64(ctx, v440);
                                                                                                                                                                                                                                                                                                                                                                                                                        if v441 == 0xff0000_u64 {
                                                                                                                                                                                                                                                                                                                                                                                                                            let v444 = C::unpack_value_array_2(ctx, v443);
                                                                                                                                                                                                                                                                                                                                                                                                                            let mut v447 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                                                                                            C::inst_data_value_etor(ctx, v444.0, &mut v447);
                                                                                                                                                                                                                                                                                                                                                                                                                            let mut v447 = v447.into_context_iter();
                                                                                                                                                                                                                                                                                                                                                                                                                            while let Some(v448) = v447.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                                                                                                if v448.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                    if let &InstructionData::Binary {
                                                                                                                                                                                                                                                                                                                                                                                                                                        opcode: ref v451,
                                                                                                                                                                                                                                                                                                                                                                                                                                        args: ref v452,
                                                                                                                                                                                                                                                                                                                                                                                                                                    } = &v448.1 {
                                                                                                                                                                                                                                                                                                                                                                                                                                        if let &Opcode::Band = v451 {
                                                                                                                                                                                                                                                                                                                                                                                                                                            let v453 = C::unpack_value_array_2(ctx, v452);
                                                                                                                                                                                                                                                                                                                                                                                                                                            if v388.0 == v453.0 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                let mut v456 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                                                                                                                C::inst_data_value_etor(ctx, v453.1, &mut v456);
                                                                                                                                                                                                                                                                                                                                                                                                                                                let mut v456 = v456.into_context_iter();
                                                                                                                                                                                                                                                                                                                                                                                                                                                while let Some(v457) = v456.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                    if v457.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                        if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                                                                                                                                                                                                                                                            opcode: ref v460,
                                                                                                                                                                                                                                                                                                                                                                                                                                                            imm: v461,
                                                                                                                                                                                                                                                                                                                                                                                                                                                        } = &v457.1 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                            if let &Opcode::Iconst = v460 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                let v462 = C::u64_from_imm64(ctx, v461);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                if v462 == 0xff000000_u64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mut v463 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    C::inst_data_value_etor(ctx, v444.1, &mut v463);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mut v463 = v463.into_context_iter();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    while let Some(v464) = v463.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if v464.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                opcode: ref v467,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                imm: v468,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            } = &v464.1 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if let &Opcode::Iconst = v467 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let v469 = C::u64_from_imm64(ctx, v468);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if v469 == 0x8_u64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mut v470 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        C::inst_data_value_etor(ctx, v348.0, &mut v470);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mut v470 = v470.into_context_iter();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        while let Some(v471) = v470.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if v471.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if let &InstructionData::Binary {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    opcode: ref v474,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    args: ref v475,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } = &v471.1 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if let &Opcode::Ushr = v474 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let v476 = C::unpack_value_array_2(ctx, v475);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if v388.0 == v476.0 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mut v479 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            C::inst_data_value_etor(ctx, v476.1, &mut v479);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mut v479 = v479.into_context_iter();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            while let Some(v480) = v479.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if v480.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        opcode: ref v483,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        imm: v484,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } = &v480.1 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if let &Opcode::Iconst = v483 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let v485 = C::u64_from_imm64(ctx, v484);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if v485 == 0x8_u64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let v488 = C::unpack_value_array_2(ctx, v487);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mut v491 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                C::inst_data_value_etor(ctx, v488.0, &mut v491);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mut v491 = v491.into_context_iter();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                while let Some(v492) = v491.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if v492.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if let &InstructionData::Binary {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            opcode: ref v495,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            args: ref v496,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } = &v492.1 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if let &Opcode::Ushr = v495 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let v497 = C::unpack_value_array_2(ctx, v496);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if v388.0 == v497.0 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mut v500 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    C::inst_data_value_etor(ctx, v497.1, &mut v500);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mut v500 = v500.into_context_iter();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    while let Some(v501) = v500.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if v501.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                opcode: ref v504,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                imm: v505,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            } = &v501.1 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if let &Opcode::Iconst = v504 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let v506 = C::u64_from_imm64(ctx, v505);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if v506 == 0x18_u64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mut v507 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        C::inst_data_value_etor(ctx, v488.1, &mut v507);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mut v507 = v507.into_context_iter();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        while let Some(v508) = v507.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if v508.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    opcode: ref v511,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    imm: v512,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } = &v508.1 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if let &Opcode::Iconst = v511 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let v513 = C::u64_from_imm64(ctx, v512);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if v513 == 0xff0000_u64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mut v514 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            C::inst_data_value_etor(ctx, v371.0, &mut v514);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mut v514 = v514.into_context_iter();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            while let Some(v515) = v514.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if v515.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if let &InstructionData::Binary {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        opcode: ref v518,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        args: ref v519,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } = &v515.1 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if let &Opcode::Band = v518 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let v520 = C::unpack_value_array_2(ctx, v519);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mut v523 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            C::inst_data_value_etor(ctx, v520.0, &mut v523);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mut v523 = v523.into_context_iter();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            while let Some(v524) = v523.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if v524.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if let &InstructionData::Binary {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        opcode: ref v527,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        args: ref v528,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } = &v524.1 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if let &Opcode::Ushr = v527 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let v529 = C::unpack_value_array_2(ctx, v528);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if v388.0 == v529.0 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mut v532 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                C::inst_data_value_etor(ctx, v529.1, &mut v532);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mut v532 = v532.into_context_iter();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                while let Some(v533) = v532.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if v533.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            opcode: ref v536,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            imm: v537,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } = &v533.1 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if let &Opcode::Iconst = v536 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let v538 = C::u64_from_imm64(ctx, v537);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if v538 == 0x28_u64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mut v539 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    C::inst_data_value_etor(ctx, v520.1, &mut v539);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mut v539 = v539.into_context_iter();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    while let Some(v540) = v539.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if v540.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                opcode: ref v543,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                imm: v544,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            } = &v540.1 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if let &Opcode::Iconst = v543 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let v545 = C::u64_from_imm64(ctx, v544);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if v545 == 0xff00_u64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mut v551 = C::inst_data_value_etor_returns::default();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        C::inst_data_value_etor(ctx, v548.1, &mut v551);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mut v551 = v551.into_context_iter();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        while let Some(v552) = v551.next(ctx) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if v552.0 == I64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if let &InstructionData::UnaryImm {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    opcode: ref v555,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    imm: v556,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } = &v552.1 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if let &Opcode::Iconst = v555 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let v557 = C::u64_from_imm64(ctx, v556);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if v557 == 0x38_u64 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let v558 = constructor_bswap(ctx, v2.0, v388.0);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            // Rule at src/opts/bitops.isle line 155.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            returns.extend(Some(v558));
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                }
                                                                                                                                                                                                                            }
                                                                                                                                                                                                                        }
                                                                                                                                                                                                                    }
                                                                                                                                                                                                                }
                                                                                                                                                                                                            }
                                                                                                                                                                                                        }
                                                                                                                                                                                                    }
                                                                                                                                                                                                }
                                                                                                                                                                                            }
                                                                                                                                                                                        }
                                                                                                                                                                                    }
                                                                                                                                                                                }
                                                                                                                                                                            }
                                                                                                                                                                        }
                                                                                                                                                                    }
                                                                                                                                                                }
                                                                                                                                                            }
                                                                                                                                                        }
                                                                                                                                                    }
                                                                                                                                                }
                                                                                                                                            }
                                                                                                                                        }
                                                                                                                                    }
                                                                                                                                }
                                                                                                                            }
                                                                                                                        }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                _ => {}
                                            }
                                        }
                                        &Opcode::Ishl => {
                                            let v52 = C::ty_int(ctx, v2.0);
                                            if let Some(v53) = v52 {
                                                if v11.0 == v53 {
                                                    let mut v18 = C::inst_data_value_etor_returns::default();
                                                    C::inst_data_value_etor(ctx, v7.0, &mut v18);
                                                    let mut v18 = v18.into_context_iter();
                                                    while let Some(v19) = v18.next(ctx) {
                                                        if let &InstructionData::Binary {
                                                            opcode: ref v104,
                                                            args: ref v105,
                                                        } = &v19.1 {
                                                            if let &Opcode::Ushr = v104 {
                                                                if v11.0 == v19.0 {
                                                                    let v106 = C::unpack_value_array_2(ctx, v105);
                                                                    let v149 = C::unpack_value_array_2(ctx, v148);
                                                                    if v106.0 == v149.0 {
                                                                        let mut v116 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v106.1, &mut v116);
                                                                        let mut v116 = v116.into_context_iter();
                                                                        while let Some(v117) = v116.next(ctx) {
                                                                            if let &InstructionData::UnaryImm {
                                                                                opcode: ref v258,
                                                                                imm: v259,
                                                                            } = &v117.1 {
                                                                                if let &Opcode::Iconst = v258 {
                                                                                    let mut v365 = C::inst_data_value_etor_returns::default();
                                                                                    C::inst_data_value_etor(ctx, v149.1, &mut v365);
                                                                                    let mut v365 = v365.into_context_iter();
                                                                                    while let Some(v366) = v365.next(ctx) {
                                                                                        if let &InstructionData::UnaryImm {
                                                                                            opcode: ref v771,
                                                                                            imm: v772,
                                                                                        } = &v366.1 {
                                                                                            if let &Opcode::Iconst = v771 {
                                                                                                let v260 = C::u64_from_imm64(ctx, v259);
                                                                                                let v1442 = C::lane_type(ctx, v53);
                                                                                                let v1443 = C::ty_bits_u64(ctx, v1442);
                                                                                                let v1041 = C::u64_from_imm64(ctx, v772);
                                                                                                let v1447 = C::u64_wrapping_sub(ctx, v1443, v1041);
                                                                                                let v1448 = C::u64_eq(ctx, v260, v1447);
                                                                                                if v1448 == true {
                                                                                                    let v1449 = constructor_rotl(ctx, v53, v106.0, v149.1);
                                                                                                    // Rule at src/opts/shifts.isle line 280.
                                                                                                    returns.extend(Some(v1449));
                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        &Opcode::Ushr => {
                                            let v52 = C::ty_int(ctx, v2.0);
                                            if let Some(v53) = v52 {
                                                if v11.0 == v53 {
                                                    let mut v18 = C::inst_data_value_etor_returns::default();
                                                    C::inst_data_value_etor(ctx, v7.0, &mut v18);
                                                    let mut v18 = v18.into_context_iter();
                                                    while let Some(v19) = v18.next(ctx) {
                                                        if let &InstructionData::Binary {
                                                            opcode: ref v104,
                                                            args: ref v105,
                                                        } = &v19.1 {
                                                            if let &Opcode::Ishl = v104 {
                                                                if v11.0 == v19.0 {
                                                                    let v106 = C::unpack_value_array_2(ctx, v105);
                                                                    let v149 = C::unpack_value_array_2(ctx, v148);
                                                                    if v106.0 == v149.0 {
                                                                        let mut v116 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v106.1, &mut v116);
                                                                        let mut v116 = v116.into_context_iter();
                                                                        while let Some(v117) = v116.next(ctx) {
                                                                            if let &InstructionData::UnaryImm {
                                                                                opcode: ref v258,
                                                                                imm: v259,
                                                                            } = &v117.1 {
                                                                                if let &Opcode::Iconst = v258 {
                                                                                    let mut v365 = C::inst_data_value_etor_returns::default();
                                                                                    C::inst_data_value_etor(ctx, v149.1, &mut v365);
                                                                                    let mut v365 = v365.into_context_iter();
                                                                                    while let Some(v366) = v365.next(ctx) {
                                                                                        if let &InstructionData::UnaryImm {
                                                                                            opcode: ref v771,
                                                                                            imm: v772,
                                                                                        } = &v366.1 {
                                                                                            if let &Opcode::Iconst = v771 {
                                                                                                let v1041 = C::u64_from_imm64(ctx, v772);
                                                                                                let v1442 = C::lane_type(ctx, v53);
                                                                                                let v1443 = C::ty_bits_u64(ctx, v1442);
                                                                                                let v260 = C::u64_from_imm64(ctx, v259);
                                                                                                let v1444 = C::u64_wrapping_sub(ctx, v1443, v260);
                                                                                                let v1445 = C::u64_eq(ctx, v1041, v1444);
                                                                                                if v1445 == true {
                                                                                                    let v1446 = constructor_rotl(ctx, v53, v106.0, v106.1);
                                                                                                    // Rule at src/opts/shifts.isle line 275.
                                                                                                    returns.extend(Some(v1446));
                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        _ => {}
                                    }
                                }
                                &InstructionData::IntCompare {
                                    opcode: ref v1126,
                                    args: ref v1127,
                                    cond: ref v1128,
                                } => {
                                    if let &Opcode::Icmp = v1126 {
                                        let v608 = C::fits_in_64(ctx, v2.0);
                                        if let Some(v609) = v608 {
                                            if v11.0 == v609 {
                                                let mut v18 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v7.0, &mut v18);
                                                let mut v18 = v18.into_context_iter();
                                                while let Some(v19) = v18.next(ctx) {
                                                    if let &InstructionData::IntCompare {
                                                        opcode: ref v1100,
                                                        args: ref v1101,
                                                        cond: ref v1102,
                                                    } = &v19.1 {
                                                        if let &Opcode::Icmp = v1100 {
                                                            let v1132 = constructor_intcc_comparable(ctx, v1102, v1128);
                                                            if let Some(v1133) = v1132 {
                                                                if v11.0 == v19.0 {
                                                                    let v1103 = C::unpack_value_array_2(ctx, v1101);
                                                                    let v1129 = C::unpack_value_array_2(ctx, v1127);
                                                                    if v1103.0 == v1129.0 {
                                                                        if v1103.1 == v1129.1 {
                                                                            let v1134 = constructor_decompose_intcc(ctx, v1102);
                                                                            let v1135 = constructor_decompose_intcc(ctx, v1128);
                                                                            let v1138 = C::u64_or(ctx, v1134, v1135);
                                                                            let v1139 = constructor_compose_icmp(ctx, v609, v1138, v1133, v1103.0, v1103.1);
                                                                            // Rule at src/opts/icmp.isle line 186.
                                                                            returns.extend(Some(v1139));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v26,
                                    arg: v27,
                                } => {
                                    match v26 {
                                        &Opcode::Splat => {
                                            let v1539 = C::ty_vector_not_float(ctx, v2.0);
                                            if let Some(v1540) = v1539 {
                                                if v2.0 == v11.0 {
                                                    let mut v18 = C::inst_data_value_etor_returns::default();
                                                    C::inst_data_value_etor(ctx, v7.0, &mut v18);
                                                    let mut v18 = v18.into_context_iter();
                                                    while let Some(v19) = v18.next(ctx) {
                                                        if let &InstructionData::Unary {
                                                            opcode: ref v29,
                                                            arg: v30,
                                                        } = &v19.1 {
                                                            if let &Opcode::Splat = v29 {
                                                                if v2.0 == v19.0 {
                                                                    let v1425 = C::lane_type(ctx, v2.0);
                                                                    let v1543 = constructor_bor(ctx, v1425, v30, v27);
                                                                    let v1544 = constructor_splat(ctx, v2.0, v1543);
                                                                    // Rule at src/opts/vector.isle line 18.
                                                                    returns.extend(Some(v1544));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        &Opcode::Bnot => {
                                            if v2.0 == v11.0 {
                                                let mut v18 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v7.0, &mut v18);
                                                let mut v18 = v18.into_context_iter();
                                                while let Some(v19) = v18.next(ctx) {
                                                    if let &InstructionData::Binary {
                                                        opcode: ref v104,
                                                        args: ref v105,
                                                    } = &v19.1 {
                                                        if let &Opcode::Band = v104 {
                                                            if v2.0 == v19.0 {
                                                                let mut v578 = C::inst_data_value_etor_returns::default();
                                                                C::inst_data_value_etor(ctx, v27, &mut v578);
                                                                let mut v578 = v578.into_context_iter();
                                                                while let Some(v579) = v578.next(ctx) {
                                                                    if let &InstructionData::Binary {
                                                                        opcode: ref v582,
                                                                        args: ref v583,
                                                                    } = &v579.1 {
                                                                        if let &Opcode::Bxor = v582 {
                                                                            if v2.0 == v579.0 {
                                                                                let v106 = C::unpack_value_array_2(ctx, v105);
                                                                                let v584 = C::unpack_value_array_2(ctx, v583);
                                                                                if v106.0 == v584.0 {
                                                                                    if v106.1 == v584.1 {
                                                                                        let v559 = constructor_bxor(ctx, v2.0, v106.0, v106.1);
                                                                                        let v587 = constructor_bnot(ctx, v2.0, v559);
                                                                                        // Rule at src/opts/bitops.isle line 229.
                                                                                        returns.extend(Some(v587));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        let v601 = constructor_bxor(ctx, v2.0, v106.1, v106.0);
                                                                                        let v602 = constructor_bnot(ctx, v2.0, v601);
                                                                                        // Rule at src/opts/bitops.isle line 235.
                                                                                        returns.extend(Some(v602));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                                if v106.0 == v584.1 {
                                                                                    if v106.1 == v584.0 {
                                                                                        let v559 = constructor_bxor(ctx, v2.0, v106.0, v106.1);
                                                                                        let v587 = constructor_bnot(ctx, v2.0, v559);
                                                                                        // Rule at src/opts/bitops.isle line 231.
                                                                                        returns.extend(Some(v587));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        let v601 = constructor_bxor(ctx, v2.0, v106.1, v106.0);
                                                                                        let v602 = constructor_bnot(ctx, v2.0, v601);
                                                                                        // Rule at src/opts/bitops.isle line 233.
                                                                                        returns.extend(Some(v602));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                let v106 = C::unpack_value_array_2(ctx, v105);
                                                                if v27 == v106.0 {
                                                                    let v572 = constructor_bnot(ctx, v2.0, v106.0);
                                                                    let v573 = constructor_bor(ctx, v2.0, v106.1, v572);
                                                                    // Rule at src/opts/bitops.isle line 220.
                                                                    returns.extend(Some(v573));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                if v27 == v106.1 {
                                                                    let v256 = constructor_bor(ctx, v2.0, v106.0, v7.1);
                                                                    // Rule at src/opts/bitops.isle line 44.
                                                                    returns.extend(Some(v256));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                            let v52 = C::ty_int(ctx, v2.0);
                                            if let Some(v53) = v52 {
                                                if v11.0 == v53 {
                                                    if v7.0 == v27 {
                                                        let v253 = constructor_iconst_s(ctx, v53, -1_i64);
                                                        let v254 = C::subsume(ctx, v253);
                                                        // Rule at src/opts/bitops.isle line 24.
                                                        returns.extend(Some(v254));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                        }
                                        &Opcode::Uextend => {
                                            let mut v18 = C::inst_data_value_etor_returns::default();
                                            C::inst_data_value_etor(ctx, v7.0, &mut v18);
                                            let mut v18 = v18.into_context_iter();
                                            while let Some(v19) = v18.next(ctx) {
                                                if let &InstructionData::Unary {
                                                    opcode: ref v29,
                                                    arg: v30,
                                                } = &v19.1 {
                                                    if let &Opcode::Uextend = v29 {
                                                        let v986 = C::value_type(ctx, v30);
                                                        let v1021 = C::value_type(ctx, v27);
                                                        if v986 == v1021 {
                                                            let v1024 = constructor_bor(ctx, v986, v30, v27);
                                                            let v1025 = constructor_uextend(ctx, v2.0, v1024);
                                                            // Rule at src/opts/extends.isle line 72.
                                                            returns.extend(Some(v1025));
                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        _ => {}
                                    }
                                }
                                &InstructionData::UnaryImm {
                                    opcode: ref v14,
                                    imm: v15,
                                } => {
                                    if let &Opcode::Iconst = v14 {
                                        if v2.0 == v11.0 {
                                            let mut v18 = C::inst_data_value_etor_returns::default();
                                            C::inst_data_value_etor(ctx, v7.0, &mut v18);
                                            let mut v18 = v18.into_context_iter();
                                            while let Some(v19) = v18.next(ctx) {
                                                if let &InstructionData::Binary {
                                                    opcode: ref v104,
                                                    args: ref v105,
                                                } = &v19.1 {
                                                    match v104 {
                                                        &Opcode::Band => {
                                                            if v2.0 == v19.0 {
                                                                let v106 = C::unpack_value_array_2(ctx, v105);
                                                                let mut v116 = C::inst_data_value_etor_returns::default();
                                                                C::inst_data_value_etor(ctx, v106.1, &mut v116);
                                                                let mut v116 = v116.into_context_iter();
                                                                while let Some(v117) = v116.next(ctx) {
                                                                    if let &InstructionData::UnaryImm {
                                                                        opcode: ref v258,
                                                                        imm: v259,
                                                                    } = &v117.1 {
                                                                        if let &Opcode::Iconst = v258 {
                                                                            let v261 = C::ty_mask(ctx, v2.0);
                                                                            let v16 = C::u64_from_imm64(ctx, v15);
                                                                            let v262 = C::u64_and(ctx, v261, v16);
                                                                            let v260 = C::u64_from_imm64(ctx, v259);
                                                                            let v263 = C::u64_not(ctx, v260);
                                                                            let v264 = C::u64_and(ctx, v261, v263);
                                                                            let v265 = C::u64_eq(ctx, v262, v264);
                                                                            if v265 == true {
                                                                                if v2.0 == v117.0 {
                                                                                    let v256 = constructor_bor(ctx, v2.0, v106.0, v7.1);
                                                                                    // Rule at src/opts/bitops.isle line 64.
                                                                                    returns.extend(Some(v256));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        &Opcode::Bor => {
                                                            if v2.0 == v19.0 {
                                                                let v106 = C::unpack_value_array_2(ctx, v105);
                                                                let mut v116 = C::inst_data_value_etor_returns::default();
                                                                C::inst_data_value_etor(ctx, v106.1, &mut v116);
                                                                let mut v116 = v116.into_context_iter();
                                                                while let Some(v117) = v116.next(ctx) {
                                                                    if let &InstructionData::UnaryImm {
                                                                        opcode: ref v258,
                                                                        imm: v259,
                                                                    } = &v117.1 {
                                                                        if let &Opcode::Iconst = v258 {
                                                                            if v2.0 == v117.0 {
                                                                                let v707 = constructor_bor(ctx, v2.0, v106.1, v7.1);
                                                                                let v708 = constructor_bor(ctx, v2.0, v106.0, v707);
                                                                                // Rule at src/opts/cprop.isle line 180.
                                                                                returns.extend(Some(v708));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                            }
                                            let v16 = C::u64_from_imm64(ctx, v15);
                                            if v16 == 0x0_u64 {
                                                let v17 = C::subsume(ctx, v7.0);
                                                // Rule at src/opts/bitops.isle line 3.
                                                returns.extend(Some(v17));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                        let v608 = C::fits_in_64(ctx, v2.0);
                                        if let Some(v609) = v608 {
                                            if v11.0 == v609 {
                                                let mut v18 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v7.0, &mut v18);
                                                let mut v18 = v18.into_context_iter();
                                                while let Some(v19) = v18.next(ctx) {
                                                    if let &InstructionData::UnaryImm {
                                                        opcode: ref v22,
                                                        imm: v23,
                                                    } = &v19.1 {
                                                        if let &Opcode::Iconst = v22 {
                                                            if v11.0 == v19.0 {
                                                                let v24 = C::u64_from_imm64(ctx, v23);
                                                                let v16 = C::u64_from_imm64(ctx, v15);
                                                                let v630 = C::u64_or(ctx, v24, v16);
                                                                let v631 = C::imm64_masked(ctx, v609, v630);
                                                                let v632 = constructor_iconst(ctx, v609, v631);
                                                                let v633 = C::subsume(ctx, v632);
                                                                // Rule at src/opts/cprop.isle line 55.
                                                                returns.extend(Some(v633));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        let v1270 = C::remat(ctx, arg0);
                                        // Rule at src/opts/remat.isle line 17.
                                        returns.extend(Some(v1270));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                                _ => {}
                            }
                        }
                        let mut v18 = C::inst_data_value_etor_returns::default();
                        C::inst_data_value_etor(ctx, v7.0, &mut v18);
                        let mut v18 = v18.into_context_iter();
                        while let Some(v19) = v18.next(ctx) {
                            match &v19.1 {
                                &InstructionData::Binary {
                                    opcode: ref v104,
                                    args: ref v105,
                                } => {
                                    match v104 {
                                        &Opcode::Band => {
                                            if v2.0 == v19.0 {
                                                let v106 = C::unpack_value_array_2(ctx, v105);
                                                if v7.1 == v106.0 {
                                                    // Rule at src/opts/bitops.isle line 212.
                                                    returns.extend(Some(v106.0));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                        &Opcode::Bor => {
                                            if v2.0 == v19.0 {
                                                let v106 = C::unpack_value_array_2(ctx, v105);
                                                if v7.1 == v106.0 {
                                                    let v255 = constructor_bor(ctx, v2.0, v106.0, v106.1);
                                                    // Rule at src/opts/bitops.isle line 187.
                                                    returns.extend(Some(v255));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v7.1 == v106.1 {
                                                    let v255 = constructor_bor(ctx, v2.0, v106.0, v106.1);
                                                    // Rule at src/opts/bitops.isle line 188.
                                                    returns.extend(Some(v255));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                        _ => {}
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v29,
                                    arg: v30,
                                } => {
                                    if let &Opcode::Bnot = v29 {
                                        if v7.1 == v30 {
                                            let v52 = C::ty_int(ctx, v2.0);
                                            if let Some(v53) = v52 {
                                                if v19.0 == v53 {
                                                    let v253 = constructor_iconst_s(ctx, v53, -1_i64);
                                                    let v254 = C::subsume(ctx, v253);
                                                    // Rule at src/opts/bitops.isle line 25.
                                                    returns.extend(Some(v254));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::UnaryImm {
                                    opcode: ref v22,
                                    imm: v23,
                                } => {
                                    if let &Opcode::Iconst = v22 {
                                        if v2.0 == v19.0 {
                                            let v678 = constructor_bor(ctx, v2.0, v7.1, v7.0);
                                            // Rule at src/opts/cprop.isle line 127.
                                            returns.extend(Some(v678));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        let v1270 = C::remat(ctx, arg0);
                                        // Rule at src/opts/remat.isle line 15.
                                        returns.extend(Some(v1270));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                                _ => {}
                            }
                        }
                        if v7.0 == v7.1 {
                            let v17 = C::subsume(ctx, v7.0);
                            // Rule at src/opts/bitops.isle line 7.
                            returns.extend(Some(v17));
                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                        }
                    }
                    &Opcode::Bxor => {
                        let v7 = C::unpack_value_array_2(ctx, v6);
                        let mut v10 = C::inst_data_value_etor_returns::default();
                        C::inst_data_value_etor(ctx, v7.1, &mut v10);
                        let mut v10 = v10.into_context_iter();
                        while let Some(v11) = v10.next(ctx) {
                            match &v11.1 {
                                &InstructionData::Binary {
                                    opcode: ref v147,
                                    args: ref v148,
                                } => {
                                    match v147 {
                                        &Opcode::Band => {
                                            if v2.0 == v11.0 {
                                                let mut v18 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v7.0, &mut v18);
                                                let mut v18 = v18.into_context_iter();
                                                while let Some(v19) = v18.next(ctx) {
                                                    if let &InstructionData::Binary {
                                                        opcode: ref v104,
                                                        args: ref v105,
                                                    } = &v19.1 {
                                                        match v104 {
                                                            &Opcode::Band => {
                                                                if v2.0 == v19.0 {
                                                                    let v106 = C::unpack_value_array_2(ctx, v105);
                                                                    let v149 = C::unpack_value_array_2(ctx, v148);
                                                                    if v106.0 == v149.0 {
                                                                        let v576 = constructor_bxor(ctx, v2.0, v106.1, v149.1);
                                                                        let v577 = constructor_band(ctx, v2.0, v106.0, v576);
                                                                        // Rule at src/opts/bitops.isle line 224.
                                                                        returns.extend(Some(v577));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                            &Opcode::Bor => {
                                                                if v2.0 == v19.0 {
                                                                    let v106 = C::unpack_value_array_2(ctx, v105);
                                                                    let v149 = C::unpack_value_array_2(ctx, v148);
                                                                    if v106.0 == v149.0 {
                                                                        if v106.1 == v149.1 {
                                                                            let v559 = constructor_bxor(ctx, v2.0, v106.0, v106.1);
                                                                            // Rule at src/opts/bitops.isle line 184.
                                                                            returns.extend(Some(v559));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            _ => {}
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        &Opcode::Bxor => {
                                            if v2.0 == v11.0 {
                                                let mut v18 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v7.0, &mut v18);
                                                let mut v18 = v18.into_context_iter();
                                                while let Some(v19) = v18.next(ctx) {
                                                    if let &InstructionData::Binary {
                                                        opcode: ref v104,
                                                        args: ref v105,
                                                    } = &v19.1 {
                                                        match v104 {
                                                            &Opcode::Band => {
                                                                if v2.0 == v19.0 {
                                                                    let v106 = C::unpack_value_array_2(ctx, v105);
                                                                    let v149 = C::unpack_value_array_2(ctx, v148);
                                                                    if v106.0 == v149.0 {
                                                                        if v106.1 == v149.1 {
                                                                            let v255 = constructor_bor(ctx, v2.0, v106.0, v106.1);
                                                                            // Rule at src/opts/bitops.isle line 38.
                                                                            returns.extend(Some(v255));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            &Opcode::Bxor => {
                                                                if v2.0 == v19.0 {
                                                                    let v106 = C::unpack_value_array_2(ctx, v105);
                                                                    let mut v116 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v106.1, &mut v116);
                                                                    let mut v116 = v116.into_context_iter();
                                                                    while let Some(v117) = v116.next(ctx) {
                                                                        if let &InstructionData::UnaryImm {
                                                                            opcode: ref v258,
                                                                            imm: v259,
                                                                        } = &v117.1 {
                                                                            if let &Opcode::Iconst = v258 {
                                                                                let v149 = C::unpack_value_array_2(ctx, v148);
                                                                                let mut v365 = C::inst_data_value_etor_returns::default();
                                                                                C::inst_data_value_etor(ctx, v149.1, &mut v365);
                                                                                let mut v365 = v365.into_context_iter();
                                                                                while let Some(v366) = v365.next(ctx) {
                                                                                    if let &InstructionData::UnaryImm {
                                                                                        opcode: ref v771,
                                                                                        imm: v772,
                                                                                    } = &v366.1 {
                                                                                        if let &Opcode::Iconst = v771 {
                                                                                            let v785 = constructor_bxor(ctx, v2.0, v106.0, v149.0);
                                                                                            let v786 = constructor_bxor(ctx, v2.0, v106.1, v149.1);
                                                                                            let v787 = constructor_bxor(ctx, v2.0, v785, v786);
                                                                                            // Rule at src/opts/cprop.isle line 280.
                                                                                            returns.extend(Some(v787));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            _ => {}
                                                        }
                                                    }
                                                }
                                                let v149 = C::unpack_value_array_2(ctx, v148);
                                                if v7.0 == v149.1 {
                                                    // Rule at src/opts/bitops.isle line 217.
                                                    returns.extend(Some(v149.0));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                        _ => {}
                                    }
                                }
                                &InstructionData::IntCompare {
                                    opcode: ref v1126,
                                    args: ref v1127,
                                    cond: ref v1128,
                                } => {
                                    if let &Opcode::Icmp = v1126 {
                                        match v1128 {
                                            &IntCC::SignedGreaterThan => {
                                                if v2.0 == v11.0 {
                                                    let mut v18 = C::inst_data_value_etor_returns::default();
                                                    C::inst_data_value_etor(ctx, v7.0, &mut v18);
                                                    let mut v18 = v18.into_context_iter();
                                                    while let Some(v19) = v18.next(ctx) {
                                                        if let &InstructionData::IntCompare {
                                                            opcode: ref v1100,
                                                            args: ref v1101,
                                                            cond: ref v1102,
                                                        } = &v19.1 {
                                                            if let &Opcode::Icmp = v1100 {
                                                                match v1102 {
                                                                    &IntCC::SignedGreaterThan => {
                                                                        if v2.0 == v19.0 {
                                                                            let v1103 = C::unpack_value_array_2(ctx, v1101);
                                                                            let v1129 = C::unpack_value_array_2(ctx, v1127);
                                                                            if v1103.0 == v1129.1 {
                                                                                if v1103.1 == v1129.0 {
                                                                                    let v1215 = constructor_ne(ctx, v2.0, v1103.0, v1103.1);
                                                                                    // Rule at src/opts/icmp.isle line 312.
                                                                                    returns.extend(Some(v1215));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::SignedLessThan => {
                                                                        if v2.0 == v19.0 {
                                                                            let v1103 = C::unpack_value_array_2(ctx, v1101);
                                                                            let v1129 = C::unpack_value_array_2(ctx, v1127);
                                                                            if v1103.0 == v1129.0 {
                                                                                if v1103.1 == v1129.1 {
                                                                                    let v1215 = constructor_ne(ctx, v2.0, v1103.0, v1103.1);
                                                                                    // Rule at src/opts/icmp.isle line 314.
                                                                                    returns.extend(Some(v1215));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    _ => {}
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                            &IntCC::SignedLessThan => {
                                                if v2.0 == v11.0 {
                                                    let mut v18 = C::inst_data_value_etor_returns::default();
                                                    C::inst_data_value_etor(ctx, v7.0, &mut v18);
                                                    let mut v18 = v18.into_context_iter();
                                                    while let Some(v19) = v18.next(ctx) {
                                                        if let &InstructionData::IntCompare {
                                                            opcode: ref v1100,
                                                            args: ref v1101,
                                                            cond: ref v1102,
                                                        } = &v19.1 {
                                                            if let &Opcode::Icmp = v1100 {
                                                                match v1102 {
                                                                    &IntCC::SignedGreaterThan => {
                                                                        if v2.0 == v19.0 {
                                                                            let v1103 = C::unpack_value_array_2(ctx, v1101);
                                                                            let v1129 = C::unpack_value_array_2(ctx, v1127);
                                                                            if v1103.0 == v1129.0 {
                                                                                if v1103.1 == v1129.1 {
                                                                                    let v1215 = constructor_ne(ctx, v2.0, v1103.0, v1103.1);
                                                                                    // Rule at src/opts/icmp.isle line 313.
                                                                                    returns.extend(Some(v1215));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::SignedLessThan => {
                                                                        if v2.0 == v19.0 {
                                                                            let v1103 = C::unpack_value_array_2(ctx, v1101);
                                                                            let v1129 = C::unpack_value_array_2(ctx, v1127);
                                                                            if v1103.0 == v1129.1 {
                                                                                if v1103.1 == v1129.0 {
                                                                                    let v1215 = constructor_ne(ctx, v2.0, v1103.0, v1103.1);
                                                                                    // Rule at src/opts/icmp.isle line 315.
                                                                                    returns.extend(Some(v1215));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    _ => {}
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                            &IntCC::UnsignedGreaterThan => {
                                                if v2.0 == v11.0 {
                                                    let mut v18 = C::inst_data_value_etor_returns::default();
                                                    C::inst_data_value_etor(ctx, v7.0, &mut v18);
                                                    let mut v18 = v18.into_context_iter();
                                                    while let Some(v19) = v18.next(ctx) {
                                                        if let &InstructionData::IntCompare {
                                                            opcode: ref v1100,
                                                            args: ref v1101,
                                                            cond: ref v1102,
                                                        } = &v19.1 {
                                                            if let &Opcode::Icmp = v1100 {
                                                                match v1102 {
                                                                    &IntCC::UnsignedGreaterThan => {
                                                                        if v2.0 == v19.0 {
                                                                            let v1103 = C::unpack_value_array_2(ctx, v1101);
                                                                            let v1129 = C::unpack_value_array_2(ctx, v1127);
                                                                            if v1103.0 == v1129.1 {
                                                                                if v1103.1 == v1129.0 {
                                                                                    let v1215 = constructor_ne(ctx, v2.0, v1103.0, v1103.1);
                                                                                    // Rule at src/opts/icmp.isle line 316.
                                                                                    returns.extend(Some(v1215));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::UnsignedLessThan => {
                                                                        if v2.0 == v19.0 {
                                                                            let v1103 = C::unpack_value_array_2(ctx, v1101);
                                                                            let v1129 = C::unpack_value_array_2(ctx, v1127);
                                                                            if v1103.0 == v1129.0 {
                                                                                if v1103.1 == v1129.1 {
                                                                                    let v1215 = constructor_ne(ctx, v2.0, v1103.0, v1103.1);
                                                                                    // Rule at src/opts/icmp.isle line 318.
                                                                                    returns.extend(Some(v1215));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    _ => {}
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                            &IntCC::UnsignedLessThan => {
                                                if v2.0 == v11.0 {
                                                    let mut v18 = C::inst_data_value_etor_returns::default();
                                                    C::inst_data_value_etor(ctx, v7.0, &mut v18);
                                                    let mut v18 = v18.into_context_iter();
                                                    while let Some(v19) = v18.next(ctx) {
                                                        if let &InstructionData::IntCompare {
                                                            opcode: ref v1100,
                                                            args: ref v1101,
                                                            cond: ref v1102,
                                                        } = &v19.1 {
                                                            if let &Opcode::Icmp = v1100 {
                                                                match v1102 {
                                                                    &IntCC::UnsignedGreaterThan => {
                                                                        if v2.0 == v19.0 {
                                                                            let v1103 = C::unpack_value_array_2(ctx, v1101);
                                                                            let v1129 = C::unpack_value_array_2(ctx, v1127);
                                                                            if v1103.0 == v1129.0 {
                                                                                if v1103.1 == v1129.1 {
                                                                                    let v1215 = constructor_ne(ctx, v2.0, v1103.0, v1103.1);
                                                                                    // Rule at src/opts/icmp.isle line 317.
                                                                                    returns.extend(Some(v1215));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::UnsignedLessThan => {
                                                                        if v2.0 == v19.0 {
                                                                            let v1103 = C::unpack_value_array_2(ctx, v1101);
                                                                            let v1129 = C::unpack_value_array_2(ctx, v1127);
                                                                            if v1103.0 == v1129.1 {
                                                                                if v1103.1 == v1129.0 {
                                                                                    let v1215 = constructor_ne(ctx, v2.0, v1103.0, v1103.1);
                                                                                    // Rule at src/opts/icmp.isle line 319.
                                                                                    returns.extend(Some(v1215));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    _ => {}
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                            _ => {}
                                        }
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v26,
                                    arg: v27,
                                } => {
                                    match v26 {
                                        &Opcode::Splat => {
                                            let v1539 = C::ty_vector_not_float(ctx, v2.0);
                                            if let Some(v1540) = v1539 {
                                                if v2.0 == v11.0 {
                                                    let mut v18 = C::inst_data_value_etor_returns::default();
                                                    C::inst_data_value_etor(ctx, v7.0, &mut v18);
                                                    let mut v18 = v18.into_context_iter();
                                                    while let Some(v19) = v18.next(ctx) {
                                                        if let &InstructionData::Unary {
                                                            opcode: ref v29,
                                                            arg: v30,
                                                        } = &v19.1 {
                                                            if let &Opcode::Splat = v29 {
                                                                if v2.0 == v19.0 {
                                                                    let v1425 = C::lane_type(ctx, v2.0);
                                                                    let v1545 = constructor_bxor(ctx, v1425, v30, v27);
                                                                    let v1546 = constructor_splat(ctx, v2.0, v1545);
                                                                    // Rule at src/opts/vector.isle line 22.
                                                                    returns.extend(Some(v1546));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        &Opcode::Bnot => {
                                            let v52 = C::ty_int(ctx, v2.0);
                                            if let Some(v53) = v52 {
                                                if v7.0 == v27 {
                                                    if v11.0 == v53 {
                                                        let v253 = constructor_iconst_s(ctx, v53, -1_i64);
                                                        let v254 = C::subsume(ctx, v253);
                                                        // Rule at src/opts/bitops.isle line 22.
                                                        returns.extend(Some(v254));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                        }
                                        &Opcode::Uextend => {
                                            let mut v18 = C::inst_data_value_etor_returns::default();
                                            C::inst_data_value_etor(ctx, v7.0, &mut v18);
                                            let mut v18 = v18.into_context_iter();
                                            while let Some(v19) = v18.next(ctx) {
                                                if let &InstructionData::Unary {
                                                    opcode: ref v29,
                                                    arg: v30,
                                                } = &v19.1 {
                                                    if let &Opcode::Uextend = v29 {
                                                        let v986 = C::value_type(ctx, v30);
                                                        let v1021 = C::value_type(ctx, v27);
                                                        if v986 == v1021 {
                                                            let v1026 = constructor_bxor(ctx, v986, v30, v27);
                                                            let v1027 = constructor_uextend(ctx, v2.0, v1026);
                                                            // Rule at src/opts/extends.isle line 74.
                                                            returns.extend(Some(v1027));
                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        _ => {}
                                    }
                                }
                                &InstructionData::UnaryImm {
                                    opcode: ref v14,
                                    imm: v15,
                                } => {
                                    if let &Opcode::Iconst = v14 {
                                        if v2.0 == v11.0 {
                                            let v16 = C::u64_from_imm64(ctx, v15);
                                            if v16 == 0x0_u64 {
                                                let v17 = C::subsume(ctx, v7.0);
                                                // Rule at src/opts/bitops.isle line 11.
                                                returns.extend(Some(v17));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                            let mut v18 = C::inst_data_value_etor_returns::default();
                                            C::inst_data_value_etor(ctx, v7.0, &mut v18);
                                            let mut v18 = v18.into_context_iter();
                                            while let Some(v19) = v18.next(ctx) {
                                                if let &InstructionData::Binary {
                                                    opcode: ref v104,
                                                    args: ref v105,
                                                } = &v19.1 {
                                                    if let &Opcode::Bxor = v104 {
                                                        if v2.0 == v19.0 {
                                                            let v106 = C::unpack_value_array_2(ctx, v105);
                                                            let mut v116 = C::inst_data_value_etor_returns::default();
                                                            C::inst_data_value_etor(ctx, v106.1, &mut v116);
                                                            let mut v116 = v116.into_context_iter();
                                                            while let Some(v117) = v116.next(ctx) {
                                                                if let &InstructionData::UnaryImm {
                                                                    opcode: ref v258,
                                                                    imm: v259,
                                                                } = &v117.1 {
                                                                    if let &Opcode::Iconst = v258 {
                                                                        if v2.0 == v117.0 {
                                                                            let v711 = constructor_bxor(ctx, v2.0, v106.1, v7.1);
                                                                            let v712 = constructor_bxor(ctx, v2.0, v106.0, v711);
                                                                            // Rule at src/opts/cprop.isle line 186.
                                                                            returns.extend(Some(v712));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        let v608 = C::fits_in_64(ctx, v2.0);
                                        if let Some(v609) = v608 {
                                            if v11.0 == v609 {
                                                let mut v18 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v7.0, &mut v18);
                                                let mut v18 = v18.into_context_iter();
                                                while let Some(v19) = v18.next(ctx) {
                                                    if let &InstructionData::UnaryImm {
                                                        opcode: ref v22,
                                                        imm: v23,
                                                    } = &v19.1 {
                                                        if let &Opcode::Iconst = v22 {
                                                            if v11.0 == v19.0 {
                                                                let v24 = C::u64_from_imm64(ctx, v23);
                                                                let v16 = C::u64_from_imm64(ctx, v15);
                                                                let v638 = C::u64_xor(ctx, v24, v16);
                                                                let v639 = C::imm64_masked(ctx, v609, v638);
                                                                let v640 = constructor_iconst(ctx, v609, v639);
                                                                let v641 = C::subsume(ctx, v640);
                                                                // Rule at src/opts/cprop.isle line 67.
                                                                returns.extend(Some(v641));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        let v1270 = C::remat(ctx, arg0);
                                        // Rule at src/opts/remat.isle line 21.
                                        returns.extend(Some(v1270));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                                _ => {}
                            }
                        }
                        let mut v18 = C::inst_data_value_etor_returns::default();
                        C::inst_data_value_etor(ctx, v7.0, &mut v18);
                        let mut v18 = v18.into_context_iter();
                        while let Some(v19) = v18.next(ctx) {
                            match &v19.1 {
                                &InstructionData::Binary {
                                    opcode: ref v104,
                                    args: ref v105,
                                } => {
                                    if let &Opcode::Bxor = v104 {
                                        if v2.0 == v19.0 {
                                            let v106 = C::unpack_value_array_2(ctx, v105);
                                            if v7.1 == v106.1 {
                                                // Rule at src/opts/bitops.isle line 216.
                                                returns.extend(Some(v106.0));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v29,
                                    arg: v30,
                                } => {
                                    if let &Opcode::Bnot = v29 {
                                        if v7.1 == v30 {
                                            let v52 = C::ty_int(ctx, v2.0);
                                            if let Some(v53) = v52 {
                                                if v19.0 == v53 {
                                                    let v253 = constructor_iconst_s(ctx, v53, -1_i64);
                                                    let v254 = C::subsume(ctx, v253);
                                                    // Rule at src/opts/bitops.isle line 23.
                                                    returns.extend(Some(v254));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::UnaryImm {
                                    opcode: ref v22,
                                    imm: v23,
                                } => {
                                    if let &Opcode::Iconst = v22 {
                                        if v2.0 == v19.0 {
                                            let v680 = constructor_bxor(ctx, v2.0, v7.1, v7.0);
                                            // Rule at src/opts/cprop.isle line 133.
                                            returns.extend(Some(v680));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        let v1270 = C::remat(ctx, arg0);
                                        // Rule at src/opts/remat.isle line 19.
                                        returns.extend(Some(v1270));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                                _ => {}
                            }
                        }
                        if v7.0 == v7.1 {
                            let v52 = C::ty_int(ctx, v2.0);
                            if let Some(v53) = v52 {
                                let v55 = constructor_iconst_u(ctx, v53, 0x0_u64);
                                let v56 = C::subsume(ctx, v55);
                                // Rule at src/opts/bitops.isle line 17.
                                returns.extend(Some(v56));
                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                            }
                        }
                        let mut v58 = C::inst_data_value_tupled_etor_returns::default();
                        C::inst_data_value_tupled_etor(ctx, v7.1, &mut v58);
                        let mut v58 = v58.into_context_iter();
                        while let Some(v59) = v58.next(ctx) {
                            let v60 = C::iconst_sextend_etor(ctx, v59);
                            if let Some(v61) = v60 {
                                if v61.1 == -1_i64 {
                                    if v2.0 == v61.0 {
                                        let v266 = constructor_bnot(ctx, v2.0, v7.0);
                                        // Rule at src/opts/bitops.isle line 72.
                                        returns.extend(Some(v266));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                            }
                        }
                    }
                    &Opcode::Rotl => {
                        let v7 = C::unpack_value_array_2(ctx, v6);
                        let mut v10 = C::inst_data_value_etor_returns::default();
                        C::inst_data_value_etor(ctx, v7.1, &mut v10);
                        let mut v10 = v10.into_context_iter();
                        while let Some(v11) = v10.next(ctx) {
                            match &v11.1 {
                                &InstructionData::Binary {
                                    opcode: ref v147,
                                    args: ref v148,
                                } => {
                                    if let &Opcode::Iconcat = v147 {
                                        let v149 = C::unpack_value_array_2(ctx, v148);
                                        let v1421 = constructor_rotl(ctx, v2.0, v7.0, v149.0);
                                        // Rule at src/opts/shifts.isle line 142.
                                        returns.extend(Some(v1421));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v26,
                                    arg: v27,
                                } => {
                                    match v26 {
                                        &Opcode::Ireduce => {
                                            let v1021 = C::value_type(ctx, v27);
                                            let v1410 = C::fits_in_64(ctx, v1021);
                                            if let Some(v1411) = v1410 {
                                                let v1416 = constructor_rotl(ctx, v2.0, v7.0, v27);
                                                // Rule at src/opts/shifts.isle line 126.
                                                returns.extend(Some(v1416));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                        &Opcode::Uextend => {
                                            let v1416 = constructor_rotl(ctx, v2.0, v7.0, v27);
                                            // Rule at src/opts/shifts.isle line 127.
                                            returns.extend(Some(v1416));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Sextend => {
                                            let v1416 = constructor_rotl(ctx, v2.0, v7.0, v27);
                                            // Rule at src/opts/shifts.isle line 128.
                                            returns.extend(Some(v1416));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        _ => {}
                                    }
                                }
                                &InstructionData::UnaryImm {
                                    opcode: ref v14,
                                    imm: v15,
                                } => {
                                    if let &Opcode::Iconst = v14 {
                                        let mut v18 = C::inst_data_value_etor_returns::default();
                                        C::inst_data_value_etor(ctx, v7.0, &mut v18);
                                        let mut v18 = v18.into_context_iter();
                                        while let Some(v19) = v18.next(ctx) {
                                            if let &InstructionData::Binary {
                                                opcode: ref v104,
                                                args: ref v105,
                                            } = &v19.1 {
                                                match v104 {
                                                    &Opcode::Rotl => {
                                                        if v2.0 == v19.0 {
                                                            let v106 = C::unpack_value_array_2(ctx, v105);
                                                            let v1434 = constructor_iadd_uextend(ctx, v106.1, v7.1);
                                                            let v1435 = constructor_rotl(ctx, v2.0, v106.0, v1434);
                                                            // Rule at src/opts/shifts.isle line 239.
                                                            returns.extend(Some(v1435));
                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                        }
                                                    }
                                                    &Opcode::Rotr => {
                                                        if v2.0 == v19.0 {
                                                            let v106 = C::unpack_value_array_2(ctx, v105);
                                                            let v1437 = constructor_isub_uextend(ctx, v106.1, v7.1);
                                                            let v1439 = constructor_rotr(ctx, v2.0, v106.0, v1437);
                                                            // Rule at src/opts/shifts.isle line 246.
                                                            returns.extend(Some(v1439));
                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                        }
                                                    }
                                                    _ => {}
                                                }
                                            }
                                        }
                                        let v16 = C::u64_from_imm64(ctx, v15);
                                        if v16 == 0x0_u64 {
                                            if v2.0 == v11.0 {
                                                let v17 = C::subsume(ctx, v7.0);
                                                // Rule at src/opts/shifts.isle line 19.
                                                returns.extend(Some(v17));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                        let v267 = constructor_ty_shift_mask(ctx, v2.0);
                                        let v1423 = C::u64_and(ctx, v16, v267);
                                        let v1450 = C::u64_eq(ctx, v16, v1423);
                                        if v1450 == false {
                                            let v1451 = constructor_iconst_u(ctx, v11.0, v1423);
                                            let v1456 = constructor_rotl(ctx, v2.0, v7.0, v1451);
                                            // Rule at src/opts/shifts.isle line 304.
                                            returns.extend(Some(v1456));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                    }
                                }
                                _ => {}
                            }
                        }
                        let mut v18 = C::inst_data_value_etor_returns::default();
                        C::inst_data_value_etor(ctx, v7.0, &mut v18);
                        let mut v18 = v18.into_context_iter();
                        while let Some(v19) = v18.next(ctx) {
                            match &v19.1 {
                                &InstructionData::Binary {
                                    opcode: ref v104,
                                    args: ref v105,
                                } => {
                                    match v104 {
                                        &Opcode::Rotl => {
                                            if v2.0 == v19.0 {
                                                let v106 = C::unpack_value_array_2(ctx, v105);
                                                let v1440 = C::value_type(ctx, v106.1);
                                                let v1441 = C::value_type(ctx, v7.1);
                                                if v1440 == v1441 {
                                                    let v1434 = constructor_iadd_uextend(ctx, v106.1, v7.1);
                                                    let v1435 = constructor_rotl(ctx, v2.0, v106.0, v1434);
                                                    // Rule at src/opts/shifts.isle line 260.
                                                    returns.extend(Some(v1435));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                let mut v116 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v106.1, &mut v116);
                                                let mut v116 = v116.into_context_iter();
                                                while let Some(v117) = v116.next(ctx) {
                                                    if let &InstructionData::UnaryImm {
                                                        opcode: ref v258,
                                                        imm: v259,
                                                    } = &v117.1 {
                                                        if let &Opcode::Iconst = v258 {
                                                            let v1434 = constructor_iadd_uextend(ctx, v106.1, v7.1);
                                                            let v1435 = constructor_rotl(ctx, v2.0, v106.0, v1434);
                                                            // Rule at src/opts/shifts.isle line 238.
                                                            returns.extend(Some(v1435));
                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        &Opcode::Rotr => {
                                            if v2.0 == v19.0 {
                                                let v106 = C::unpack_value_array_2(ctx, v105);
                                                if v7.1 == v106.1 {
                                                    let v1433 = C::subsume(ctx, v106.0);
                                                    // Rule at src/opts/shifts.isle line 203.
                                                    returns.extend(Some(v1433));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                let v1440 = C::value_type(ctx, v106.1);
                                                let v1441 = C::value_type(ctx, v7.1);
                                                if v1440 == v1441 {
                                                    let v1437 = constructor_isub_uextend(ctx, v106.1, v7.1);
                                                    let v1439 = constructor_rotr(ctx, v2.0, v106.0, v1437);
                                                    // Rule at src/opts/shifts.isle line 265.
                                                    returns.extend(Some(v1439));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                let mut v116 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v106.1, &mut v116);
                                                let mut v116 = v116.into_context_iter();
                                                while let Some(v117) = v116.next(ctx) {
                                                    if let &InstructionData::UnaryImm {
                                                        opcode: ref v258,
                                                        imm: v259,
                                                    } = &v117.1 {
                                                        if let &Opcode::Iconst = v258 {
                                                            let v1437 = constructor_isub_uextend(ctx, v106.1, v7.1);
                                                            let v1439 = constructor_rotr(ctx, v2.0, v106.0, v1437);
                                                            // Rule at src/opts/shifts.isle line 245.
                                                            returns.extend(Some(v1439));
                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        _ => {}
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v29,
                                    arg: v30,
                                } => {
                                    if let &Opcode::Splat = v29 {
                                        if v2.0 == v19.0 {
                                            let v1425 = C::lane_type(ctx, v2.0);
                                            let v1573 = constructor_rotl(ctx, v1425, v30, v7.1);
                                            let v1574 = constructor_splat(ctx, v2.0, v1573);
                                            // Rule at src/opts/vector.isle line 68.
                                            returns.extend(Some(v1574));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                    }
                                }
                                _ => {}
                            }
                        }
                    }
                    &Opcode::Rotr => {
                        let v7 = C::unpack_value_array_2(ctx, v6);
                        let mut v10 = C::inst_data_value_etor_returns::default();
                        C::inst_data_value_etor(ctx, v7.1, &mut v10);
                        let mut v10 = v10.into_context_iter();
                        while let Some(v11) = v10.next(ctx) {
                            match &v11.1 {
                                &InstructionData::Binary {
                                    opcode: ref v147,
                                    args: ref v148,
                                } => {
                                    if let &Opcode::Iconcat = v147 {
                                        let v149 = C::unpack_value_array_2(ctx, v148);
                                        let v1420 = constructor_rotr(ctx, v2.0, v7.0, v149.0);
                                        // Rule at src/opts/shifts.isle line 141.
                                        returns.extend(Some(v1420));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v26,
                                    arg: v27,
                                } => {
                                    match v26 {
                                        &Opcode::Ireduce => {
                                            let v1021 = C::value_type(ctx, v27);
                                            let v1410 = C::fits_in_64(ctx, v1021);
                                            if let Some(v1411) = v1410 {
                                                let v1415 = constructor_rotr(ctx, v2.0, v7.0, v27);
                                                // Rule at src/opts/shifts.isle line 123.
                                                returns.extend(Some(v1415));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                        &Opcode::Uextend => {
                                            let v1415 = constructor_rotr(ctx, v2.0, v7.0, v27);
                                            // Rule at src/opts/shifts.isle line 124.
                                            returns.extend(Some(v1415));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Sextend => {
                                            let v1415 = constructor_rotr(ctx, v2.0, v7.0, v27);
                                            // Rule at src/opts/shifts.isle line 125.
                                            returns.extend(Some(v1415));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        _ => {}
                                    }
                                }
                                &InstructionData::UnaryImm {
                                    opcode: ref v14,
                                    imm: v15,
                                } => {
                                    if let &Opcode::Iconst = v14 {
                                        let mut v18 = C::inst_data_value_etor_returns::default();
                                        C::inst_data_value_etor(ctx, v7.0, &mut v18);
                                        let mut v18 = v18.into_context_iter();
                                        while let Some(v19) = v18.next(ctx) {
                                            if let &InstructionData::Binary {
                                                opcode: ref v104,
                                                args: ref v105,
                                            } = &v19.1 {
                                                match v104 {
                                                    &Opcode::Rotl => {
                                                        if v2.0 == v19.0 {
                                                            let v106 = C::unpack_value_array_2(ctx, v105);
                                                            let v1437 = constructor_isub_uextend(ctx, v106.1, v7.1);
                                                            let v1438 = constructor_rotl(ctx, v2.0, v106.0, v1437);
                                                            // Rule at src/opts/shifts.isle line 244.
                                                            returns.extend(Some(v1438));
                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                        }
                                                    }
                                                    &Opcode::Rotr => {
                                                        if v2.0 == v19.0 {
                                                            let v106 = C::unpack_value_array_2(ctx, v105);
                                                            let v1434 = constructor_iadd_uextend(ctx, v106.1, v7.1);
                                                            let v1436 = constructor_rotr(ctx, v2.0, v106.0, v1434);
                                                            // Rule at src/opts/shifts.isle line 241.
                                                            returns.extend(Some(v1436));
                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                        }
                                                    }
                                                    _ => {}
                                                }
                                            }
                                        }
                                        let v16 = C::u64_from_imm64(ctx, v15);
                                        if v16 == 0x0_u64 {
                                            if v2.0 == v11.0 {
                                                let v17 = C::subsume(ctx, v7.0);
                                                // Rule at src/opts/shifts.isle line 15.
                                                returns.extend(Some(v17));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                        let v267 = constructor_ty_shift_mask(ctx, v2.0);
                                        let v1423 = C::u64_and(ctx, v16, v267);
                                        let v1450 = C::u64_eq(ctx, v16, v1423);
                                        if v1450 == false {
                                            let v1451 = constructor_iconst_u(ctx, v11.0, v1423);
                                            let v1455 = constructor_rotr(ctx, v2.0, v7.0, v1451);
                                            // Rule at src/opts/shifts.isle line 301.
                                            returns.extend(Some(v1455));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                    }
                                }
                                _ => {}
                            }
                        }
                        let mut v18 = C::inst_data_value_etor_returns::default();
                        C::inst_data_value_etor(ctx, v7.0, &mut v18);
                        let mut v18 = v18.into_context_iter();
                        while let Some(v19) = v18.next(ctx) {
                            match &v19.1 {
                                &InstructionData::Binary {
                                    opcode: ref v104,
                                    args: ref v105,
                                } => {
                                    match v104 {
                                        &Opcode::Rotl => {
                                            if v2.0 == v19.0 {
                                                let v106 = C::unpack_value_array_2(ctx, v105);
                                                if v7.1 == v106.1 {
                                                    let v1433 = C::subsume(ctx, v106.0);
                                                    // Rule at src/opts/shifts.isle line 204.
                                                    returns.extend(Some(v1433));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                let v1440 = C::value_type(ctx, v106.1);
                                                let v1441 = C::value_type(ctx, v7.1);
                                                if v1440 == v1441 {
                                                    let v1437 = constructor_isub_uextend(ctx, v106.1, v7.1);
                                                    let v1438 = constructor_rotl(ctx, v2.0, v106.0, v1437);
                                                    // Rule at src/opts/shifts.isle line 263.
                                                    returns.extend(Some(v1438));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                let mut v116 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v106.1, &mut v116);
                                                let mut v116 = v116.into_context_iter();
                                                while let Some(v117) = v116.next(ctx) {
                                                    if let &InstructionData::UnaryImm {
                                                        opcode: ref v258,
                                                        imm: v259,
                                                    } = &v117.1 {
                                                        if let &Opcode::Iconst = v258 {
                                                            let v1437 = constructor_isub_uextend(ctx, v106.1, v7.1);
                                                            let v1438 = constructor_rotl(ctx, v2.0, v106.0, v1437);
                                                            // Rule at src/opts/shifts.isle line 243.
                                                            returns.extend(Some(v1438));
                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        &Opcode::Rotr => {
                                            if v2.0 == v19.0 {
                                                let v106 = C::unpack_value_array_2(ctx, v105);
                                                let v1440 = C::value_type(ctx, v106.1);
                                                let v1441 = C::value_type(ctx, v7.1);
                                                if v1440 == v1441 {
                                                    let v1434 = constructor_iadd_uextend(ctx, v106.1, v7.1);
                                                    let v1436 = constructor_rotr(ctx, v2.0, v106.0, v1434);
                                                    // Rule at src/opts/shifts.isle line 258.
                                                    returns.extend(Some(v1436));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                let mut v116 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v106.1, &mut v116);
                                                let mut v116 = v116.into_context_iter();
                                                while let Some(v117) = v116.next(ctx) {
                                                    if let &InstructionData::UnaryImm {
                                                        opcode: ref v258,
                                                        imm: v259,
                                                    } = &v117.1 {
                                                        if let &Opcode::Iconst = v258 {
                                                            let v1434 = constructor_iadd_uextend(ctx, v106.1, v7.1);
                                                            let v1436 = constructor_rotr(ctx, v2.0, v106.0, v1434);
                                                            // Rule at src/opts/shifts.isle line 240.
                                                            returns.extend(Some(v1436));
                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        _ => {}
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v29,
                                    arg: v30,
                                } => {
                                    if let &Opcode::Splat = v29 {
                                        if v2.0 == v19.0 {
                                            let v1425 = C::lane_type(ctx, v2.0);
                                            let v1575 = constructor_rotr(ctx, v1425, v30, v7.1);
                                            let v1576 = constructor_splat(ctx, v2.0, v1575);
                                            // Rule at src/opts/vector.isle line 71.
                                            returns.extend(Some(v1576));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                    }
                                }
                                _ => {}
                            }
                        }
                    }
                    &Opcode::Ishl => {
                        let v7 = C::unpack_value_array_2(ctx, v6);
                        let mut v10 = C::inst_data_value_etor_returns::default();
                        C::inst_data_value_etor(ctx, v7.1, &mut v10);
                        let mut v10 = v10.into_context_iter();
                        while let Some(v11) = v10.next(ctx) {
                            match &v11.1 {
                                &InstructionData::Binary {
                                    opcode: ref v147,
                                    args: ref v148,
                                } => {
                                    if let &Opcode::Iconcat = v147 {
                                        let v149 = C::unpack_value_array_2(ctx, v148);
                                        let v1417 = constructor_ishl(ctx, v2.0, v7.0, v149.0);
                                        // Rule at src/opts/shifts.isle line 138.
                                        returns.extend(Some(v1417));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v26,
                                    arg: v27,
                                } => {
                                    match v26 {
                                        &Opcode::Ireduce => {
                                            let v1021 = C::value_type(ctx, v27);
                                            let v1410 = C::fits_in_64(ctx, v1021);
                                            if let Some(v1411) = v1410 {
                                                let v1412 = constructor_ishl(ctx, v2.0, v7.0, v27);
                                                // Rule at src/opts/shifts.isle line 114.
                                                returns.extend(Some(v1412));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                        &Opcode::Uextend => {
                                            let v1412 = constructor_ishl(ctx, v2.0, v7.0, v27);
                                            // Rule at src/opts/shifts.isle line 115.
                                            returns.extend(Some(v1412));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Sextend => {
                                            let v1412 = constructor_ishl(ctx, v2.0, v7.0, v27);
                                            // Rule at src/opts/shifts.isle line 116.
                                            returns.extend(Some(v1412));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        _ => {}
                                    }
                                }
                                &InstructionData::UnaryImm {
                                    opcode: ref v14,
                                    imm: v15,
                                } => {
                                    if let &Opcode::Iconst = v14 {
                                        let mut v18 = C::inst_data_value_etor_returns::default();
                                        C::inst_data_value_etor(ctx, v7.0, &mut v18);
                                        let mut v18 = v18.into_context_iter();
                                        while let Some(v19) = v18.next(ctx) {
                                            match &v19.1 {
                                                &InstructionData::Binary {
                                                    opcode: ref v104,
                                                    args: ref v105,
                                                } => {
                                                    match v104 {
                                                        &Opcode::Ishl => {
                                                            if v2.0 == v19.0 {
                                                                let v106 = C::unpack_value_array_2(ctx, v105);
                                                                let mut v116 = C::inst_data_value_etor_returns::default();
                                                                C::inst_data_value_etor(ctx, v106.1, &mut v116);
                                                                let mut v116 = v116.into_context_iter();
                                                                while let Some(v117) = v116.next(ctx) {
                                                                    if let &InstructionData::UnaryImm {
                                                                        opcode: ref v258,
                                                                        imm: v259,
                                                                    } = &v117.1 {
                                                                        if let &Opcode::Iconst = v258 {
                                                                            let v260 = C::u64_from_imm64(ctx, v259);
                                                                            let v267 = constructor_ty_shift_mask(ctx, v2.0);
                                                                            let v1422 = C::u64_and(ctx, v260, v267);
                                                                            let v16 = C::u64_from_imm64(ctx, v15);
                                                                            let v1423 = C::u64_and(ctx, v16, v267);
                                                                            let v1424 = C::u64_wrapping_add(ctx, v1422, v1423);
                                                                            let v1425 = C::lane_type(ctx, v2.0);
                                                                            let v1426 = C::ty_bits_u64(ctx, v1425);
                                                                            let v1427 = C::u64_lt(ctx, v1424, v1426);
                                                                            if v1427 == true {
                                                                                let v1428 = constructor_iconst_u(ctx, v117.0, v1424);
                                                                                let v1429 = constructor_ishl(ctx, v2.0, v106.0, v1428);
                                                                                // Rule at src/opts/shifts.isle line 151.
                                                                                returns.extend(Some(v1429));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                            let v1385 = C::ty_bits_u64(ctx, v2.0);
                                                                            let v1432 = C::u64_lt_eq(ctx, v1385, v1424);
                                                                            if v1432 == true {
                                                                                let v995 = constructor_iconst_u(ctx, v2.0, 0x0_u64);
                                                                                let v996 = C::subsume(ctx, v995);
                                                                                // Rule at src/opts/shifts.isle line 183.
                                                                                returns.extend(Some(v996));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                let mut v109 = C::inst_data_value_etor_returns::default();
                                                                C::inst_data_value_etor(ctx, v106.0, &mut v109);
                                                                let mut v109 = v109.into_context_iter();
                                                                while let Some(v110) = v109.next(ctx) {
                                                                    if let &InstructionData::UnaryImm {
                                                                        opcode: ref v689,
                                                                        imm: v690,
                                                                    } = &v110.1 {
                                                                        if let &Opcode::Iconst = v689 {
                                                                            let v765 = constructor_ishl(ctx, v2.0, v106.0, v7.1);
                                                                            let v766 = constructor_ishl(ctx, v2.0, v765, v106.1);
                                                                            // Rule at src/opts/cprop.isle line 251.
                                                                            returns.extend(Some(v766));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        &Opcode::Ushr => {
                                                            let v608 = C::fits_in_64(ctx, v2.0);
                                                            if let Some(v609) = v608 {
                                                                if v19.0 == v609 {
                                                                    let v106 = C::unpack_value_array_2(ctx, v105);
                                                                    let mut v116 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v106.1, &mut v116);
                                                                    let mut v116 = v116.into_context_iter();
                                                                    while let Some(v117) = v116.next(ctx) {
                                                                        if let &InstructionData::UnaryImm {
                                                                            opcode: ref v258,
                                                                            imm: v259,
                                                                        } = &v117.1 {
                                                                            if let &Opcode::Iconst = v258 {
                                                                                if v15 == v259 {
                                                                                    let v1376 = C::imm64(ctx, 0xffffffffffffffff_u64);
                                                                                    let v1377 = C::imm64_shl(ctx, v609, v1376, v259);
                                                                                    let v1378 = constructor_iconst(ctx, v609, v1377);
                                                                                    let v1379 = constructor_band(ctx, v609, v106.0, v1378);
                                                                                    // Rule at src/opts/shifts.isle line 26.
                                                                                    returns.extend(Some(v1379));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        &Opcode::Sshr => {
                                                            let v608 = C::fits_in_64(ctx, v2.0);
                                                            if let Some(v609) = v608 {
                                                                if v19.0 == v609 {
                                                                    let v106 = C::unpack_value_array_2(ctx, v105);
                                                                    let mut v116 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v106.1, &mut v116);
                                                                    let mut v116 = v116.into_context_iter();
                                                                    while let Some(v117) = v116.next(ctx) {
                                                                        if let &InstructionData::UnaryImm {
                                                                            opcode: ref v258,
                                                                            imm: v259,
                                                                        } = &v117.1 {
                                                                            if let &Opcode::Iconst = v258 {
                                                                                if v15 == v259 {
                                                                                    let v1376 = C::imm64(ctx, 0xffffffffffffffff_u64);
                                                                                    let v1377 = C::imm64_shl(ctx, v609, v1376, v259);
                                                                                    let v1378 = constructor_iconst(ctx, v609, v1377);
                                                                                    let v1379 = constructor_band(ctx, v609, v106.0, v1378);
                                                                                    // Rule at src/opts/shifts.isle line 31.
                                                                                    returns.extend(Some(v1379));
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                &InstructionData::UnaryImm {
                                                    opcode: ref v22,
                                                    imm: v23,
                                                } => {
                                                    if let &Opcode::Iconst = v22 {
                                                        let v608 = C::fits_in_64(ctx, v2.0);
                                                        if let Some(v609) = v608 {
                                                            if v19.0 == v609 {
                                                                let v647 = C::imm64_shl(ctx, v609, v23, v15);
                                                                let v648 = constructor_iconst(ctx, v609, v647);
                                                                let v649 = C::subsume(ctx, v648);
                                                                // Rule at src/opts/cprop.isle line 78.
                                                                returns.extend(Some(v649));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                                _ => {}
                                            }
                                        }
                                        let v16 = C::u64_from_imm64(ctx, v15);
                                        if v16 == 0x0_u64 {
                                            if v2.0 == v11.0 {
                                                let v17 = C::subsume(ctx, v7.0);
                                                // Rule at src/opts/shifts.isle line 3.
                                                returns.extend(Some(v17));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                        let v267 = constructor_ty_shift_mask(ctx, v2.0);
                                        let v1423 = C::u64_and(ctx, v16, v267);
                                        let v1450 = C::u64_eq(ctx, v16, v1423);
                                        if v1450 == false {
                                            let v1451 = constructor_iconst_u(ctx, v11.0, v1423);
                                            let v1452 = constructor_ishl(ctx, v2.0, v7.0, v1451);
                                            // Rule at src/opts/shifts.isle line 292.
                                            returns.extend(Some(v1452));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                    }
                                }
                                _ => {}
                            }
                        }
                        let mut v18 = C::inst_data_value_etor_returns::default();
                        C::inst_data_value_etor(ctx, v7.0, &mut v18);
                        let mut v18 = v18.into_context_iter();
                        while let Some(v19) = v18.next(ctx) {
                            if let &InstructionData::Unary {
                                opcode: ref v29,
                                arg: v30,
                            } = &v19.1 {
                                if let &Opcode::Splat = v29 {
                                    if v2.0 == v19.0 {
                                        let v1425 = C::lane_type(ctx, v2.0);
                                        let v1577 = constructor_ishl(ctx, v1425, v30, v7.1);
                                        let v1578 = constructor_splat(ctx, v2.0, v1577);
                                        // Rule at src/opts/vector.isle line 74.
                                        returns.extend(Some(v1578));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                            }
                        }
                    }
                    &Opcode::Ushr => {
                        let v7 = C::unpack_value_array_2(ctx, v6);
                        let mut v10 = C::inst_data_value_etor_returns::default();
                        C::inst_data_value_etor(ctx, v7.1, &mut v10);
                        let mut v10 = v10.into_context_iter();
                        while let Some(v11) = v10.next(ctx) {
                            match &v11.1 {
                                &InstructionData::Binary {
                                    opcode: ref v147,
                                    args: ref v148,
                                } => {
                                    if let &Opcode::Iconcat = v147 {
                                        let v149 = C::unpack_value_array_2(ctx, v148);
                                        let v1418 = constructor_ushr(ctx, v2.0, v7.0, v149.0);
                                        // Rule at src/opts/shifts.isle line 139.
                                        returns.extend(Some(v1418));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v26,
                                    arg: v27,
                                } => {
                                    match v26 {
                                        &Opcode::Ireduce => {
                                            let v1021 = C::value_type(ctx, v27);
                                            let v1410 = C::fits_in_64(ctx, v1021);
                                            if let Some(v1411) = v1410 {
                                                let v1413 = constructor_ushr(ctx, v2.0, v7.0, v27);
                                                // Rule at src/opts/shifts.isle line 117.
                                                returns.extend(Some(v1413));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                        &Opcode::Uextend => {
                                            let v1413 = constructor_ushr(ctx, v2.0, v7.0, v27);
                                            // Rule at src/opts/shifts.isle line 118.
                                            returns.extend(Some(v1413));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Sextend => {
                                            let v1413 = constructor_ushr(ctx, v2.0, v7.0, v27);
                                            // Rule at src/opts/shifts.isle line 119.
                                            returns.extend(Some(v1413));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        _ => {}
                                    }
                                }
                                &InstructionData::UnaryImm {
                                    opcode: ref v14,
                                    imm: v15,
                                } => {
                                    if let &Opcode::Iconst = v14 {
                                        let mut v18 = C::inst_data_value_etor_returns::default();
                                        C::inst_data_value_etor(ctx, v7.0, &mut v18);
                                        let mut v18 = v18.into_context_iter();
                                        while let Some(v19) = v18.next(ctx) {
                                            match &v19.1 {
                                                &InstructionData::Binary {
                                                    opcode: ref v104,
                                                    args: ref v105,
                                                } => {
                                                    match v104 {
                                                        &Opcode::Imul => {
                                                            let v123 = C::ty_half_width(ctx, v2.0);
                                                            if let Some(v124) = v123 {
                                                                if v2.0 == v19.0 {
                                                                    let v106 = C::unpack_value_array_2(ctx, v105);
                                                                    let mut v109 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v106.0, &mut v109);
                                                                    let mut v109 = v109.into_context_iter();
                                                                    while let Some(v110) = v109.next(ctx) {
                                                                        if let &InstructionData::Unary {
                                                                            opcode: ref v113,
                                                                            arg: v114,
                                                                        } = &v110.1 {
                                                                            if let &Opcode::Uextend = v113 {
                                                                                let v115 = C::value_type(ctx, v114);
                                                                                let v125 = C::ty_equal(ctx, v115, v124);
                                                                                if v125 == true {
                                                                                    let v16 = C::u64_from_imm64(ctx, v15);
                                                                                    let v126 = C::ty_bits_u64(ctx, v115);
                                                                                    let v127 = C::u64_eq(ctx, v16, v126);
                                                                                    if v127 == true {
                                                                                        let mut v116 = C::inst_data_value_etor_returns::default();
                                                                                        C::inst_data_value_etor(ctx, v106.1, &mut v116);
                                                                                        let mut v116 = v116.into_context_iter();
                                                                                        while let Some(v117) = v116.next(ctx) {
                                                                                            if let &InstructionData::Unary {
                                                                                                opcode: ref v120,
                                                                                                arg: v121,
                                                                                            } = &v117.1 {
                                                                                                if let &Opcode::Uextend = v120 {
                                                                                                    let v122 = C::value_type(ctx, v121);
                                                                                                    if v115 == v122 {
                                                                                                        let v130 = constructor_umulhi(ctx, v115, v114, v121);
                                                                                                        let v131 = constructor_uextend(ctx, v2.0, v130);
                                                                                                        // Rule at src/opts/arithmetic.isle line 207.
                                                                                                        returns.extend(Some(v131));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        &Opcode::Ishl => {
                                                            let v106 = C::unpack_value_array_2(ctx, v105);
                                                            let mut v116 = C::inst_data_value_etor_returns::default();
                                                            C::inst_data_value_etor(ctx, v106.1, &mut v116);
                                                            let mut v116 = v116.into_context_iter();
                                                            while let Some(v117) = v116.next(ctx) {
                                                                if let &InstructionData::UnaryImm {
                                                                    opcode: ref v258,
                                                                    imm: v259,
                                                                } = &v117.1 {
                                                                    if let &Opcode::Iconst = v258 {
                                                                        if v15 == v259 {
                                                                            let v52 = C::ty_int(ctx, v2.0);
                                                                            if let Some(v53) = v52 {
                                                                                let v260 = C::u64_from_imm64(ctx, v259);
                                                                                let v1391 = C::u64_matches_non_zero(ctx, v260);
                                                                                if let Some(v1392) = v1391 {
                                                                                    if v1392 == true {
                                                                                        let v1393 = C::ty_bits(ctx, v53);
                                                                                        let v1394 = C::u8_into_u64(ctx, v1393);
                                                                                        let v1395 = C::u64_wrapping_sub(ctx, v1394, v260);
                                                                                        let v1396 = constructor_shift_amt_to_type(ctx, v1395);
                                                                                        if let Some(v1397) = v1396 {
                                                                                            if v19.0 == v53 {
                                                                                                let v1398 = constructor_ireduce(ctx, v1397, v106.0);
                                                                                                let v1400 = constructor_uextend(ctx, v53, v1398);
                                                                                                // Rule at src/opts/shifts.isle line 87.
                                                                                                returns.extend(Some(v1400));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                            let v608 = C::fits_in_64(ctx, v2.0);
                                                                            if let Some(v609) = v608 {
                                                                                let v1112 = C::ty_int(ctx, v609);
                                                                                if let Some(v1113) = v1112 {
                                                                                    if v19.0 == v1113 {
                                                                                        let v1380 = C::ty_mask(ctx, v1113);
                                                                                        let v1381 = C::imm64(ctx, v1380);
                                                                                        let v1382 = C::imm64_ushr(ctx, v1113, v1381, v259);
                                                                                        let v1383 = constructor_iconst(ctx, v1113, v1382);
                                                                                        let v1384 = constructor_band(ctx, v1113, v106.0, v1383);
                                                                                        // Rule at src/opts/shifts.isle line 40.
                                                                                        returns.extend(Some(v1384));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        &Opcode::Ushr => {
                                                            if v2.0 == v19.0 {
                                                                let v106 = C::unpack_value_array_2(ctx, v105);
                                                                let mut v116 = C::inst_data_value_etor_returns::default();
                                                                C::inst_data_value_etor(ctx, v106.1, &mut v116);
                                                                let mut v116 = v116.into_context_iter();
                                                                while let Some(v117) = v116.next(ctx) {
                                                                    if let &InstructionData::UnaryImm {
                                                                        opcode: ref v258,
                                                                        imm: v259,
                                                                    } = &v117.1 {
                                                                        if let &Opcode::Iconst = v258 {
                                                                            let v260 = C::u64_from_imm64(ctx, v259);
                                                                            let v267 = constructor_ty_shift_mask(ctx, v2.0);
                                                                            let v1422 = C::u64_and(ctx, v260, v267);
                                                                            let v16 = C::u64_from_imm64(ctx, v15);
                                                                            let v1423 = C::u64_and(ctx, v16, v267);
                                                                            let v1424 = C::u64_wrapping_add(ctx, v1422, v1423);
                                                                            let v1425 = C::lane_type(ctx, v2.0);
                                                                            let v1426 = C::ty_bits_u64(ctx, v1425);
                                                                            let v1427 = C::u64_lt(ctx, v1424, v1426);
                                                                            if v1427 == true {
                                                                                let v1428 = constructor_iconst_u(ctx, v117.0, v1424);
                                                                                let v1430 = constructor_ushr(ctx, v2.0, v106.0, v1428);
                                                                                // Rule at src/opts/shifts.isle line 160.
                                                                                returns.extend(Some(v1430));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                            let v1385 = C::ty_bits_u64(ctx, v2.0);
                                                                            let v1432 = C::u64_lt_eq(ctx, v1385, v1424);
                                                                            if v1432 == true {
                                                                                let v995 = constructor_iconst_u(ctx, v2.0, 0x0_u64);
                                                                                let v996 = C::subsume(ctx, v995);
                                                                                // Rule at src/opts/shifts.isle line 192.
                                                                                returns.extend(Some(v996));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                let mut v109 = C::inst_data_value_etor_returns::default();
                                                                C::inst_data_value_etor(ctx, v106.0, &mut v109);
                                                                let mut v109 = v109.into_context_iter();
                                                                while let Some(v110) = v109.next(ctx) {
                                                                    if let &InstructionData::UnaryImm {
                                                                        opcode: ref v689,
                                                                        imm: v690,
                                                                    } = &v110.1 {
                                                                        if let &Opcode::Iconst = v689 {
                                                                            let v767 = constructor_ushr(ctx, v2.0, v106.0, v7.1);
                                                                            let v768 = constructor_ushr(ctx, v2.0, v767, v106.1);
                                                                            // Rule at src/opts/cprop.isle line 253.
                                                                            returns.extend(Some(v768));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                &InstructionData::UnaryImm {
                                                    opcode: ref v22,
                                                    imm: v23,
                                                } => {
                                                    if let &Opcode::Iconst = v22 {
                                                        let v608 = C::fits_in_64(ctx, v2.0);
                                                        if let Some(v609) = v608 {
                                                            if v19.0 == v609 {
                                                                let v650 = C::imm64_ushr(ctx, v609, v23, v15);
                                                                let v651 = constructor_iconst(ctx, v609, v650);
                                                                let v652 = C::subsume(ctx, v651);
                                                                // Rule at src/opts/cprop.isle line 83.
                                                                returns.extend(Some(v652));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                                _ => {}
                                            }
                                        }
                                        let v16 = C::u64_from_imm64(ctx, v15);
                                        if v16 == 0x0_u64 {
                                            if v2.0 == v11.0 {
                                                let v17 = C::subsume(ctx, v7.0);
                                                // Rule at src/opts/shifts.isle line 7.
                                                returns.extend(Some(v17));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                        let v267 = constructor_ty_shift_mask(ctx, v2.0);
                                        let v1423 = C::u64_and(ctx, v16, v267);
                                        let v1450 = C::u64_eq(ctx, v16, v1423);
                                        if v1450 == false {
                                            let v1451 = constructor_iconst_u(ctx, v11.0, v1423);
                                            let v1453 = constructor_ushr(ctx, v2.0, v7.0, v1451);
                                            // Rule at src/opts/shifts.isle line 295.
                                            returns.extend(Some(v1453));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                    }
                                }
                                _ => {}
                            }
                        }
                        let mut v18 = C::inst_data_value_etor_returns::default();
                        C::inst_data_value_etor(ctx, v7.0, &mut v18);
                        let mut v18 = v18.into_context_iter();
                        while let Some(v19) = v18.next(ctx) {
                            match &v19.1 {
                                &InstructionData::Binary {
                                    opcode: ref v104,
                                    args: ref v105,
                                } => {
                                    if let &Opcode::Band = v104 {
                                        if v2.0 == v19.0 {
                                            let v106 = C::unpack_value_array_2(ctx, v105);
                                            let mut v109 = C::inst_data_value_etor_returns::default();
                                            C::inst_data_value_etor(ctx, v106.0, &mut v109);
                                            let mut v109 = v109.into_context_iter();
                                            while let Some(v110) = v109.next(ctx) {
                                                if let &InstructionData::Binary {
                                                    opcode: ref v293,
                                                    args: ref v294,
                                                } = &v110.1 {
                                                    if let &Opcode::Ishl = v293 {
                                                        if v2.0 == v110.0 {
                                                            let v295 = C::unpack_value_array_2(ctx, v294);
                                                            if v7.1 == v295.1 {
                                                                let v1461 = constructor_ushr(ctx, v2.0, v106.1, v295.1);
                                                                let v1462 = constructor_band(ctx, v2.0, v295.0, v1461);
                                                                // Rule at src/opts/shifts.isle line 312.
                                                                returns.extend(Some(v1462));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v29,
                                    arg: v30,
                                } => {
                                    if let &Opcode::Splat = v29 {
                                        if v2.0 == v19.0 {
                                            let v1425 = C::lane_type(ctx, v2.0);
                                            let v1579 = constructor_ushr(ctx, v1425, v30, v7.1);
                                            let v1580 = constructor_splat(ctx, v2.0, v1579);
                                            // Rule at src/opts/vector.isle line 77.
                                            returns.extend(Some(v1580));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                    }
                                }
                                _ => {}
                            }
                        }
                    }
                    &Opcode::Sshr => {
                        let v7 = C::unpack_value_array_2(ctx, v6);
                        let mut v10 = C::inst_data_value_etor_returns::default();
                        C::inst_data_value_etor(ctx, v7.1, &mut v10);
                        let mut v10 = v10.into_context_iter();
                        while let Some(v11) = v10.next(ctx) {
                            match &v11.1 {
                                &InstructionData::Binary {
                                    opcode: ref v147,
                                    args: ref v148,
                                } => {
                                    if let &Opcode::Iconcat = v147 {
                                        let v149 = C::unpack_value_array_2(ctx, v148);
                                        let v1419 = constructor_sshr(ctx, v2.0, v7.0, v149.0);
                                        // Rule at src/opts/shifts.isle line 140.
                                        returns.extend(Some(v1419));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v26,
                                    arg: v27,
                                } => {
                                    match v26 {
                                        &Opcode::Ireduce => {
                                            let v1021 = C::value_type(ctx, v27);
                                            let v1410 = C::fits_in_64(ctx, v1021);
                                            if let Some(v1411) = v1410 {
                                                let v1414 = constructor_sshr(ctx, v2.0, v7.0, v27);
                                                // Rule at src/opts/shifts.isle line 120.
                                                returns.extend(Some(v1414));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                        &Opcode::Uextend => {
                                            let v1414 = constructor_sshr(ctx, v2.0, v7.0, v27);
                                            // Rule at src/opts/shifts.isle line 121.
                                            returns.extend(Some(v1414));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Sextend => {
                                            let v1414 = constructor_sshr(ctx, v2.0, v7.0, v27);
                                            // Rule at src/opts/shifts.isle line 122.
                                            returns.extend(Some(v1414));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        _ => {}
                                    }
                                }
                                &InstructionData::UnaryImm {
                                    opcode: ref v14,
                                    imm: v15,
                                } => {
                                    if let &Opcode::Iconst = v14 {
                                        let mut v18 = C::inst_data_value_etor_returns::default();
                                        C::inst_data_value_etor(ctx, v7.0, &mut v18);
                                        let mut v18 = v18.into_context_iter();
                                        while let Some(v19) = v18.next(ctx) {
                                            match &v19.1 {
                                                &InstructionData::Binary {
                                                    opcode: ref v104,
                                                    args: ref v105,
                                                } => {
                                                    match v104 {
                                                        &Opcode::Imul => {
                                                            let v123 = C::ty_half_width(ctx, v2.0);
                                                            if let Some(v124) = v123 {
                                                                if v2.0 == v19.0 {
                                                                    let v106 = C::unpack_value_array_2(ctx, v105);
                                                                    let mut v109 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v106.0, &mut v109);
                                                                    let mut v109 = v109.into_context_iter();
                                                                    while let Some(v110) = v109.next(ctx) {
                                                                        if let &InstructionData::Unary {
                                                                            opcode: ref v113,
                                                                            arg: v114,
                                                                        } = &v110.1 {
                                                                            if let &Opcode::Sextend = v113 {
                                                                                let v115 = C::value_type(ctx, v114);
                                                                                let v125 = C::ty_equal(ctx, v115, v124);
                                                                                if v125 == true {
                                                                                    let v16 = C::u64_from_imm64(ctx, v15);
                                                                                    let v126 = C::ty_bits_u64(ctx, v115);
                                                                                    let v127 = C::u64_eq(ctx, v16, v126);
                                                                                    if v127 == true {
                                                                                        let mut v116 = C::inst_data_value_etor_returns::default();
                                                                                        C::inst_data_value_etor(ctx, v106.1, &mut v116);
                                                                                        let mut v116 = v116.into_context_iter();
                                                                                        while let Some(v117) = v116.next(ctx) {
                                                                                            if let &InstructionData::Unary {
                                                                                                opcode: ref v120,
                                                                                                arg: v121,
                                                                                            } = &v117.1 {
                                                                                                if let &Opcode::Sextend = v120 {
                                                                                                    let v122 = C::value_type(ctx, v121);
                                                                                                    if v115 == v122 {
                                                                                                        let v128 = constructor_smulhi(ctx, v115, v114, v121);
                                                                                                        let v129 = constructor_sextend(ctx, v2.0, v128);
                                                                                                        // Rule at src/opts/arithmetic.isle line 201.
                                                                                                        returns.extend(Some(v129));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        &Opcode::Bor => {
                                                            let v16 = C::u64_from_imm64(ctx, v15);
                                                            let v267 = constructor_ty_shift_mask(ctx, v2.0);
                                                            let v268 = C::u64_eq(ctx, v16, v267);
                                                            if v268 == true {
                                                                if v2.0 == v11.0 {
                                                                    if v2.0 == v19.0 {
                                                                        let v106 = C::unpack_value_array_2(ctx, v105);
                                                                        let mut v109 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v106.0, &mut v109);
                                                                        let mut v109 = v109.into_context_iter();
                                                                        while let Some(v110) = v109.next(ctx) {
                                                                            if let &InstructionData::Unary {
                                                                                opcode: ref v113,
                                                                                arg: v114,
                                                                            } = &v110.1 {
                                                                                if let &Opcode::Ineg = v113 {
                                                                                    if v2.0 == v110.0 {
                                                                                        if v106.1 == v114 {
                                                                                            let v270 = constructor_bmask(ctx, v2.0, v114);
                                                                                            // Rule at src/opts/bitops.isle line 83.
                                                                                            returns.extend(Some(v270));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                        let mut v116 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v106.1, &mut v116);
                                                                        let mut v116 = v116.into_context_iter();
                                                                        while let Some(v117) = v116.next(ctx) {
                                                                            if let &InstructionData::Unary {
                                                                                opcode: ref v120,
                                                                                arg: v121,
                                                                            } = &v117.1 {
                                                                                if let &Opcode::Ineg = v120 {
                                                                                    if v106.0 == v121 {
                                                                                        if v2.0 == v117.0 {
                                                                                            let v269 = constructor_bmask(ctx, v2.0, v106.0);
                                                                                            // Rule at src/opts/bitops.isle line 79.
                                                                                            returns.extend(Some(v269));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        &Opcode::Ishl => {
                                                            let v106 = C::unpack_value_array_2(ctx, v105);
                                                            let mut v116 = C::inst_data_value_etor_returns::default();
                                                            C::inst_data_value_etor(ctx, v106.1, &mut v116);
                                                            let mut v116 = v116.into_context_iter();
                                                            while let Some(v117) = v116.next(ctx) {
                                                                if let &InstructionData::UnaryImm {
                                                                    opcode: ref v258,
                                                                    imm: v259,
                                                                } = &v117.1 {
                                                                    if let &Opcode::Iconst = v258 {
                                                                        if v2.0 == v19.0 {
                                                                            let v16 = C::u64_from_imm64(ctx, v15);
                                                                            let v260 = C::u64_from_imm64(ctx, v259);
                                                                            if v16 == v260 {
                                                                                let mut v109 = C::inst_data_value_etor_returns::default();
                                                                                C::inst_data_value_etor(ctx, v106.0, &mut v109);
                                                                                let mut v109 = v109.into_context_iter();
                                                                                while let Some(v110) = v109.next(ctx) {
                                                                                    if let &InstructionData::Unary {
                                                                                        opcode: ref v113,
                                                                                        arg: v114,
                                                                                    } = &v110.1 {
                                                                                        match v113 {
                                                                                            &Opcode::Uextend => {
                                                                                                if v2.0 == v110.0 {
                                                                                                    let v1385 = C::ty_bits_u64(ctx, v2.0);
                                                                                                    let v115 = C::value_type(ctx, v114);
                                                                                                    let v126 = C::ty_bits_u64(ctx, v115);
                                                                                                    let v1386 = C::u64_wrapping_sub(ctx, v1385, v126);
                                                                                                    let v1387 = C::u64_eq(ctx, v260, v1386);
                                                                                                    if v1387 == true {
                                                                                                        let v1388 = constructor_sextend(ctx, v2.0, v114);
                                                                                                        // Rule at src/opts/shifts.isle line 49.
                                                                                                        returns.extend(Some(v1388));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                    let v1389 = C::u64_lt(ctx, v260, v1386);
                                                                                                    if v1389 == true {
                                                                                                        // Rule at src/opts/shifts.isle line 60.
                                                                                                        returns.extend(Some(v106.0));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                            &Opcode::Sextend => {
                                                                                                let v1385 = C::ty_bits_u64(ctx, v2.0);
                                                                                                let v115 = C::value_type(ctx, v114);
                                                                                                let v126 = C::ty_bits_u64(ctx, v115);
                                                                                                let v1386 = C::u64_wrapping_sub(ctx, v1385, v126);
                                                                                                let v1390 = C::u64_lt_eq(ctx, v260, v1386);
                                                                                                if v1390 == true {
                                                                                                    if v2.0 == v110.0 {
                                                                                                        // Rule at src/opts/shifts.isle line 70.
                                                                                                        returns.extend(Some(v106.0));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                            _ => {}
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                        if v15 == v259 {
                                                                            let v52 = C::ty_int(ctx, v2.0);
                                                                            if let Some(v53) = v52 {
                                                                                if v19.0 == v53 {
                                                                                    let v260 = C::u64_from_imm64(ctx, v259);
                                                                                    let v1391 = C::u64_matches_non_zero(ctx, v260);
                                                                                    if let Some(v1392) = v1391 {
                                                                                        if v1392 == true {
                                                                                            let v1393 = C::ty_bits(ctx, v53);
                                                                                            let v1394 = C::u8_into_u64(ctx, v1393);
                                                                                            let v1395 = C::u64_wrapping_sub(ctx, v1394, v260);
                                                                                            let v1396 = constructor_shift_amt_to_type(ctx, v1395);
                                                                                            if let Some(v1397) = v1396 {
                                                                                                let v1398 = constructor_ireduce(ctx, v1397, v106.0);
                                                                                                let v1399 = constructor_sextend(ctx, v53, v1398);
                                                                                                // Rule at src/opts/shifts.isle line 83.
                                                                                                returns.extend(Some(v1399));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        &Opcode::Sshr => {
                                                            if v2.0 == v19.0 {
                                                                let v106 = C::unpack_value_array_2(ctx, v105);
                                                                let mut v109 = C::inst_data_value_etor_returns::default();
                                                                C::inst_data_value_etor(ctx, v106.0, &mut v109);
                                                                let mut v109 = v109.into_context_iter();
                                                                while let Some(v110) = v109.next(ctx) {
                                                                    if let &InstructionData::UnaryImm {
                                                                        opcode: ref v689,
                                                                        imm: v690,
                                                                    } = &v110.1 {
                                                                        if let &Opcode::Iconst = v689 {
                                                                            let v769 = constructor_sshr(ctx, v2.0, v106.0, v7.1);
                                                                            let v770 = constructor_sshr(ctx, v2.0, v769, v106.1);
                                                                            // Rule at src/opts/cprop.isle line 255.
                                                                            returns.extend(Some(v770));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                                let mut v116 = C::inst_data_value_etor_returns::default();
                                                                C::inst_data_value_etor(ctx, v106.1, &mut v116);
                                                                let mut v116 = v116.into_context_iter();
                                                                while let Some(v117) = v116.next(ctx) {
                                                                    if let &InstructionData::UnaryImm {
                                                                        opcode: ref v258,
                                                                        imm: v259,
                                                                    } = &v117.1 {
                                                                        if let &Opcode::Iconst = v258 {
                                                                            let v260 = C::u64_from_imm64(ctx, v259);
                                                                            let v267 = constructor_ty_shift_mask(ctx, v2.0);
                                                                            let v1422 = C::u64_and(ctx, v260, v267);
                                                                            let v16 = C::u64_from_imm64(ctx, v15);
                                                                            let v1423 = C::u64_and(ctx, v16, v267);
                                                                            let v1424 = C::u64_wrapping_add(ctx, v1422, v1423);
                                                                            let v1425 = C::lane_type(ctx, v2.0);
                                                                            let v1426 = C::ty_bits_u64(ctx, v1425);
                                                                            let v1427 = C::u64_lt(ctx, v1424, v1426);
                                                                            if v1427 == true {
                                                                                let v1428 = constructor_iconst_u(ctx, v117.0, v1424);
                                                                                let v1431 = constructor_sshr(ctx, v2.0, v106.0, v1428);
                                                                                // Rule at src/opts/shifts.isle line 169.
                                                                                returns.extend(Some(v1431));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                &InstructionData::UnaryImm {
                                                    opcode: ref v22,
                                                    imm: v23,
                                                } => {
                                                    if let &Opcode::Iconst = v22 {
                                                        let v608 = C::fits_in_64(ctx, v2.0);
                                                        if let Some(v609) = v608 {
                                                            if v19.0 == v609 {
                                                                let v653 = C::imm64_sshr(ctx, v609, v23, v15);
                                                                let v654 = constructor_iconst(ctx, v609, v653);
                                                                let v655 = C::subsume(ctx, v654);
                                                                // Rule at src/opts/cprop.isle line 88.
                                                                returns.extend(Some(v655));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                                _ => {}
                                            }
                                        }
                                        let v16 = C::u64_from_imm64(ctx, v15);
                                        if v16 == 0x0_u64 {
                                            if v2.0 == v11.0 {
                                                let v17 = C::subsume(ctx, v7.0);
                                                // Rule at src/opts/shifts.isle line 11.
                                                returns.extend(Some(v17));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                        let v267 = constructor_ty_shift_mask(ctx, v2.0);
                                        let v1423 = C::u64_and(ctx, v16, v267);
                                        let v1450 = C::u64_eq(ctx, v16, v1423);
                                        if v1450 == false {
                                            let v1451 = constructor_iconst_u(ctx, v11.0, v1423);
                                            let v1454 = constructor_sshr(ctx, v2.0, v7.0, v1451);
                                            // Rule at src/opts/shifts.isle line 298.
                                            returns.extend(Some(v1454));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                    }
                                }
                                _ => {}
                            }
                        }
                        let mut v18 = C::inst_data_value_etor_returns::default();
                        C::inst_data_value_etor(ctx, v7.0, &mut v18);
                        let mut v18 = v18.into_context_iter();
                        while let Some(v19) = v18.next(ctx) {
                            if let &InstructionData::Unary {
                                opcode: ref v29,
                                arg: v30,
                            } = &v19.1 {
                                if let &Opcode::Splat = v29 {
                                    if v2.0 == v19.0 {
                                        let v1425 = C::lane_type(ctx, v2.0);
                                        let v1581 = constructor_sshr(ctx, v1425, v30, v7.1);
                                        let v1582 = constructor_splat(ctx, v2.0, v1581);
                                        // Rule at src/opts/vector.isle line 80.
                                        returns.extend(Some(v1582));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                            }
                        }
                    }
                    &Opcode::Fadd => {
                        match v2.0 {
                            F32 => {
                                let v7 = C::unpack_value_array_2(ctx, v6);
                                let mut v10 = C::inst_data_value_etor_returns::default();
                                C::inst_data_value_etor(ctx, v7.1, &mut v10);
                                let mut v10 = v10.into_context_iter();
                                while let Some(v11) = v10.next(ctx) {
                                    if v11.0 == F32 {
                                        if let &InstructionData::UnaryIeee32 {
                                            opcode: ref v812,
                                            imm: v813,
                                        } = &v11.1 {
                                            if let &Opcode::F32const = v812 {
                                                let mut v18 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v7.0, &mut v18);
                                                let mut v18 = v18.into_context_iter();
                                                while let Some(v19) = v18.next(ctx) {
                                                    if v19.0 == F32 {
                                                        if let &InstructionData::UnaryIeee32 {
                                                            opcode: ref v810,
                                                            imm: v811,
                                                        } = &v19.1 {
                                                            if let &Opcode::F32const = v810 {
                                                                let v814 = C::f32_add(ctx, v811, v813);
                                                                if let Some(v815) = v814 {
                                                                    let v816 = constructor_f32const(ctx, F32, v815);
                                                                    let v817 = C::subsume(ctx, v816);
                                                                    // Rule at src/opts/cprop.isle line 329.
                                                                    returns.extend(Some(v817));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            F64 => {
                                let v7 = C::unpack_value_array_2(ctx, v6);
                                let mut v10 = C::inst_data_value_etor_returns::default();
                                C::inst_data_value_etor(ctx, v7.1, &mut v10);
                                let mut v10 = v10.into_context_iter();
                                while let Some(v11) = v10.next(ctx) {
                                    if v11.0 == F64 {
                                        if let &InstructionData::UnaryIeee64 {
                                            opcode: ref v820,
                                            imm: v821,
                                        } = &v11.1 {
                                            if let &Opcode::F64const = v820 {
                                                let mut v18 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v7.0, &mut v18);
                                                let mut v18 = v18.into_context_iter();
                                                while let Some(v19) = v18.next(ctx) {
                                                    if v19.0 == F64 {
                                                        if let &InstructionData::UnaryIeee64 {
                                                            opcode: ref v818,
                                                            imm: v819,
                                                        } = &v19.1 {
                                                            if let &Opcode::F64const = v818 {
                                                                let v822 = C::f64_add(ctx, v819, v821);
                                                                if let Some(v823) = v822 {
                                                                    let v824 = constructor_f64const(ctx, F64, v823);
                                                                    let v825 = C::subsume(ctx, v824);
                                                                    // Rule at src/opts/cprop.isle line 332.
                                                                    returns.extend(Some(v825));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            _ => {}
                        }
                    }
                    &Opcode::Fsub => {
                        match v2.0 {
                            F32 => {
                                let v7 = C::unpack_value_array_2(ctx, v6);
                                let mut v10 = C::inst_data_value_etor_returns::default();
                                C::inst_data_value_etor(ctx, v7.1, &mut v10);
                                let mut v10 = v10.into_context_iter();
                                while let Some(v11) = v10.next(ctx) {
                                    if v11.0 == F32 {
                                        if let &InstructionData::UnaryIeee32 {
                                            opcode: ref v812,
                                            imm: v813,
                                        } = &v11.1 {
                                            if let &Opcode::F32const = v812 {
                                                let mut v18 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v7.0, &mut v18);
                                                let mut v18 = v18.into_context_iter();
                                                while let Some(v19) = v18.next(ctx) {
                                                    if v19.0 == F32 {
                                                        if let &InstructionData::UnaryIeee32 {
                                                            opcode: ref v810,
                                                            imm: v811,
                                                        } = &v19.1 {
                                                            if let &Opcode::F32const = v810 {
                                                                let v826 = C::f32_sub(ctx, v811, v813);
                                                                if let Some(v827) = v826 {
                                                                    let v828 = constructor_f32const(ctx, F32, v827);
                                                                    let v829 = C::subsume(ctx, v828);
                                                                    // Rule at src/opts/cprop.isle line 336.
                                                                    returns.extend(Some(v829));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            F64 => {
                                let v7 = C::unpack_value_array_2(ctx, v6);
                                let mut v10 = C::inst_data_value_etor_returns::default();
                                C::inst_data_value_etor(ctx, v7.1, &mut v10);
                                let mut v10 = v10.into_context_iter();
                                while let Some(v11) = v10.next(ctx) {
                                    if v11.0 == F64 {
                                        if let &InstructionData::UnaryIeee64 {
                                            opcode: ref v820,
                                            imm: v821,
                                        } = &v11.1 {
                                            if let &Opcode::F64const = v820 {
                                                let mut v18 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v7.0, &mut v18);
                                                let mut v18 = v18.into_context_iter();
                                                while let Some(v19) = v18.next(ctx) {
                                                    if v19.0 == F64 {
                                                        if let &InstructionData::UnaryIeee64 {
                                                            opcode: ref v818,
                                                            imm: v819,
                                                        } = &v19.1 {
                                                            if let &Opcode::F64const = v818 {
                                                                let v830 = C::f64_sub(ctx, v819, v821);
                                                                if let Some(v831) = v830 {
                                                                    let v832 = constructor_f64const(ctx, F64, v831);
                                                                    let v833 = C::subsume(ctx, v832);
                                                                    // Rule at src/opts/cprop.isle line 339.
                                                                    returns.extend(Some(v833));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            _ => {}
                        }
                    }
                    &Opcode::Fmul => {
                        let v7 = C::unpack_value_array_2(ctx, v6);
                        let mut v10 = C::inst_data_value_etor_returns::default();
                        C::inst_data_value_etor(ctx, v7.1, &mut v10);
                        let mut v10 = v10.into_context_iter();
                        while let Some(v11) = v10.next(ctx) {
                            match &v11.1 {
                                &InstructionData::Unary {
                                    opcode: ref v26,
                                    arg: v27,
                                } => {
                                    if let &Opcode::Fneg = v26 {
                                        if v2.0 == v11.0 {
                                            let mut v18 = C::inst_data_value_etor_returns::default();
                                            C::inst_data_value_etor(ctx, v7.0, &mut v18);
                                            let mut v18 = v18.into_context_iter();
                                            while let Some(v19) = v18.next(ctx) {
                                                if let &InstructionData::Unary {
                                                    opcode: ref v29,
                                                    arg: v30,
                                                } = &v19.1 {
                                                    if let &Opcode::Fneg = v29 {
                                                        if v2.0 == v19.0 {
                                                            let v103 = constructor_fmul(ctx, v2.0, v30, v27);
                                                            // Rule at src/opts/arithmetic.isle line 195.
                                                            returns.extend(Some(v103));
                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::UnaryIeee32 {
                                    opcode: ref v812,
                                    imm: v813,
                                } => {
                                    if let &Opcode::F32const = v812 {
                                        if v2.0 == F32 {
                                            if v11.0 == F32 {
                                                let mut v18 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v7.0, &mut v18);
                                                let mut v18 = v18.into_context_iter();
                                                while let Some(v19) = v18.next(ctx) {
                                                    if v19.0 == F32 {
                                                        if let &InstructionData::UnaryIeee32 {
                                                            opcode: ref v810,
                                                            imm: v811,
                                                        } = &v19.1 {
                                                            if let &Opcode::F32const = v810 {
                                                                let v834 = C::f32_mul(ctx, v811, v813);
                                                                if let Some(v835) = v834 {
                                                                    let v836 = constructor_f32const(ctx, F32, v835);
                                                                    let v837 = C::subsume(ctx, v836);
                                                                    // Rule at src/opts/cprop.isle line 343.
                                                                    returns.extend(Some(v837));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::UnaryIeee64 {
                                    opcode: ref v820,
                                    imm: v821,
                                } => {
                                    if let &Opcode::F64const = v820 {
                                        if v2.0 == F64 {
                                            if v11.0 == F64 {
                                                let mut v18 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v7.0, &mut v18);
                                                let mut v18 = v18.into_context_iter();
                                                while let Some(v19) = v18.next(ctx) {
                                                    if v19.0 == F64 {
                                                        if let &InstructionData::UnaryIeee64 {
                                                            opcode: ref v818,
                                                            imm: v819,
                                                        } = &v19.1 {
                                                            if let &Opcode::F64const = v818 {
                                                                let v838 = C::f64_mul(ctx, v819, v821);
                                                                if let Some(v839) = v838 {
                                                                    let v840 = constructor_f64const(ctx, F64, v839);
                                                                    let v841 = C::subsume(ctx, v840);
                                                                    // Rule at src/opts/cprop.isle line 346.
                                                                    returns.extend(Some(v841));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                                _ => {}
                            }
                        }
                    }
                    &Opcode::Fdiv => {
                        match v2.0 {
                            F32 => {
                                let v7 = C::unpack_value_array_2(ctx, v6);
                                let mut v10 = C::inst_data_value_etor_returns::default();
                                C::inst_data_value_etor(ctx, v7.1, &mut v10);
                                let mut v10 = v10.into_context_iter();
                                while let Some(v11) = v10.next(ctx) {
                                    if v11.0 == F32 {
                                        if let &InstructionData::UnaryIeee32 {
                                            opcode: ref v812,
                                            imm: v813,
                                        } = &v11.1 {
                                            if let &Opcode::F32const = v812 {
                                                let mut v18 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v7.0, &mut v18);
                                                let mut v18 = v18.into_context_iter();
                                                while let Some(v19) = v18.next(ctx) {
                                                    if v19.0 == F32 {
                                                        if let &InstructionData::UnaryIeee32 {
                                                            opcode: ref v810,
                                                            imm: v811,
                                                        } = &v19.1 {
                                                            if let &Opcode::F32const = v810 {
                                                                let v842 = C::f32_div(ctx, v811, v813);
                                                                if let Some(v843) = v842 {
                                                                    let v844 = constructor_f32const(ctx, F32, v843);
                                                                    let v845 = C::subsume(ctx, v844);
                                                                    // Rule at src/opts/cprop.isle line 350.
                                                                    returns.extend(Some(v845));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            F64 => {
                                let v7 = C::unpack_value_array_2(ctx, v6);
                                let mut v10 = C::inst_data_value_etor_returns::default();
                                C::inst_data_value_etor(ctx, v7.1, &mut v10);
                                let mut v10 = v10.into_context_iter();
                                while let Some(v11) = v10.next(ctx) {
                                    if v11.0 == F64 {
                                        if let &InstructionData::UnaryIeee64 {
                                            opcode: ref v820,
                                            imm: v821,
                                        } = &v11.1 {
                                            if let &Opcode::F64const = v820 {
                                                let mut v18 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v7.0, &mut v18);
                                                let mut v18 = v18.into_context_iter();
                                                while let Some(v19) = v18.next(ctx) {
                                                    if v19.0 == F64 {
                                                        if let &InstructionData::UnaryIeee64 {
                                                            opcode: ref v818,
                                                            imm: v819,
                                                        } = &v19.1 {
                                                            if let &Opcode::F64const = v818 {
                                                                let v846 = C::f64_div(ctx, v819, v821);
                                                                if let Some(v847) = v846 {
                                                                    let v848 = constructor_f64const(ctx, F64, v847);
                                                                    let v849 = C::subsume(ctx, v848);
                                                                    // Rule at src/opts/cprop.isle line 353.
                                                                    returns.extend(Some(v849));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            _ => {}
                        }
                    }
                    &Opcode::Fcopysign => {
                        match v2.0 {
                            F16 => {
                                let v7 = C::unpack_value_array_2(ctx, v6);
                                let mut v10 = C::inst_data_value_etor_returns::default();
                                C::inst_data_value_etor(ctx, v7.1, &mut v10);
                                let mut v10 = v10.into_context_iter();
                                while let Some(v11) = v10.next(ctx) {
                                    if v11.0 == F16 {
                                        if let &InstructionData::UnaryIeee16 {
                                            opcode: ref v892,
                                            imm: v893,
                                        } = &v11.1 {
                                            if let &Opcode::F16const = v892 {
                                                let mut v18 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v7.0, &mut v18);
                                                let mut v18 = v18.into_context_iter();
                                                while let Some(v19) = v18.next(ctx) {
                                                    if v19.0 == F16 {
                                                        if let &InstructionData::UnaryIeee16 {
                                                            opcode: ref v890,
                                                            imm: v891,
                                                        } = &v19.1 {
                                                            if let &Opcode::F16const = v890 {
                                                                let v970 = C::f16_copysign(ctx, v891, v893);
                                                                let v971 = constructor_f16const(ctx, F16, v970);
                                                                let v972 = C::subsume(ctx, v971);
                                                                // Rule at src/opts/cprop.isle line 436.
                                                                returns.extend(Some(v972));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            F32 => {
                                let v7 = C::unpack_value_array_2(ctx, v6);
                                let mut v10 = C::inst_data_value_etor_returns::default();
                                C::inst_data_value_etor(ctx, v7.1, &mut v10);
                                let mut v10 = v10.into_context_iter();
                                while let Some(v11) = v10.next(ctx) {
                                    if v11.0 == F32 {
                                        if let &InstructionData::UnaryIeee32 {
                                            opcode: ref v812,
                                            imm: v813,
                                        } = &v11.1 {
                                            if let &Opcode::F32const = v812 {
                                                let mut v18 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v7.0, &mut v18);
                                                let mut v18 = v18.into_context_iter();
                                                while let Some(v19) = v18.next(ctx) {
                                                    if v19.0 == F32 {
                                                        if let &InstructionData::UnaryIeee32 {
                                                            opcode: ref v810,
                                                            imm: v811,
                                                        } = &v19.1 {
                                                            if let &Opcode::F32const = v810 {
                                                                let v973 = C::f32_copysign(ctx, v811, v813);
                                                                let v974 = constructor_f32const(ctx, F32, v973);
                                                                let v975 = C::subsume(ctx, v974);
                                                                // Rule at src/opts/cprop.isle line 438.
                                                                returns.extend(Some(v975));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            F64 => {
                                let v7 = C::unpack_value_array_2(ctx, v6);
                                let mut v10 = C::inst_data_value_etor_returns::default();
                                C::inst_data_value_etor(ctx, v7.1, &mut v10);
                                let mut v10 = v10.into_context_iter();
                                while let Some(v11) = v10.next(ctx) {
                                    if v11.0 == F64 {
                                        if let &InstructionData::UnaryIeee64 {
                                            opcode: ref v820,
                                            imm: v821,
                                        } = &v11.1 {
                                            if let &Opcode::F64const = v820 {
                                                let mut v18 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v7.0, &mut v18);
                                                let mut v18 = v18.into_context_iter();
                                                while let Some(v19) = v18.next(ctx) {
                                                    if v19.0 == F64 {
                                                        if let &InstructionData::UnaryIeee64 {
                                                            opcode: ref v818,
                                                            imm: v819,
                                                        } = &v19.1 {
                                                            if let &Opcode::F64const = v818 {
                                                                let v976 = C::f64_copysign(ctx, v819, v821);
                                                                let v977 = constructor_f64const(ctx, F64, v976);
                                                                let v978 = C::subsume(ctx, v977);
                                                                // Rule at src/opts/cprop.isle line 440.
                                                                returns.extend(Some(v978));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            F128 => {
                                let v7 = C::unpack_value_array_2(ctx, v6);
                                let mut v10 = C::inst_data_value_etor_returns::default();
                                C::inst_data_value_etor(ctx, v7.1, &mut v10);
                                let mut v10 = v10.into_context_iter();
                                while let Some(v11) = v10.next(ctx) {
                                    if v11.0 == F128 {
                                        if let &InstructionData::UnaryConst {
                                            opcode: ref v910,
                                            constant_handle: v911,
                                        } = &v11.1 {
                                            if let &Opcode::F128const = v910 {
                                                let v912 = C::ieee128_constant_extractor(ctx, v911);
                                                if let Some(v913) = v912 {
                                                    let mut v18 = C::inst_data_value_etor_returns::default();
                                                    C::inst_data_value_etor(ctx, v7.0, &mut v18);
                                                    let mut v18 = v18.into_context_iter();
                                                    while let Some(v19) = v18.next(ctx) {
                                                        if v19.0 == F128 {
                                                            if let &InstructionData::UnaryConst {
                                                                opcode: ref v906,
                                                                constant_handle: v907,
                                                            } = &v19.1 {
                                                                if let &Opcode::F128const = v906 {
                                                                    let v908 = C::ieee128_constant_extractor(ctx, v907);
                                                                    if let Some(v909) = v908 {
                                                                        let v979 = C::f128_copysign(ctx, v909, v913);
                                                                        let v980 = C::ieee128_constant(ctx, v979);
                                                                        let v981 = constructor_f128const(ctx, F128, v980);
                                                                        let v982 = C::subsume(ctx, v981);
                                                                        // Rule at src/opts/cprop.isle line 442.
                                                                        returns.extend(Some(v982));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            _ => {}
                        }
                    }
                    &Opcode::Fmin => {
                        match v2.0 {
                            F16 => {
                                let v7 = C::unpack_value_array_2(ctx, v6);
                                let mut v10 = C::inst_data_value_etor_returns::default();
                                C::inst_data_value_etor(ctx, v7.1, &mut v10);
                                let mut v10 = v10.into_context_iter();
                                while let Some(v11) = v10.next(ctx) {
                                    if v11.0 == F16 {
                                        if let &InstructionData::UnaryIeee16 {
                                            opcode: ref v892,
                                            imm: v893,
                                        } = &v11.1 {
                                            if let &Opcode::F16const = v892 {
                                                let mut v18 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v7.0, &mut v18);
                                                let mut v18 = v18.into_context_iter();
                                                while let Some(v19) = v18.next(ctx) {
                                                    if v19.0 == F16 {
                                                        if let &InstructionData::UnaryIeee16 {
                                                            opcode: ref v890,
                                                            imm: v891,
                                                        } = &v19.1 {
                                                            if let &Opcode::F16const = v890 {
                                                                let v894 = C::f16_min(ctx, v891, v893);
                                                                if let Some(v895) = v894 {
                                                                    let v896 = constructor_f16const(ctx, F32, v895);
                                                                    let v897 = C::subsume(ctx, v896);
                                                                    // Rule at src/opts/cprop.isle line 392.
                                                                    returns.extend(Some(v897));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            F32 => {
                                let v7 = C::unpack_value_array_2(ctx, v6);
                                let mut v10 = C::inst_data_value_etor_returns::default();
                                C::inst_data_value_etor(ctx, v7.1, &mut v10);
                                let mut v10 = v10.into_context_iter();
                                while let Some(v11) = v10.next(ctx) {
                                    if v11.0 == F32 {
                                        if let &InstructionData::UnaryIeee32 {
                                            opcode: ref v812,
                                            imm: v813,
                                        } = &v11.1 {
                                            if let &Opcode::F32const = v812 {
                                                let mut v18 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v7.0, &mut v18);
                                                let mut v18 = v18.into_context_iter();
                                                while let Some(v19) = v18.next(ctx) {
                                                    if v19.0 == F32 {
                                                        if let &InstructionData::UnaryIeee32 {
                                                            opcode: ref v810,
                                                            imm: v811,
                                                        } = &v19.1 {
                                                            if let &Opcode::F32const = v810 {
                                                                let v898 = C::f32_min(ctx, v811, v813);
                                                                if let Some(v899) = v898 {
                                                                    let v900 = constructor_f32const(ctx, F32, v899);
                                                                    let v901 = C::subsume(ctx, v900);
                                                                    // Rule at src/opts/cprop.isle line 395.
                                                                    returns.extend(Some(v901));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            F64 => {
                                let v7 = C::unpack_value_array_2(ctx, v6);
                                let mut v10 = C::inst_data_value_etor_returns::default();
                                C::inst_data_value_etor(ctx, v7.1, &mut v10);
                                let mut v10 = v10.into_context_iter();
                                while let Some(v11) = v10.next(ctx) {
                                    if v11.0 == F64 {
                                        if let &InstructionData::UnaryIeee64 {
                                            opcode: ref v820,
                                            imm: v821,
                                        } = &v11.1 {
                                            if let &Opcode::F64const = v820 {
                                                let mut v18 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v7.0, &mut v18);
                                                let mut v18 = v18.into_context_iter();
                                                while let Some(v19) = v18.next(ctx) {
                                                    if v19.0 == F64 {
                                                        if let &InstructionData::UnaryIeee64 {
                                                            opcode: ref v818,
                                                            imm: v819,
                                                        } = &v19.1 {
                                                            if let &Opcode::F64const = v818 {
                                                                let v902 = C::f64_min(ctx, v819, v821);
                                                                if let Some(v903) = v902 {
                                                                    let v904 = constructor_f64const(ctx, F64, v903);
                                                                    let v905 = C::subsume(ctx, v904);
                                                                    // Rule at src/opts/cprop.isle line 398.
                                                                    returns.extend(Some(v905));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            F128 => {
                                let v7 = C::unpack_value_array_2(ctx, v6);
                                let mut v10 = C::inst_data_value_etor_returns::default();
                                C::inst_data_value_etor(ctx, v7.1, &mut v10);
                                let mut v10 = v10.into_context_iter();
                                while let Some(v11) = v10.next(ctx) {
                                    if v11.0 == F128 {
                                        if let &InstructionData::UnaryConst {
                                            opcode: ref v910,
                                            constant_handle: v911,
                                        } = &v11.1 {
                                            if let &Opcode::F128const = v910 {
                                                let v912 = C::ieee128_constant_extractor(ctx, v911);
                                                if let Some(v913) = v912 {
                                                    let mut v18 = C::inst_data_value_etor_returns::default();
                                                    C::inst_data_value_etor(ctx, v7.0, &mut v18);
                                                    let mut v18 = v18.into_context_iter();
                                                    while let Some(v19) = v18.next(ctx) {
                                                        if v19.0 == F128 {
                                                            if let &InstructionData::UnaryConst {
                                                                opcode: ref v906,
                                                                constant_handle: v907,
                                                            } = &v19.1 {
                                                                if let &Opcode::F128const = v906 {
                                                                    let v908 = C::ieee128_constant_extractor(ctx, v907);
                                                                    if let Some(v909) = v908 {
                                                                        let v914 = C::f128_min(ctx, v909, v913);
                                                                        if let Some(v915) = v914 {
                                                                            let v917 = C::ieee128_constant(ctx, v915);
                                                                            let v918 = constructor_f128const(ctx, F128, v917);
                                                                            let v919 = C::subsume(ctx, v918);
                                                                            // Rule at src/opts/cprop.isle line 401.
                                                                            returns.extend(Some(v919));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            _ => {}
                        }
                    }
                    &Opcode::Fmax => {
                        match v2.0 {
                            F16 => {
                                let v7 = C::unpack_value_array_2(ctx, v6);
                                let mut v10 = C::inst_data_value_etor_returns::default();
                                C::inst_data_value_etor(ctx, v7.1, &mut v10);
                                let mut v10 = v10.into_context_iter();
                                while let Some(v11) = v10.next(ctx) {
                                    if v11.0 == F16 {
                                        if let &InstructionData::UnaryIeee16 {
                                            opcode: ref v892,
                                            imm: v893,
                                        } = &v11.1 {
                                            if let &Opcode::F16const = v892 {
                                                let mut v18 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v7.0, &mut v18);
                                                let mut v18 = v18.into_context_iter();
                                                while let Some(v19) = v18.next(ctx) {
                                                    if v19.0 == F16 {
                                                        if let &InstructionData::UnaryIeee16 {
                                                            opcode: ref v890,
                                                            imm: v891,
                                                        } = &v19.1 {
                                                            if let &Opcode::F16const = v890 {
                                                                let v920 = C::f16_max(ctx, v891, v893);
                                                                if let Some(v921) = v920 {
                                                                    let v923 = constructor_f16const(ctx, F16, v921);
                                                                    let v924 = C::subsume(ctx, v923);
                                                                    // Rule at src/opts/cprop.isle line 405.
                                                                    returns.extend(Some(v924));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            F32 => {
                                let v7 = C::unpack_value_array_2(ctx, v6);
                                let mut v10 = C::inst_data_value_etor_returns::default();
                                C::inst_data_value_etor(ctx, v7.1, &mut v10);
                                let mut v10 = v10.into_context_iter();
                                while let Some(v11) = v10.next(ctx) {
                                    if v11.0 == F32 {
                                        if let &InstructionData::UnaryIeee32 {
                                            opcode: ref v812,
                                            imm: v813,
                                        } = &v11.1 {
                                            if let &Opcode::F32const = v812 {
                                                let mut v18 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v7.0, &mut v18);
                                                let mut v18 = v18.into_context_iter();
                                                while let Some(v19) = v18.next(ctx) {
                                                    if v19.0 == F32 {
                                                        if let &InstructionData::UnaryIeee32 {
                                                            opcode: ref v810,
                                                            imm: v811,
                                                        } = &v19.1 {
                                                            if let &Opcode::F32const = v810 {
                                                                let v925 = C::f32_max(ctx, v811, v813);
                                                                if let Some(v926) = v925 {
                                                                    let v927 = constructor_f32const(ctx, F32, v926);
                                                                    let v928 = C::subsume(ctx, v927);
                                                                    // Rule at src/opts/cprop.isle line 408.
                                                                    returns.extend(Some(v928));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            F64 => {
                                let v7 = C::unpack_value_array_2(ctx, v6);
                                let mut v10 = C::inst_data_value_etor_returns::default();
                                C::inst_data_value_etor(ctx, v7.1, &mut v10);
                                let mut v10 = v10.into_context_iter();
                                while let Some(v11) = v10.next(ctx) {
                                    if v11.0 == F64 {
                                        if let &InstructionData::UnaryIeee64 {
                                            opcode: ref v820,
                                            imm: v821,
                                        } = &v11.1 {
                                            if let &Opcode::F64const = v820 {
                                                let mut v18 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v7.0, &mut v18);
                                                let mut v18 = v18.into_context_iter();
                                                while let Some(v19) = v18.next(ctx) {
                                                    if v19.0 == F64 {
                                                        if let &InstructionData::UnaryIeee64 {
                                                            opcode: ref v818,
                                                            imm: v819,
                                                        } = &v19.1 {
                                                            if let &Opcode::F64const = v818 {
                                                                let v929 = C::f64_max(ctx, v819, v821);
                                                                if let Some(v930) = v929 {
                                                                    let v931 = constructor_f64const(ctx, F64, v930);
                                                                    let v932 = C::subsume(ctx, v931);
                                                                    // Rule at src/opts/cprop.isle line 411.
                                                                    returns.extend(Some(v932));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            F128 => {
                                let v7 = C::unpack_value_array_2(ctx, v6);
                                let mut v10 = C::inst_data_value_etor_returns::default();
                                C::inst_data_value_etor(ctx, v7.1, &mut v10);
                                let mut v10 = v10.into_context_iter();
                                while let Some(v11) = v10.next(ctx) {
                                    if v11.0 == F128 {
                                        if let &InstructionData::UnaryConst {
                                            opcode: ref v910,
                                            constant_handle: v911,
                                        } = &v11.1 {
                                            if let &Opcode::F128const = v910 {
                                                let v912 = C::ieee128_constant_extractor(ctx, v911);
                                                if let Some(v913) = v912 {
                                                    let mut v18 = C::inst_data_value_etor_returns::default();
                                                    C::inst_data_value_etor(ctx, v7.0, &mut v18);
                                                    let mut v18 = v18.into_context_iter();
                                                    while let Some(v19) = v18.next(ctx) {
                                                        if v19.0 == F128 {
                                                            if let &InstructionData::UnaryConst {
                                                                opcode: ref v906,
                                                                constant_handle: v907,
                                                            } = &v19.1 {
                                                                if let &Opcode::F128const = v906 {
                                                                    let v908 = C::ieee128_constant_extractor(ctx, v907);
                                                                    if let Some(v909) = v908 {
                                                                        let v933 = C::f128_max(ctx, v909, v913);
                                                                        if let Some(v934) = v933 {
                                                                            let v935 = C::ieee128_constant(ctx, v934);
                                                                            let v936 = constructor_f128const(ctx, F128, v935);
                                                                            let v937 = C::subsume(ctx, v936);
                                                                            // Rule at src/opts/cprop.isle line 414.
                                                                            returns.extend(Some(v937));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            _ => {}
                        }
                    }
                    &Opcode::Iconcat => {
                        if v2.0 == I128 {
                            let v7 = C::unpack_value_array_2(ctx, v6);
                            let mut v10 = C::inst_data_value_etor_returns::default();
                            C::inst_data_value_etor(ctx, v7.1, &mut v10);
                            let mut v10 = v10.into_context_iter();
                            while let Some(v11) = v10.next(ctx) {
                                match &v11.1 {
                                    &InstructionData::Binary {
                                        opcode: ref v147,
                                        args: ref v148,
                                    } => {
                                        if let &Opcode::Sshr = v147 {
                                            let v149 = C::unpack_value_array_2(ctx, v148);
                                            if v7.0 == v149.0 {
                                                let mut v365 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v149.1, &mut v365);
                                                let mut v365 = v365.into_context_iter();
                                                while let Some(v366) = v365.next(ctx) {
                                                    if let &InstructionData::UnaryImm {
                                                        opcode: ref v771,
                                                        imm: v772,
                                                    } = &v366.1 {
                                                        if let &Opcode::Iconst = v771 {
                                                            let v1041 = C::u64_from_imm64(ctx, v772);
                                                            if v1041 == 0x3f_u64 {
                                                                let v1042 = constructor_sextend(ctx, I128, v7.0);
                                                                // Rule at src/opts/extends.isle line 94.
                                                                returns.extend(Some(v1042));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    &InstructionData::UnaryImm {
                                        opcode: ref v14,
                                        imm: v15,
                                    } => {
                                        if let &Opcode::Iconst = v14 {
                                            let v16 = C::u64_from_imm64(ctx, v15);
                                            if v16 == 0x0_u64 {
                                                let v1040 = constructor_uextend(ctx, I128, v7.0);
                                                // Rule at src/opts/extends.isle line 93.
                                                returns.extend(Some(v1040));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                    }
                                    _ => {}
                                }
                            }
                        }
                    }
                    _ => {}
                }
            }
            &InstructionData::IntCompare {
                opcode: ref v161,
                args: ref v162,
                cond: ref v163,
            } => {
                if let &Opcode::Icmp = v161 {
                    match v163 {
                        &IntCC::Equal => {
                            let v164 = C::unpack_value_array_2(ctx, v162);
                            let mut v167 = C::inst_data_value_etor_returns::default();
                            C::inst_data_value_etor(ctx, v164.0, &mut v167);
                            let mut v167 = v167.into_context_iter();
                            while let Some(v168) = v167.next(ctx) {
                                match &v168.1 {
                                    &InstructionData::Binary {
                                        opcode: ref v212,
                                        args: ref v213,
                                    } => {
                                        match v212 {
                                            &Opcode::Iadd => {
                                                let mut v174 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v164.1, &mut v174);
                                                let mut v174 = v174.into_context_iter();
                                                while let Some(v175) = v174.next(ctx) {
                                                    match &v175.1 {
                                                        &InstructionData::Binary {
                                                            opcode: ref v178,
                                                            args: ref v179,
                                                        } => {
                                                            if let &Opcode::Iadd = v178 {
                                                                let v180 = C::unpack_value_array_2(ctx, v179);
                                                                let v214 = C::unpack_value_array_2(ctx, v213);
                                                                if v180.0 == v214.0 {
                                                                    let v1051 = constructor_eq(ctx, v2.0, v214.1, v180.1);
                                                                    let v1052 = C::subsume(ctx, v1051);
                                                                    // Rule at src/opts/icmp.isle line 26.
                                                                    returns.extend(Some(v1052));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                if v180.0 == v214.1 {
                                                                    let v1047 = constructor_eq(ctx, v2.0, v214.0, v180.1);
                                                                    let v1048 = C::subsume(ctx, v1047);
                                                                    // Rule at src/opts/icmp.isle line 22.
                                                                    returns.extend(Some(v1048));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                if v180.1 == v214.0 {
                                                                    let v1049 = constructor_eq(ctx, v2.0, v214.1, v180.0);
                                                                    let v1050 = C::subsume(ctx, v1049);
                                                                    // Rule at src/opts/icmp.isle line 24.
                                                                    returns.extend(Some(v1050));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                if v180.1 == v214.1 {
                                                                    let v1045 = constructor_eq(ctx, v2.0, v214.0, v180.0);
                                                                    let v1046 = C::subsume(ctx, v1045);
                                                                    // Rule at src/opts/icmp.isle line 20.
                                                                    returns.extend(Some(v1046));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                let mut v183 = C::inst_data_value_etor_returns::default();
                                                                C::inst_data_value_etor(ctx, v180.1, &mut v183);
                                                                let mut v183 = v183.into_context_iter();
                                                                while let Some(v184) = v183.next(ctx) {
                                                                    if let &InstructionData::UnaryImm {
                                                                        opcode: ref v187,
                                                                        imm: v188,
                                                                    } = &v184.1 {
                                                                        if let &Opcode::Iconst = v187 {
                                                                            let mut v217 = C::inst_data_value_etor_returns::default();
                                                                            C::inst_data_value_etor(ctx, v214.1, &mut v217);
                                                                            let mut v217 = v217.into_context_iter();
                                                                            while let Some(v218) = v217.next(ctx) {
                                                                                if let &InstructionData::UnaryImm {
                                                                                    opcode: ref v221,
                                                                                    imm: v222,
                                                                                } = &v218.1 {
                                                                                    if let &Opcode::Iconst = v221 {
                                                                                        let v726 = constructor_isub(ctx, v175.0, v180.1, v214.1);
                                                                                        let v727 = constructor_iadd(ctx, v168.0, v180.0, v726);
                                                                                        let v728 = constructor_eq(ctx, v2.0, v214.0, v727);
                                                                                        // Rule at src/opts/cprop.isle line 207.
                                                                                        returns.extend(Some(v728));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        &InstructionData::UnaryImm {
                                                            opcode: ref v224,
                                                            imm: v225,
                                                        } => {
                                                            if let &Opcode::Iconst = v224 {
                                                                let v214 = C::unpack_value_array_2(ctx, v213);
                                                                let mut v217 = C::inst_data_value_etor_returns::default();
                                                                C::inst_data_value_etor(ctx, v214.1, &mut v217);
                                                                let mut v217 = v217.into_context_iter();
                                                                while let Some(v218) = v217.next(ctx) {
                                                                    if let &InstructionData::UnaryImm {
                                                                        opcode: ref v221,
                                                                        imm: v222,
                                                                    } = &v218.1 {
                                                                        if let &Opcode::Iconst = v221 {
                                                                            let v720 = constructor_isub(ctx, v168.0, v164.1, v214.1);
                                                                            let v721 = constructor_eq(ctx, v2.0, v214.0, v720);
                                                                            // Rule at src/opts/cprop.isle line 197.
                                                                            returns.extend(Some(v721));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                            }
                                            &Opcode::Isub => {
                                                let v214 = C::unpack_value_array_2(ctx, v213);
                                                let mut v217 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v214.1, &mut v217);
                                                let mut v217 = v217.into_context_iter();
                                                while let Some(v218) = v217.next(ctx) {
                                                    match &v218.1 {
                                                        &InstructionData::IntCompare {
                                                            opcode: ref v1519,
                                                            args: ref v1520,
                                                            cond: ref v1521,
                                                        } => {
                                                            if let &Opcode::Icmp = v1519 {
                                                                match v1521 {
                                                                    &IntCC::SignedLessThan => {
                                                                        if v168.0 == I8 {
                                                                            let mut v234 = C::inst_data_value_etor_returns::default();
                                                                            C::inst_data_value_etor(ctx, v214.0, &mut v234);
                                                                            let mut v234 = v234.into_context_iter();
                                                                            while let Some(v235) = v234.next(ctx) {
                                                                                if let &InstructionData::IntCompare {
                                                                                    opcode: ref v1513,
                                                                                    args: ref v1514,
                                                                                    cond: ref v1515,
                                                                                } = &v235.1 {
                                                                                    if let &Opcode::Icmp = v1513 {
                                                                                        if let &IntCC::SignedGreaterThan = v1515 {
                                                                                            if v218.0 == v235.0 {
                                                                                                let v1516 = C::unpack_value_array_2(ctx, v1514);
                                                                                                let v1522 = C::unpack_value_array_2(ctx, v1520);
                                                                                                if v1516.0 == v1522.0 {
                                                                                                    if v1516.1 == v1522.1 {
                                                                                                        let mut v1000 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                        C::inst_data_value_tupled_etor(ctx, v164.1, &mut v1000);
                                                                                                        let mut v1000 = v1000.into_context_iter();
                                                                                                        while let Some(v1001) = v1000.next(ctx) {
                                                                                                            let v1002 = C::iconst_sextend_etor(ctx, v1001);
                                                                                                            if let Some(v1003) = v1002 {
                                                                                                                match v1003.1 {
                                                                                                                    -1_i64 => {
                                                                                                                        let v1527 = constructor_slt(ctx, v235.0, v1516.0, v1516.1);
                                                                                                                        // Rule at src/opts/spaceship.isle line 178.
                                                                                                                        returns.extend(Some(v1527));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                    0_i64 => {
                                                                                                                        let v1525 = constructor_eq(ctx, v235.0, v1516.0, v1516.1);
                                                                                                                        // Rule at src/opts/spaceship.isle line 145.
                                                                                                                        returns.extend(Some(v1525));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                    1_i64 => {
                                                                                                                        let v1531 = constructor_sgt(ctx, v235.0, v1516.0, v1516.1);
                                                                                                                        // Rule at src/opts/spaceship.isle line 186.
                                                                                                                        returns.extend(Some(v1531));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                    _ => {}
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::UnsignedLessThan => {
                                                                        if v168.0 == I8 {
                                                                            let mut v234 = C::inst_data_value_etor_returns::default();
                                                                            C::inst_data_value_etor(ctx, v214.0, &mut v234);
                                                                            let mut v234 = v234.into_context_iter();
                                                                            while let Some(v235) = v234.next(ctx) {
                                                                                if let &InstructionData::IntCompare {
                                                                                    opcode: ref v1513,
                                                                                    args: ref v1514,
                                                                                    cond: ref v1515,
                                                                                } = &v235.1 {
                                                                                    if let &Opcode::Icmp = v1513 {
                                                                                        if let &IntCC::UnsignedGreaterThan = v1515 {
                                                                                            if v218.0 == v235.0 {
                                                                                                let v1516 = C::unpack_value_array_2(ctx, v1514);
                                                                                                let v1522 = C::unpack_value_array_2(ctx, v1520);
                                                                                                if v1516.0 == v1522.0 {
                                                                                                    if v1516.1 == v1522.1 {
                                                                                                        let mut v1000 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                        C::inst_data_value_tupled_etor(ctx, v164.1, &mut v1000);
                                                                                                        let mut v1000 = v1000.into_context_iter();
                                                                                                        while let Some(v1001) = v1000.next(ctx) {
                                                                                                            let v1002 = C::iconst_sextend_etor(ctx, v1001);
                                                                                                            if let Some(v1003) = v1002 {
                                                                                                                match v1003.1 {
                                                                                                                    -1_i64 => {
                                                                                                                        let v1528 = constructor_ult(ctx, v235.0, v1516.0, v1516.1);
                                                                                                                        // Rule at src/opts/spaceship.isle line 180.
                                                                                                                        returns.extend(Some(v1528));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                    0_i64 => {
                                                                                                                        let v1525 = constructor_eq(ctx, v235.0, v1516.0, v1516.1);
                                                                                                                        // Rule at src/opts/spaceship.isle line 147.
                                                                                                                        returns.extend(Some(v1525));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                    1_i64 => {
                                                                                                                        let v1532 = constructor_ugt(ctx, v235.0, v1516.0, v1516.1);
                                                                                                                        // Rule at src/opts/spaceship.isle line 188.
                                                                                                                        returns.extend(Some(v1532));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                    _ => {}
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    _ => {}
                                                                }
                                                            }
                                                        }
                                                        &InstructionData::UnaryImm {
                                                            opcode: ref v221,
                                                            imm: v222,
                                                        } => {
                                                            if let &Opcode::Iconst = v221 {
                                                                let mut v174 = C::inst_data_value_etor_returns::default();
                                                                C::inst_data_value_etor(ctx, v164.1, &mut v174);
                                                                let mut v174 = v174.into_context_iter();
                                                                while let Some(v175) = v174.next(ctx) {
                                                                    if let &InstructionData::UnaryImm {
                                                                        opcode: ref v224,
                                                                        imm: v225,
                                                                    } = &v175.1 {
                                                                        if let &Opcode::Iconst = v224 {
                                                                            let v723 = constructor_iadd(ctx, v168.0, v164.1, v214.1);
                                                                            let v724 = constructor_eq(ctx, v2.0, v214.0, v723);
                                                                            // Rule at src/opts/cprop.isle line 202.
                                                                            returns.extend(Some(v724));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                let mut v174 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v164.1, &mut v174);
                                                let mut v174 = v174.into_context_iter();
                                                while let Some(v175) = v174.next(ctx) {
                                                    if let &InstructionData::Binary {
                                                        opcode: ref v178,
                                                        args: ref v179,
                                                    } = &v175.1 {
                                                        if let &Opcode::Isub = v178 {
                                                            let v180 = C::unpack_value_array_2(ctx, v179);
                                                            let v1061 = constructor_iadd(ctx, v168.0, v214.0, v180.1);
                                                            let v1062 = constructor_iadd(ctx, v175.0, v180.0, v214.1);
                                                            let v1063 = constructor_eq(ctx, v2.0, v1061, v1062);
                                                            // Rule at src/opts/icmp.isle line 40.
                                                            returns.extend(Some(v1063));
                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                        }
                                                    }
                                                }
                                            }
                                            &Opcode::Imul => {
                                                let mut v174 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v164.1, &mut v174);
                                                let mut v174 = v174.into_context_iter();
                                                while let Some(v175) = v174.next(ctx) {
                                                    if let &InstructionData::UnaryImm {
                                                        opcode: ref v224,
                                                        imm: v225,
                                                    } = &v175.1 {
                                                        if let &Opcode::Iconst = v224 {
                                                            if v168.0 == v175.0 {
                                                                let v214 = C::unpack_value_array_2(ctx, v213);
                                                                let mut v217 = C::inst_data_value_etor_returns::default();
                                                                C::inst_data_value_etor(ctx, v214.1, &mut v217);
                                                                let mut v217 = v217.into_context_iter();
                                                                while let Some(v218) = v217.next(ctx) {
                                                                    if let &InstructionData::UnaryImm {
                                                                        opcode: ref v221,
                                                                        imm: v222,
                                                                    } = &v218.1 {
                                                                        if let &Opcode::Iconst = v221 {
                                                                            let v226 = C::u64_from_imm64(ctx, v225);
                                                                            let v223 = C::u64_from_imm64(ctx, v222);
                                                                            let v227 = C::u64_checked_rem(ctx, v226, v223);
                                                                            if let Some(v228) = v227 {
                                                                                if v228 == 0x0_u64 {
                                                                                    let v229 = C::u64_rem(ctx, v223, 0x2_u64);
                                                                                    if v229 == 0x1_u64 {
                                                                                        if v168.0 == v218.0 {
                                                                                            let v230 = C::u64_div(ctx, v226, v223);
                                                                                            let v231 = C::imm64(ctx, v230);
                                                                                            let v232 = constructor_iconst(ctx, v168.0, v231);
                                                                                            let v250 = constructor_eq(ctx, v2.0, v214.0, v232);
                                                                                            // Rule at src/opts/arithmetic.isle line 284.
                                                                                            returns.extend(Some(v250));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                let mut v234 = C::inst_data_value_etor_returns::default();
                                                                C::inst_data_value_etor(ctx, v214.0, &mut v234);
                                                                let mut v234 = v234.into_context_iter();
                                                                while let Some(v235) = v234.next(ctx) {
                                                                    if let &InstructionData::UnaryImm {
                                                                        opcode: ref v238,
                                                                        imm: v239,
                                                                    } = &v235.1 {
                                                                        if let &Opcode::Iconst = v238 {
                                                                            let v226 = C::u64_from_imm64(ctx, v225);
                                                                            let v240 = C::u64_from_imm64(ctx, v239);
                                                                            let v241 = C::u64_checked_rem(ctx, v226, v240);
                                                                            if let Some(v242) = v241 {
                                                                                if v242 == 0x0_u64 {
                                                                                    let v243 = C::u64_rem(ctx, v240, 0x2_u64);
                                                                                    if v243 == 0x1_u64 {
                                                                                        if v168.0 == v235.0 {
                                                                                            let v244 = C::u64_div(ctx, v226, v240);
                                                                                            let v245 = C::imm64(ctx, v244);
                                                                                            let v246 = constructor_iconst(ctx, v168.0, v245);
                                                                                            let v251 = constructor_eq(ctx, v2.0, v214.1, v246);
                                                                                            // Rule at src/opts/arithmetic.isle line 289.
                                                                                            returns.extend(Some(v251));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                            _ => {}
                                        }
                                    }
                                    &InstructionData::Ternary {
                                        opcode: ref v1193,
                                        args: ref v1194,
                                    } => {
                                        if let &Opcode::Select = v1193 {
                                            let mut v174 = C::inst_data_value_etor_returns::default();
                                            C::inst_data_value_etor(ctx, v164.1, &mut v174);
                                            let mut v174 = v174.into_context_iter();
                                            while let Some(v175) = v174.next(ctx) {
                                                if let &InstructionData::UnaryImm {
                                                    opcode: ref v224,
                                                    imm: v225,
                                                } = &v175.1 {
                                                    if let &Opcode::Iconst = v224 {
                                                        let v1195 = C::unpack_value_array_3(ctx, v1194);
                                                        let mut v1252 = C::inst_data_value_etor_returns::default();
                                                        C::inst_data_value_etor(ctx, v1195.1, &mut v1252);
                                                        let mut v1252 = v1252.into_context_iter();
                                                        while let Some(v1253) = v1252.next(ctx) {
                                                            if let &InstructionData::UnaryImm {
                                                                opcode: ref v1256,
                                                                imm: v1257,
                                                            } = &v1253.1 {
                                                                if let &Opcode::Iconst = v1256 {
                                                                    let mut v1259 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v1195.2, &mut v1259);
                                                                    let mut v1259 = v1259.into_context_iter();
                                                                    while let Some(v1260) = v1259.next(ctx) {
                                                                        if let &InstructionData::UnaryImm {
                                                                            opcode: ref v1263,
                                                                            imm: v1264,
                                                                        } = &v1260.1 {
                                                                            if let &Opcode::Iconst = v1263 {
                                                                                let v1258 = C::u64_from_imm64(ctx, v1257);
                                                                                let v1265 = C::u64_from_imm64(ctx, v1264);
                                                                                let v1266 = C::u64_eq(ctx, v1258, v1265);
                                                                                if v1266 == false {
                                                                                    let v226 = C::u64_from_imm64(ctx, v225);
                                                                                    if v226 == v1258 {
                                                                                        let v1251 = C::value_type(ctx, v1195.0);
                                                                                        let v1267 = constructor_iconst_u(ctx, v1251, 0x0_u64);
                                                                                        let v1268 = constructor_ne(ctx, v168.0, v1195.0, v1267);
                                                                                        // Rule at src/opts/icmp.isle line 388.
                                                                                        returns.extend(Some(v1268));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                    if v226 == v1265 {
                                                                                        let v1251 = C::value_type(ctx, v1195.0);
                                                                                        let v1267 = constructor_iconst_u(ctx, v1251, 0x0_u64);
                                                                                        let v1269 = constructor_eq(ctx, v168.0, v1195.0, v1267);
                                                                                        // Rule at src/opts/icmp.isle line 396.
                                                                                        returns.extend(Some(v1269));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    &InstructionData::Unary {
                                        opcode: ref v992,
                                        arg: v993,
                                    } => {
                                        if let &Opcode::Sextend = v992 {
                                            let mut v1000 = C::inst_data_value_tupled_etor_returns::default();
                                            C::inst_data_value_tupled_etor(ctx, v164.1, &mut v1000);
                                            let mut v1000 = v1000.into_context_iter();
                                            while let Some(v1001) = v1000.next(ctx) {
                                                let v1002 = C::iconst_sextend_etor(ctx, v1001);
                                                if let Some(v1003) = v1002 {
                                                    if v1003.1 == 0_i64 {
                                                        let v994 = C::value_type(ctx, v993);
                                                        let v1007 = constructor_iconst_s(ctx, v994, 0_i64);
                                                        let v1008 = constructor_eq(ctx, v994, v993, v1007);
                                                        // Rule at src/opts/extends.isle line 39.
                                                        returns.extend(Some(v1008));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    &InstructionData::UnaryImm {
                                        opcode: ref v171,
                                        imm: v172,
                                    } => {
                                        if let &Opcode::Iconst = v171 {
                                            let mut v174 = C::inst_data_value_etor_returns::default();
                                            C::inst_data_value_etor(ctx, v164.1, &mut v174);
                                            let mut v174 = v174.into_context_iter();
                                            while let Some(v175) = v174.next(ctx) {
                                                if let &InstructionData::Binary {
                                                    opcode: ref v178,
                                                    args: ref v179,
                                                } = &v175.1 {
                                                    if let &Opcode::Imul = v178 {
                                                        if v168.0 == v175.0 {
                                                            let v180 = C::unpack_value_array_2(ctx, v179);
                                                            let mut v183 = C::inst_data_value_etor_returns::default();
                                                            C::inst_data_value_etor(ctx, v180.1, &mut v183);
                                                            let mut v183 = v183.into_context_iter();
                                                            while let Some(v184) = v183.next(ctx) {
                                                                if let &InstructionData::UnaryImm {
                                                                    opcode: ref v187,
                                                                    imm: v188,
                                                                } = &v184.1 {
                                                                    if let &Opcode::Iconst = v187 {
                                                                        let v173 = C::u64_from_imm64(ctx, v172);
                                                                        let v189 = C::u64_from_imm64(ctx, v188);
                                                                        let v190 = C::u64_checked_rem(ctx, v173, v189);
                                                                        if let Some(v191) = v190 {
                                                                            if v191 == 0x0_u64 {
                                                                                let v193 = C::u64_rem(ctx, v189, 0x2_u64);
                                                                                if v193 == 0x1_u64 {
                                                                                    if v168.0 == v184.0 {
                                                                                        let v194 = C::u64_div(ctx, v173, v189);
                                                                                        let v195 = C::imm64(ctx, v194);
                                                                                        let v196 = constructor_iconst(ctx, v168.0, v195);
                                                                                        let v248 = constructor_eq(ctx, v2.0, v180.0, v196);
                                                                                        // Rule at src/opts/arithmetic.isle line 274.
                                                                                        returns.extend(Some(v248));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            let mut v198 = C::inst_data_value_etor_returns::default();
                                                            C::inst_data_value_etor(ctx, v180.0, &mut v198);
                                                            let mut v198 = v198.into_context_iter();
                                                            while let Some(v199) = v198.next(ctx) {
                                                                if let &InstructionData::UnaryImm {
                                                                    opcode: ref v202,
                                                                    imm: v203,
                                                                } = &v199.1 {
                                                                    if let &Opcode::Iconst = v202 {
                                                                        let v173 = C::u64_from_imm64(ctx, v172);
                                                                        let v204 = C::u64_from_imm64(ctx, v203);
                                                                        let v205 = C::u64_checked_rem(ctx, v173, v204);
                                                                        if let Some(v206) = v205 {
                                                                            if v206 == 0x0_u64 {
                                                                                let v207 = C::u64_rem(ctx, v204, 0x2_u64);
                                                                                if v207 == 0x1_u64 {
                                                                                    if v168.0 == v199.0 {
                                                                                        let v208 = C::u64_div(ctx, v173, v204);
                                                                                        let v209 = C::imm64(ctx, v208);
                                                                                        let v210 = constructor_iconst(ctx, v168.0, v209);
                                                                                        let v249 = constructor_eq(ctx, v2.0, v180.1, v210);
                                                                                        // Rule at src/opts/arithmetic.isle line 279.
                                                                                        returns.extend(Some(v249));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    _ => {}
                                }
                            }
                            let mut v174 = C::inst_data_value_etor_returns::default();
                            C::inst_data_value_etor(ctx, v164.1, &mut v174);
                            let mut v174 = v174.into_context_iter();
                            while let Some(v175) = v174.next(ctx) {
                                match &v175.1 {
                                    &InstructionData::Binary {
                                        opcode: ref v178,
                                        args: ref v179,
                                    } => {
                                        if let &Opcode::Bxor = v178 {
                                            let v1184 = C::ty_int(ctx, v175.0);
                                            if let Some(v1185) = v1184 {
                                                let v180 = C::unpack_value_array_2(ctx, v179);
                                                if v164.0 == v180.0 {
                                                    let v1186 = constructor_iconst_u(ctx, v1185, 0x0_u64);
                                                    let v1187 = constructor_eq(ctx, v2.0, v180.1, v1186);
                                                    let v1188 = C::subsume(ctx, v1187);
                                                    // Rule at src/opts/icmp.isle line 297.
                                                    returns.extend(Some(v1188));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                    }
                                    &InstructionData::UnaryImm {
                                        opcode: ref v224,
                                        imm: v225,
                                    } => {
                                        if let &Opcode::Iconst = v224 {
                                            let v226 = C::u64_from_imm64(ctx, v225);
                                            match v226 {
                                                0x0_u64 => {
                                                    let mut v1065 = C::uextend_maybe_etor_returns::default();
                                                    C::uextend_maybe_etor(ctx, v164.0, &mut v1065);
                                                    let mut v1065 = v1065.into_context_iter();
                                                    while let Some(v1066) = v1065.next(ctx) {
                                                        let mut v1069 = C::inst_data_value_etor_returns::default();
                                                        C::inst_data_value_etor(ctx, v1066.1, &mut v1069);
                                                        let mut v1069 = v1069.into_context_iter();
                                                        while let Some(v1070) = v1069.next(ctx) {
                                                            if let &InstructionData::IntCompare {
                                                                opcode: ref v1073,
                                                                args: ref v1074,
                                                                cond: ref v1075,
                                                            } = &v1070.1 {
                                                                if let &Opcode::Icmp = v1073 {
                                                                    if v2.0 == v1070.0 {
                                                                        let v1086 = &C::intcc_complement(ctx, v1075);
                                                                        let v1076 = C::unpack_value_array_2(ctx, v1074);
                                                                        let v1087 = constructor_icmp(ctx, v2.0, v1086, v1076.0, v1076.1);
                                                                        let v1088 = C::subsume(ctx, v1087);
                                                                        // Rule at src/opts/icmp.isle line 62.
                                                                        returns.extend(Some(v1088));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                0x1_u64 => {
                                                    let mut v1065 = C::uextend_maybe_etor_returns::default();
                                                    C::uextend_maybe_etor(ctx, v164.0, &mut v1065);
                                                    let mut v1065 = v1065.into_context_iter();
                                                    while let Some(v1066) = v1065.next(ctx) {
                                                        let mut v1069 = C::inst_data_value_etor_returns::default();
                                                        C::inst_data_value_etor(ctx, v1066.1, &mut v1069);
                                                        let mut v1069 = v1069.into_context_iter();
                                                        while let Some(v1070) = v1069.next(ctx) {
                                                            if let &InstructionData::IntCompare {
                                                                opcode: ref v1073,
                                                                args: ref v1074,
                                                                cond: ref v1075,
                                                            } = &v1070.1 {
                                                                if let &Opcode::Icmp = v1073 {
                                                                    let v1079 = C::subsume(ctx, v1066.1);
                                                                    // Rule at src/opts/icmp.isle line 76.
                                                                    returns.extend(Some(v1079));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                _ => {}
                                            }
                                        }
                                    }
                                    _ => {}
                                }
                            }
                            if v164.0 == v164.1 {
                                let v52 = C::ty_int(ctx, v2.0);
                                if let Some(v53) = v52 {
                                    let v1043 = constructor_iconst_u(ctx, v53, 0x1_u64);
                                    let v1044 = C::subsume(ctx, v1043);
                                    // Rule at src/opts/icmp.isle line 4.
                                    returns.extend(Some(v1044));
                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                }
                            }
                        }
                        &IntCC::NotEqual => {
                            let v164 = C::unpack_value_array_2(ctx, v162);
                            let mut v167 = C::inst_data_value_etor_returns::default();
                            C::inst_data_value_etor(ctx, v164.0, &mut v167);
                            let mut v167 = v167.into_context_iter();
                            while let Some(v168) = v167.next(ctx) {
                                match &v168.1 {
                                    &InstructionData::Binary {
                                        opcode: ref v212,
                                        args: ref v213,
                                    } => {
                                        match v212 {
                                            &Opcode::Iadd => {
                                                let mut v174 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v164.1, &mut v174);
                                                let mut v174 = v174.into_context_iter();
                                                while let Some(v175) = v174.next(ctx) {
                                                    match &v175.1 {
                                                        &InstructionData::Binary {
                                                            opcode: ref v178,
                                                            args: ref v179,
                                                        } => {
                                                            if let &Opcode::Iadd = v178 {
                                                                let v180 = C::unpack_value_array_2(ctx, v179);
                                                                let v214 = C::unpack_value_array_2(ctx, v213);
                                                                if v180.0 == v214.0 {
                                                                    let v1059 = constructor_ne(ctx, v2.0, v214.1, v180.1);
                                                                    let v1060 = C::subsume(ctx, v1059);
                                                                    // Rule at src/opts/icmp.isle line 34.
                                                                    returns.extend(Some(v1060));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                if v180.0 == v214.1 {
                                                                    let v1055 = constructor_ne(ctx, v2.0, v214.0, v180.1);
                                                                    let v1056 = C::subsume(ctx, v1055);
                                                                    // Rule at src/opts/icmp.isle line 30.
                                                                    returns.extend(Some(v1056));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                if v180.1 == v214.0 {
                                                                    let v1057 = constructor_ne(ctx, v2.0, v214.1, v180.0);
                                                                    let v1058 = C::subsume(ctx, v1057);
                                                                    // Rule at src/opts/icmp.isle line 32.
                                                                    returns.extend(Some(v1058));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                if v180.1 == v214.1 {
                                                                    let v1053 = constructor_ne(ctx, v2.0, v214.0, v180.0);
                                                                    let v1054 = C::subsume(ctx, v1053);
                                                                    // Rule at src/opts/icmp.isle line 28.
                                                                    returns.extend(Some(v1054));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                                let mut v183 = C::inst_data_value_etor_returns::default();
                                                                C::inst_data_value_etor(ctx, v180.1, &mut v183);
                                                                let mut v183 = v183.into_context_iter();
                                                                while let Some(v184) = v183.next(ctx) {
                                                                    if let &InstructionData::UnaryImm {
                                                                        opcode: ref v187,
                                                                        imm: v188,
                                                                    } = &v184.1 {
                                                                        if let &Opcode::Iconst = v187 {
                                                                            let mut v217 = C::inst_data_value_etor_returns::default();
                                                                            C::inst_data_value_etor(ctx, v214.1, &mut v217);
                                                                            let mut v217 = v217.into_context_iter();
                                                                            while let Some(v218) = v217.next(ctx) {
                                                                                if let &InstructionData::UnaryImm {
                                                                                    opcode: ref v221,
                                                                                    imm: v222,
                                                                                } = &v218.1 {
                                                                                    if let &Opcode::Iconst = v221 {
                                                                                        let v726 = constructor_isub(ctx, v175.0, v180.1, v214.1);
                                                                                        let v727 = constructor_iadd(ctx, v168.0, v180.0, v726);
                                                                                        let v729 = constructor_ne(ctx, v2.0, v214.0, v727);
                                                                                        // Rule at src/opts/cprop.isle line 209.
                                                                                        returns.extend(Some(v729));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        &InstructionData::UnaryImm {
                                                            opcode: ref v224,
                                                            imm: v225,
                                                        } => {
                                                            if let &Opcode::Iconst = v224 {
                                                                let v214 = C::unpack_value_array_2(ctx, v213);
                                                                let mut v217 = C::inst_data_value_etor_returns::default();
                                                                C::inst_data_value_etor(ctx, v214.1, &mut v217);
                                                                let mut v217 = v217.into_context_iter();
                                                                while let Some(v218) = v217.next(ctx) {
                                                                    if let &InstructionData::UnaryImm {
                                                                        opcode: ref v221,
                                                                        imm: v222,
                                                                    } = &v218.1 {
                                                                        if let &Opcode::Iconst = v221 {
                                                                            let v720 = constructor_isub(ctx, v168.0, v164.1, v214.1);
                                                                            let v722 = constructor_ne(ctx, v2.0, v214.0, v720);
                                                                            // Rule at src/opts/cprop.isle line 199.
                                                                            returns.extend(Some(v722));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                            }
                                            &Opcode::Isub => {
                                                let v214 = C::unpack_value_array_2(ctx, v213);
                                                let mut v217 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v214.1, &mut v217);
                                                let mut v217 = v217.into_context_iter();
                                                while let Some(v218) = v217.next(ctx) {
                                                    match &v218.1 {
                                                        &InstructionData::IntCompare {
                                                            opcode: ref v1519,
                                                            args: ref v1520,
                                                            cond: ref v1521,
                                                        } => {
                                                            if let &Opcode::Icmp = v1519 {
                                                                match v1521 {
                                                                    &IntCC::SignedLessThan => {
                                                                        if v168.0 == I8 {
                                                                            let mut v234 = C::inst_data_value_etor_returns::default();
                                                                            C::inst_data_value_etor(ctx, v214.0, &mut v234);
                                                                            let mut v234 = v234.into_context_iter();
                                                                            while let Some(v235) = v234.next(ctx) {
                                                                                if let &InstructionData::IntCompare {
                                                                                    opcode: ref v1513,
                                                                                    args: ref v1514,
                                                                                    cond: ref v1515,
                                                                                } = &v235.1 {
                                                                                    if let &Opcode::Icmp = v1513 {
                                                                                        if let &IntCC::SignedGreaterThan = v1515 {
                                                                                            if v218.0 == v235.0 {
                                                                                                let v1516 = C::unpack_value_array_2(ctx, v1514);
                                                                                                let v1522 = C::unpack_value_array_2(ctx, v1520);
                                                                                                if v1516.0 == v1522.0 {
                                                                                                    if v1516.1 == v1522.1 {
                                                                                                        let mut v1000 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                        C::inst_data_value_tupled_etor(ctx, v164.1, &mut v1000);
                                                                                                        let mut v1000 = v1000.into_context_iter();
                                                                                                        while let Some(v1001) = v1000.next(ctx) {
                                                                                                            let v1002 = C::iconst_sextend_etor(ctx, v1001);
                                                                                                            if let Some(v1003) = v1002 {
                                                                                                                match v1003.1 {
                                                                                                                    -1_i64 => {
                                                                                                                        let v1533 = constructor_sge(ctx, v235.0, v1516.0, v1516.1);
                                                                                                                        // Rule at src/opts/spaceship.isle line 182.
                                                                                                                        returns.extend(Some(v1533));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                    0_i64 => {
                                                                                                                        let v1526 = constructor_ne(ctx, v235.0, v1516.0, v1516.1);
                                                                                                                        // Rule at src/opts/spaceship.isle line 150.
                                                                                                                        returns.extend(Some(v1526));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                    1_i64 => {
                                                                                                                        let v1529 = constructor_sle(ctx, v235.0, v1516.0, v1516.1);
                                                                                                                        // Rule at src/opts/spaceship.isle line 190.
                                                                                                                        returns.extend(Some(v1529));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                    _ => {}
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::UnsignedLessThan => {
                                                                        if v168.0 == I8 {
                                                                            let mut v234 = C::inst_data_value_etor_returns::default();
                                                                            C::inst_data_value_etor(ctx, v214.0, &mut v234);
                                                                            let mut v234 = v234.into_context_iter();
                                                                            while let Some(v235) = v234.next(ctx) {
                                                                                if let &InstructionData::IntCompare {
                                                                                    opcode: ref v1513,
                                                                                    args: ref v1514,
                                                                                    cond: ref v1515,
                                                                                } = &v235.1 {
                                                                                    if let &Opcode::Icmp = v1513 {
                                                                                        if let &IntCC::UnsignedGreaterThan = v1515 {
                                                                                            if v218.0 == v235.0 {
                                                                                                let v1516 = C::unpack_value_array_2(ctx, v1514);
                                                                                                let v1522 = C::unpack_value_array_2(ctx, v1520);
                                                                                                if v1516.0 == v1522.0 {
                                                                                                    if v1516.1 == v1522.1 {
                                                                                                        let mut v1000 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                        C::inst_data_value_tupled_etor(ctx, v164.1, &mut v1000);
                                                                                                        let mut v1000 = v1000.into_context_iter();
                                                                                                        while let Some(v1001) = v1000.next(ctx) {
                                                                                                            let v1002 = C::iconst_sextend_etor(ctx, v1001);
                                                                                                            if let Some(v1003) = v1002 {
                                                                                                                match v1003.1 {
                                                                                                                    -1_i64 => {
                                                                                                                        let v1534 = constructor_uge(ctx, v235.0, v1516.0, v1516.1);
                                                                                                                        // Rule at src/opts/spaceship.isle line 184.
                                                                                                                        returns.extend(Some(v1534));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                    0_i64 => {
                                                                                                                        let v1526 = constructor_ne(ctx, v235.0, v1516.0, v1516.1);
                                                                                                                        // Rule at src/opts/spaceship.isle line 152.
                                                                                                                        returns.extend(Some(v1526));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                    1_i64 => {
                                                                                                                        let v1530 = constructor_ule(ctx, v235.0, v1516.0, v1516.1);
                                                                                                                        // Rule at src/opts/spaceship.isle line 192.
                                                                                                                        returns.extend(Some(v1530));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                    _ => {}
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    _ => {}
                                                                }
                                                            }
                                                        }
                                                        &InstructionData::UnaryImm {
                                                            opcode: ref v221,
                                                            imm: v222,
                                                        } => {
                                                            if let &Opcode::Iconst = v221 {
                                                                let mut v174 = C::inst_data_value_etor_returns::default();
                                                                C::inst_data_value_etor(ctx, v164.1, &mut v174);
                                                                let mut v174 = v174.into_context_iter();
                                                                while let Some(v175) = v174.next(ctx) {
                                                                    if let &InstructionData::UnaryImm {
                                                                        opcode: ref v224,
                                                                        imm: v225,
                                                                    } = &v175.1 {
                                                                        if let &Opcode::Iconst = v224 {
                                                                            let v723 = constructor_iadd(ctx, v168.0, v164.1, v214.1);
                                                                            let v725 = constructor_ne(ctx, v2.0, v214.0, v723);
                                                                            // Rule at src/opts/cprop.isle line 204.
                                                                            returns.extend(Some(v725));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                                let mut v174 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v164.1, &mut v174);
                                                let mut v174 = v174.into_context_iter();
                                                while let Some(v175) = v174.next(ctx) {
                                                    if let &InstructionData::Binary {
                                                        opcode: ref v178,
                                                        args: ref v179,
                                                    } = &v175.1 {
                                                        if let &Opcode::Isub = v178 {
                                                            let v180 = C::unpack_value_array_2(ctx, v179);
                                                            let v1061 = constructor_iadd(ctx, v168.0, v214.0, v180.1);
                                                            let v1062 = constructor_iadd(ctx, v175.0, v180.0, v214.1);
                                                            let v1064 = constructor_ne(ctx, v2.0, v1061, v1062);
                                                            // Rule at src/opts/icmp.isle line 42.
                                                            returns.extend(Some(v1064));
                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                        }
                                                    }
                                                }
                                            }
                                            &Opcode::Imul => {
                                                let mut v174 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v164.1, &mut v174);
                                                let mut v174 = v174.into_context_iter();
                                                while let Some(v175) = v174.next(ctx) {
                                                    if let &InstructionData::UnaryImm {
                                                        opcode: ref v224,
                                                        imm: v225,
                                                    } = &v175.1 {
                                                        if let &Opcode::Iconst = v224 {
                                                            if v168.0 == v175.0 {
                                                                let v214 = C::unpack_value_array_2(ctx, v213);
                                                                let mut v217 = C::inst_data_value_etor_returns::default();
                                                                C::inst_data_value_etor(ctx, v214.1, &mut v217);
                                                                let mut v217 = v217.into_context_iter();
                                                                while let Some(v218) = v217.next(ctx) {
                                                                    if let &InstructionData::UnaryImm {
                                                                        opcode: ref v221,
                                                                        imm: v222,
                                                                    } = &v218.1 {
                                                                        if let &Opcode::Iconst = v221 {
                                                                            let v226 = C::u64_from_imm64(ctx, v225);
                                                                            let v223 = C::u64_from_imm64(ctx, v222);
                                                                            let v227 = C::u64_checked_rem(ctx, v226, v223);
                                                                            if let Some(v228) = v227 {
                                                                                if v228 == 0x0_u64 {
                                                                                    let v229 = C::u64_rem(ctx, v223, 0x2_u64);
                                                                                    if v229 == 0x1_u64 {
                                                                                        if v168.0 == v218.0 {
                                                                                            let v230 = C::u64_div(ctx, v226, v223);
                                                                                            let v231 = C::imm64(ctx, v230);
                                                                                            let v232 = constructor_iconst(ctx, v168.0, v231);
                                                                                            let v233 = constructor_ne(ctx, v2.0, v214.0, v232);
                                                                                            // Rule at src/opts/arithmetic.isle line 262.
                                                                                            returns.extend(Some(v233));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                let mut v234 = C::inst_data_value_etor_returns::default();
                                                                C::inst_data_value_etor(ctx, v214.0, &mut v234);
                                                                let mut v234 = v234.into_context_iter();
                                                                while let Some(v235) = v234.next(ctx) {
                                                                    if let &InstructionData::UnaryImm {
                                                                        opcode: ref v238,
                                                                        imm: v239,
                                                                    } = &v235.1 {
                                                                        if let &Opcode::Iconst = v238 {
                                                                            let v226 = C::u64_from_imm64(ctx, v225);
                                                                            let v240 = C::u64_from_imm64(ctx, v239);
                                                                            let v241 = C::u64_checked_rem(ctx, v226, v240);
                                                                            if let Some(v242) = v241 {
                                                                                if v242 == 0x0_u64 {
                                                                                    let v243 = C::u64_rem(ctx, v240, 0x2_u64);
                                                                                    if v243 == 0x1_u64 {
                                                                                        if v168.0 == v235.0 {
                                                                                            let v244 = C::u64_div(ctx, v226, v240);
                                                                                            let v245 = C::imm64(ctx, v244);
                                                                                            let v246 = constructor_iconst(ctx, v168.0, v245);
                                                                                            let v247 = constructor_ne(ctx, v2.0, v214.1, v246);
                                                                                            // Rule at src/opts/arithmetic.isle line 267.
                                                                                            returns.extend(Some(v247));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                            _ => {}
                                        }
                                    }
                                    &InstructionData::Ternary {
                                        opcode: ref v1193,
                                        args: ref v1194,
                                    } => {
                                        if let &Opcode::Select = v1193 {
                                            let v1195 = C::unpack_value_array_3(ctx, v1194);
                                            if v164.1 == v1195.1 {
                                                let mut v1199 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v1195.0, &mut v1199);
                                                let mut v1199 = v1199.into_context_iter();
                                                while let Some(v1200) = v1199.next(ctx) {
                                                    if let &InstructionData::IntCompare {
                                                        opcode: ref v1203,
                                                        args: ref v1204,
                                                        cond: ref v1205,
                                                    } = &v1200.1 {
                                                        if let &Opcode::Icmp = v1203 {
                                                            match v1205 {
                                                                &IntCC::SignedLessThan => {
                                                                    if v2.0 == v1200.0 {
                                                                        let v1206 = C::unpack_value_array_2(ctx, v1204);
                                                                        if v164.1 == v1206.0 {
                                                                            if v1195.2 == v1206.1 {
                                                                                let v1209 = constructor_sgt(ctx, v2.0, v1206.0, v1206.1);
                                                                                // Rule at src/opts/icmp.isle line 305.
                                                                                returns.extend(Some(v1209));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                &IntCC::UnsignedLessThan => {
                                                                    if v2.0 == v1200.0 {
                                                                        let v1206 = C::unpack_value_array_2(ctx, v1204);
                                                                        if v164.1 == v1206.0 {
                                                                            if v1195.2 == v1206.1 {
                                                                                let v1210 = constructor_ugt(ctx, v2.0, v1206.0, v1206.1);
                                                                                // Rule at src/opts/icmp.isle line 306.
                                                                                returns.extend(Some(v1210));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                _ => {}
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                            let mut v174 = C::inst_data_value_etor_returns::default();
                                            C::inst_data_value_etor(ctx, v164.1, &mut v174);
                                            let mut v174 = v174.into_context_iter();
                                            while let Some(v175) = v174.next(ctx) {
                                                if let &InstructionData::UnaryImm {
                                                    opcode: ref v224,
                                                    imm: v225,
                                                } = &v175.1 {
                                                    if let &Opcode::Iconst = v224 {
                                                        let mut v1252 = C::inst_data_value_etor_returns::default();
                                                        C::inst_data_value_etor(ctx, v1195.1, &mut v1252);
                                                        let mut v1252 = v1252.into_context_iter();
                                                        while let Some(v1253) = v1252.next(ctx) {
                                                            if let &InstructionData::UnaryImm {
                                                                opcode: ref v1256,
                                                                imm: v1257,
                                                            } = &v1253.1 {
                                                                if let &Opcode::Iconst = v1256 {
                                                                    let mut v1259 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v1195.2, &mut v1259);
                                                                    let mut v1259 = v1259.into_context_iter();
                                                                    while let Some(v1260) = v1259.next(ctx) {
                                                                        if let &InstructionData::UnaryImm {
                                                                            opcode: ref v1263,
                                                                            imm: v1264,
                                                                        } = &v1260.1 {
                                                                            if let &Opcode::Iconst = v1263 {
                                                                                let v1258 = C::u64_from_imm64(ctx, v1257);
                                                                                let v1265 = C::u64_from_imm64(ctx, v1264);
                                                                                let v1266 = C::u64_eq(ctx, v1258, v1265);
                                                                                if v1266 == false {
                                                                                    let v226 = C::u64_from_imm64(ctx, v225);
                                                                                    if v226 == v1258 {
                                                                                        let v1251 = C::value_type(ctx, v1195.0);
                                                                                        let v1267 = constructor_iconst_u(ctx, v1251, 0x0_u64);
                                                                                        let v1269 = constructor_eq(ctx, v168.0, v1195.0, v1267);
                                                                                        // Rule at src/opts/icmp.isle line 404.
                                                                                        returns.extend(Some(v1269));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                    if v226 == v1265 {
                                                                                        let v1251 = C::value_type(ctx, v1195.0);
                                                                                        let v1267 = constructor_iconst_u(ctx, v1251, 0x0_u64);
                                                                                        let v1268 = constructor_ne(ctx, v168.0, v1195.0, v1267);
                                                                                        // Rule at src/opts/icmp.isle line 412.
                                                                                        returns.extend(Some(v1268));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    &InstructionData::Unary {
                                        opcode: ref v992,
                                        arg: v993,
                                    } => {
                                        if let &Opcode::Sextend = v992 {
                                            let mut v1000 = C::inst_data_value_tupled_etor_returns::default();
                                            C::inst_data_value_tupled_etor(ctx, v164.1, &mut v1000);
                                            let mut v1000 = v1000.into_context_iter();
                                            while let Some(v1001) = v1000.next(ctx) {
                                                let v1002 = C::iconst_sextend_etor(ctx, v1001);
                                                if let Some(v1003) = v1002 {
                                                    if v1003.1 == 0_i64 {
                                                        let v994 = C::value_type(ctx, v993);
                                                        let v1007 = constructor_iconst_s(ctx, v994, 0_i64);
                                                        let v1009 = constructor_ne(ctx, v994, v993, v1007);
                                                        // Rule at src/opts/extends.isle line 41.
                                                        returns.extend(Some(v1009));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    &InstructionData::UnaryImm {
                                        opcode: ref v171,
                                        imm: v172,
                                    } => {
                                        if let &Opcode::Iconst = v171 {
                                            let mut v174 = C::inst_data_value_etor_returns::default();
                                            C::inst_data_value_etor(ctx, v164.1, &mut v174);
                                            let mut v174 = v174.into_context_iter();
                                            while let Some(v175) = v174.next(ctx) {
                                                if let &InstructionData::Binary {
                                                    opcode: ref v178,
                                                    args: ref v179,
                                                } = &v175.1 {
                                                    if let &Opcode::Imul = v178 {
                                                        if v168.0 == v175.0 {
                                                            let v180 = C::unpack_value_array_2(ctx, v179);
                                                            let mut v183 = C::inst_data_value_etor_returns::default();
                                                            C::inst_data_value_etor(ctx, v180.1, &mut v183);
                                                            let mut v183 = v183.into_context_iter();
                                                            while let Some(v184) = v183.next(ctx) {
                                                                if let &InstructionData::UnaryImm {
                                                                    opcode: ref v187,
                                                                    imm: v188,
                                                                } = &v184.1 {
                                                                    if let &Opcode::Iconst = v187 {
                                                                        let v173 = C::u64_from_imm64(ctx, v172);
                                                                        let v189 = C::u64_from_imm64(ctx, v188);
                                                                        let v190 = C::u64_checked_rem(ctx, v173, v189);
                                                                        if let Some(v191) = v190 {
                                                                            if v191 == 0x0_u64 {
                                                                                let v193 = C::u64_rem(ctx, v189, 0x2_u64);
                                                                                if v193 == 0x1_u64 {
                                                                                    if v168.0 == v184.0 {
                                                                                        let v194 = C::u64_div(ctx, v173, v189);
                                                                                        let v195 = C::imm64(ctx, v194);
                                                                                        let v196 = constructor_iconst(ctx, v168.0, v195);
                                                                                        let v197 = constructor_ne(ctx, v2.0, v180.0, v196);
                                                                                        // Rule at src/opts/arithmetic.isle line 252.
                                                                                        returns.extend(Some(v197));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            let mut v198 = C::inst_data_value_etor_returns::default();
                                                            C::inst_data_value_etor(ctx, v180.0, &mut v198);
                                                            let mut v198 = v198.into_context_iter();
                                                            while let Some(v199) = v198.next(ctx) {
                                                                if let &InstructionData::UnaryImm {
                                                                    opcode: ref v202,
                                                                    imm: v203,
                                                                } = &v199.1 {
                                                                    if let &Opcode::Iconst = v202 {
                                                                        let v173 = C::u64_from_imm64(ctx, v172);
                                                                        let v204 = C::u64_from_imm64(ctx, v203);
                                                                        let v205 = C::u64_checked_rem(ctx, v173, v204);
                                                                        if let Some(v206) = v205 {
                                                                            if v206 == 0x0_u64 {
                                                                                let v207 = C::u64_rem(ctx, v204, 0x2_u64);
                                                                                if v207 == 0x1_u64 {
                                                                                    if v168.0 == v199.0 {
                                                                                        let v208 = C::u64_div(ctx, v173, v204);
                                                                                        let v209 = C::imm64(ctx, v208);
                                                                                        let v210 = constructor_iconst(ctx, v168.0, v209);
                                                                                        let v211 = constructor_ne(ctx, v2.0, v180.1, v210);
                                                                                        // Rule at src/opts/arithmetic.isle line 257.
                                                                                        returns.extend(Some(v211));
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    _ => {}
                                }
                            }
                            let mut v174 = C::inst_data_value_etor_returns::default();
                            C::inst_data_value_etor(ctx, v164.1, &mut v174);
                            let mut v174 = v174.into_context_iter();
                            while let Some(v175) = v174.next(ctx) {
                                match &v175.1 {
                                    &InstructionData::Binary {
                                        opcode: ref v178,
                                        args: ref v179,
                                    } => {
                                        if let &Opcode::Bxor = v178 {
                                            let v1184 = C::ty_int(ctx, v175.0);
                                            if let Some(v1185) = v1184 {
                                                let v180 = C::unpack_value_array_2(ctx, v179);
                                                if v164.0 == v180.0 {
                                                    let v1186 = constructor_iconst_u(ctx, v1185, 0x0_u64);
                                                    let v1189 = constructor_ne(ctx, v2.0, v180.1, v1186);
                                                    let v1190 = C::subsume(ctx, v1189);
                                                    // Rule at src/opts/icmp.isle line 298.
                                                    returns.extend(Some(v1190));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                    }
                                    &InstructionData::UnaryImm {
                                        opcode: ref v224,
                                        imm: v225,
                                    } => {
                                        if let &Opcode::Iconst = v224 {
                                            let v226 = C::u64_from_imm64(ctx, v225);
                                            match v226 {
                                                0x0_u64 => {
                                                    let mut v1065 = C::uextend_maybe_etor_returns::default();
                                                    C::uextend_maybe_etor(ctx, v164.0, &mut v1065);
                                                    let mut v1065 = v1065.into_context_iter();
                                                    while let Some(v1066) = v1065.next(ctx) {
                                                        let mut v1069 = C::inst_data_value_etor_returns::default();
                                                        C::inst_data_value_etor(ctx, v1066.1, &mut v1069);
                                                        let mut v1069 = v1069.into_context_iter();
                                                        while let Some(v1070) = v1069.next(ctx) {
                                                            match &v1070.1 {
                                                                &InstructionData::FloatCompare {
                                                                    opcode: ref v1080,
                                                                    args: ref v1081,
                                                                    cond: ref v1082,
                                                                } => {
                                                                    if let &Opcode::Fcmp = v1080 {
                                                                        if v2.0 == v1070.0 {
                                                                            let v1079 = C::subsume(ctx, v1066.1);
                                                                            // Rule at src/opts/icmp.isle line 55.
                                                                            returns.extend(Some(v1079));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                                &InstructionData::IntCompare {
                                                                    opcode: ref v1073,
                                                                    args: ref v1074,
                                                                    cond: ref v1075,
                                                                } => {
                                                                    if let &Opcode::Icmp = v1073 {
                                                                        if v2.0 == v1070.0 {
                                                                            let v1079 = C::subsume(ctx, v1066.1);
                                                                            // Rule at src/opts/icmp.isle line 48.
                                                                            returns.extend(Some(v1079));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                                _ => {}
                                                            }
                                                        }
                                                    }
                                                    let mut v285 = ContextIterWrapper::<ConstructorVec<_>, _>::default();
                                                    constructor_truthy(ctx, v164.0, &mut v285);
                                                    let mut v285 = v285.into_context_iter();
                                                    while let Some(v286) = v285.next(ctx) {
                                                        let v287 = C::value_type(ctx, v286);
                                                        let v288 = C::ty_int_ref_scalar_64_extract(ctx, v287);
                                                        if let Some(v289) = v288 {
                                                            let v290 = constructor_iconst_u(ctx, v289, 0x0_u64);
                                                            let v291 = constructor_ne(ctx, v2.0, v286, v290);
                                                            // Rule at src/opts/bitops.isle line 114.
                                                            returns.extend(Some(v291));
                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                        }
                                                    }
                                                }
                                                0x1_u64 => {
                                                    let mut v1065 = C::uextend_maybe_etor_returns::default();
                                                    C::uextend_maybe_etor(ctx, v164.0, &mut v1065);
                                                    let mut v1065 = v1065.into_context_iter();
                                                    while let Some(v1066) = v1065.next(ctx) {
                                                        let mut v1069 = C::inst_data_value_etor_returns::default();
                                                        C::inst_data_value_etor(ctx, v1066.1, &mut v1069);
                                                        let mut v1069 = v1069.into_context_iter();
                                                        while let Some(v1070) = v1069.next(ctx) {
                                                            if let &InstructionData::IntCompare {
                                                                opcode: ref v1073,
                                                                args: ref v1074,
                                                                cond: ref v1075,
                                                            } = &v1070.1 {
                                                                if let &Opcode::Icmp = v1073 {
                                                                    if v2.0 == v1070.0 {
                                                                        let v1086 = &C::intcc_complement(ctx, v1075);
                                                                        let v1076 = C::unpack_value_array_2(ctx, v1074);
                                                                        let v1087 = constructor_icmp(ctx, v2.0, v1086, v1076.0, v1076.1);
                                                                        let v1088 = C::subsume(ctx, v1087);
                                                                        // Rule at src/opts/icmp.isle line 69.
                                                                        returns.extend(Some(v1088));
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                _ => {}
                                            }
                                        }
                                    }
                                    _ => {}
                                }
                            }
                            if v164.0 == v164.1 {
                                let v52 = C::ty_int(ctx, v2.0);
                                if let Some(v53) = v52 {
                                    let v55 = constructor_iconst_u(ctx, v53, 0x0_u64);
                                    let v56 = C::subsume(ctx, v55);
                                    // Rule at src/opts/icmp.isle line 5.
                                    returns.extend(Some(v56));
                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                }
                            }
                        }
                        &IntCC::SignedGreaterThan => {
                            let v608 = C::fits_in_64(ctx, v2.0);
                            if let Some(v609) = v608 {
                                let v1112 = C::ty_int(ctx, v609);
                                if let Some(v1113) = v1112 {
                                    let v164 = C::unpack_value_array_2(ctx, v162);
                                    let mut v174 = C::inst_data_value_etor_returns::default();
                                    C::inst_data_value_etor(ctx, v164.1, &mut v174);
                                    let mut v174 = v174.into_context_iter();
                                    while let Some(v175) = v174.next(ctx) {
                                        if let &InstructionData::UnaryImm {
                                            opcode: ref v224,
                                            imm: v225,
                                        } = &v175.1 {
                                            if let &Opcode::Iconst = v224 {
                                                let v226 = C::u64_from_imm64(ctx, v225);
                                                let v1122 = C::ty_smin(ctx, v175.0);
                                                let v1123 = C::u64_eq(ctx, v226, v1122);
                                                if v1123 == true {
                                                    let v1117 = constructor_ne(ctx, v1113, v164.0, v164.1);
                                                    // Rule at src/opts/icmp.isle line 152.
                                                    returns.extend(Some(v1117));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                let v1124 = C::ty_smax(ctx, v175.0);
                                                let v1125 = C::u64_eq(ctx, v226, v1124);
                                                if v1125 == true {
                                                    let v1114 = constructor_iconst_u(ctx, v1113, 0x0_u64);
                                                    let v1115 = C::subsume(ctx, v1114);
                                                    // Rule at src/opts/icmp.isle line 172.
                                                    returns.extend(Some(v1115));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                    }
                                }
                                let v164 = C::unpack_value_array_2(ctx, v162);
                                let mut v167 = C::inst_data_value_etor_returns::default();
                                C::inst_data_value_etor(ctx, v164.0, &mut v167);
                                let mut v167 = v167.into_context_iter();
                                while let Some(v168) = v167.next(ctx) {
                                    if let &InstructionData::Binary {
                                        opcode: ref v212,
                                        args: ref v213,
                                    } = &v168.1 {
                                        if let &Opcode::Smin = v212 {
                                            let v214 = C::unpack_value_array_2(ctx, v213);
                                            if v164.1 == v214.0 {
                                                let v1216 = constructor_iconst_u(ctx, v609, 0x0_u64);
                                                // Rule at src/opts/selects.isle line 105.
                                                returns.extend(Some(v1216));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                            if v164.1 == v214.1 {
                                                let v1216 = constructor_iconst_u(ctx, v609, 0x0_u64);
                                                // Rule at src/opts/selects.isle line 106.
                                                returns.extend(Some(v1216));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                    }
                                }
                            }
                            let v164 = C::unpack_value_array_2(ctx, v162);
                            let mut v1000 = C::inst_data_value_tupled_etor_returns::default();
                            C::inst_data_value_tupled_etor(ctx, v164.1, &mut v1000);
                            let mut v1000 = v1000.into_context_iter();
                            while let Some(v1001) = v1000.next(ctx) {
                                let v1002 = C::iconst_sextend_etor(ctx, v1001);
                                if let Some(v1003) = v1002 {
                                    match v1003.1 {
                                        -1_i64 => {
                                            let v1143 = constructor_iconst_s(ctx, v1003.0, 0_i64);
                                            let v1146 = constructor_sge(ctx, v2.0, v164.0, v1143);
                                            // Rule at src/opts/icmp.isle line 204.
                                            returns.extend(Some(v1146));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        0_i64 => {
                                            let mut v167 = C::inst_data_value_etor_returns::default();
                                            C::inst_data_value_etor(ctx, v164.0, &mut v167);
                                            let mut v167 = v167.into_context_iter();
                                            while let Some(v168) = v167.next(ctx) {
                                                if v168.0 == I8 {
                                                    if let &InstructionData::Binary {
                                                        opcode: ref v212,
                                                        args: ref v213,
                                                    } = &v168.1 {
                                                        if let &Opcode::Isub = v212 {
                                                            let v214 = C::unpack_value_array_2(ctx, v213);
                                                            let mut v217 = C::inst_data_value_etor_returns::default();
                                                            C::inst_data_value_etor(ctx, v214.1, &mut v217);
                                                            let mut v217 = v217.into_context_iter();
                                                            while let Some(v218) = v217.next(ctx) {
                                                                if let &InstructionData::IntCompare {
                                                                    opcode: ref v1519,
                                                                    args: ref v1520,
                                                                    cond: ref v1521,
                                                                } = &v218.1 {
                                                                    if let &Opcode::Icmp = v1519 {
                                                                        match v1521 {
                                                                            &IntCC::SignedLessThan => {
                                                                                let mut v234 = C::inst_data_value_etor_returns::default();
                                                                                C::inst_data_value_etor(ctx, v214.0, &mut v234);
                                                                                let mut v234 = v234.into_context_iter();
                                                                                while let Some(v235) = v234.next(ctx) {
                                                                                    if let &InstructionData::IntCompare {
                                                                                        opcode: ref v1513,
                                                                                        args: ref v1514,
                                                                                        cond: ref v1515,
                                                                                    } = &v235.1 {
                                                                                        if let &Opcode::Icmp = v1513 {
                                                                                            if let &IntCC::SignedGreaterThan = v1515 {
                                                                                                if v218.0 == v235.0 {
                                                                                                    let v1516 = C::unpack_value_array_2(ctx, v1514);
                                                                                                    let v1522 = C::unpack_value_array_2(ctx, v1520);
                                                                                                    if v1516.0 == v1522.0 {
                                                                                                        if v1516.1 == v1522.1 {
                                                                                                            let v1531 = constructor_sgt(ctx, v235.0, v1516.0, v1516.1);
                                                                                                            // Rule at src/opts/spaceship.isle line 166.
                                                                                                            returns.extend(Some(v1531));
                                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                            &IntCC::UnsignedLessThan => {
                                                                                let mut v234 = C::inst_data_value_etor_returns::default();
                                                                                C::inst_data_value_etor(ctx, v214.0, &mut v234);
                                                                                let mut v234 = v234.into_context_iter();
                                                                                while let Some(v235) = v234.next(ctx) {
                                                                                    if let &InstructionData::IntCompare {
                                                                                        opcode: ref v1513,
                                                                                        args: ref v1514,
                                                                                        cond: ref v1515,
                                                                                    } = &v235.1 {
                                                                                        if let &Opcode::Icmp = v1513 {
                                                                                            if let &IntCC::UnsignedGreaterThan = v1515 {
                                                                                                if v218.0 == v235.0 {
                                                                                                    let v1516 = C::unpack_value_array_2(ctx, v1514);
                                                                                                    let v1522 = C::unpack_value_array_2(ctx, v1520);
                                                                                                    if v1516.0 == v1522.0 {
                                                                                                        if v1516.1 == v1522.1 {
                                                                                                            let v1532 = constructor_ugt(ctx, v235.0, v1516.0, v1516.1);
                                                                                                            // Rule at src/opts/spaceship.isle line 168.
                                                                                                            returns.extend(Some(v1532));
                                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                            _ => {}
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        _ => {}
                                    }
                                }
                            }
                            let v52 = C::ty_int(ctx, v2.0);
                            if let Some(v53) = v52 {
                                if v164.0 == v164.1 {
                                    let v55 = constructor_iconst_u(ctx, v53, 0x0_u64);
                                    let v56 = C::subsume(ctx, v55);
                                    // Rule at src/opts/icmp.isle line 8.
                                    returns.extend(Some(v56));
                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                }
                            }
                        }
                        &IntCC::SignedGreaterThanOrEqual => {
                            let v164 = C::unpack_value_array_2(ctx, v162);
                            let mut v167 = C::inst_data_value_etor_returns::default();
                            C::inst_data_value_etor(ctx, v164.0, &mut v167);
                            let mut v167 = v167.into_context_iter();
                            while let Some(v168) = v167.next(ctx) {
                                match v168.0 {
                                    I8 => {
                                        if let &InstructionData::Binary {
                                            opcode: ref v212,
                                            args: ref v213,
                                        } = &v168.1 {
                                            if let &Opcode::Isub = v212 {
                                                let v214 = C::unpack_value_array_2(ctx, v213);
                                                let mut v217 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v214.1, &mut v217);
                                                let mut v217 = v217.into_context_iter();
                                                while let Some(v218) = v217.next(ctx) {
                                                    if let &InstructionData::IntCompare {
                                                        opcode: ref v1519,
                                                        args: ref v1520,
                                                        cond: ref v1521,
                                                    } = &v218.1 {
                                                        if let &Opcode::Icmp = v1519 {
                                                            match v1521 {
                                                                &IntCC::SignedLessThan => {
                                                                    let mut v234 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v214.0, &mut v234);
                                                                    let mut v234 = v234.into_context_iter();
                                                                    while let Some(v235) = v234.next(ctx) {
                                                                        if let &InstructionData::IntCompare {
                                                                            opcode: ref v1513,
                                                                            args: ref v1514,
                                                                            cond: ref v1515,
                                                                        } = &v235.1 {
                                                                            if let &Opcode::Icmp = v1513 {
                                                                                if let &IntCC::SignedGreaterThan = v1515 {
                                                                                    if v218.0 == v235.0 {
                                                                                        let v1516 = C::unpack_value_array_2(ctx, v1514);
                                                                                        let v1522 = C::unpack_value_array_2(ctx, v1520);
                                                                                        if v1516.0 == v1522.0 {
                                                                                            if v1516.1 == v1522.1 {
                                                                                                let mut v1000 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                C::inst_data_value_tupled_etor(ctx, v164.1, &mut v1000);
                                                                                                let mut v1000 = v1000.into_context_iter();
                                                                                                while let Some(v1001) = v1000.next(ctx) {
                                                                                                    let v1002 = C::iconst_sextend_etor(ctx, v1001);
                                                                                                    if let Some(v1003) = v1002 {
                                                                                                        if v1003.1 == 0_i64 {
                                                                                                            let v1533 = constructor_sge(ctx, v235.0, v1516.0, v1516.1);
                                                                                                            // Rule at src/opts/spaceship.isle line 171.
                                                                                                            returns.extend(Some(v1533));
                                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                &IntCC::UnsignedLessThan => {
                                                                    let mut v234 = C::inst_data_value_etor_returns::default();
                                                                    C::inst_data_value_etor(ctx, v214.0, &mut v234);
                                                                    let mut v234 = v234.into_context_iter();
                                                                    while let Some(v235) = v234.next(ctx) {
                                                                        if let &InstructionData::IntCompare {
                                                                            opcode: ref v1513,
                                                                            args: ref v1514,
                                                                            cond: ref v1515,
                                                                        } = &v235.1 {
                                                                            if let &Opcode::Icmp = v1513 {
                                                                                if let &IntCC::UnsignedGreaterThan = v1515 {
                                                                                    if v218.0 == v235.0 {
                                                                                        let v1516 = C::unpack_value_array_2(ctx, v1514);
                                                                                        let v1522 = C::unpack_value_array_2(ctx, v1520);
                                                                                        if v1516.0 == v1522.0 {
                                                                                            if v1516.1 == v1522.1 {
                                                                                                let mut v1000 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                C::inst_data_value_tupled_etor(ctx, v164.1, &mut v1000);
                                                                                                let mut v1000 = v1000.into_context_iter();
                                                                                                while let Some(v1001) = v1000.next(ctx) {
                                                                                                    let v1002 = C::iconst_sextend_etor(ctx, v1001);
                                                                                                    if let Some(v1003) = v1002 {
                                                                                                        if v1003.1 == 0_i64 {
                                                                                                            let v1534 = constructor_uge(ctx, v235.0, v1516.0, v1516.1);
                                                                                                            // Rule at src/opts/spaceship.isle line 173.
                                                                                                            returns.extend(Some(v1534));
                                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                _ => {}
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    I64 => {
                                        if let &InstructionData::Unary {
                                            opcode: ref v992,
                                            arg: v993,
                                        } = &v168.1 {
                                            if let &Opcode::Uextend = v992 {
                                                let v994 = C::value_type(ctx, v993);
                                                if v994 == I32 {
                                                    let mut v174 = C::inst_data_value_etor_returns::default();
                                                    C::inst_data_value_etor(ctx, v164.1, &mut v174);
                                                    let mut v174 = v174.into_context_iter();
                                                    while let Some(v175) = v174.next(ctx) {
                                                        if let &InstructionData::UnaryImm {
                                                            opcode: ref v224,
                                                            imm: v225,
                                                        } = &v175.1 {
                                                            if let &Opcode::Iconst = v224 {
                                                                let v226 = C::u64_from_imm64(ctx, v225);
                                                                if v226 == 0x0_u64 {
                                                                    let v998 = constructor_iconst_u(ctx, v2.0, 0x1_u64);
                                                                    let v999 = C::subsume(ctx, v998);
                                                                    // Rule at src/opts/extends.isle line 32.
                                                                    returns.extend(Some(v999));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    _ => {}
                                }
                            }
                            let v608 = C::fits_in_64(ctx, v2.0);
                            if let Some(v609) = v608 {
                                let v1112 = C::ty_int(ctx, v609);
                                if let Some(v1113) = v1112 {
                                    let mut v174 = C::inst_data_value_etor_returns::default();
                                    C::inst_data_value_etor(ctx, v164.1, &mut v174);
                                    let mut v174 = v174.into_context_iter();
                                    while let Some(v175) = v174.next(ctx) {
                                        if let &InstructionData::UnaryImm {
                                            opcode: ref v224,
                                            imm: v225,
                                        } = &v175.1 {
                                            if let &Opcode::Iconst = v224 {
                                                let v226 = C::u64_from_imm64(ctx, v225);
                                                let v1122 = C::ty_smin(ctx, v175.0);
                                                let v1123 = C::u64_eq(ctx, v226, v1122);
                                                if v1123 == true {
                                                    let v1118 = constructor_iconst_u(ctx, v1113, 0x1_u64);
                                                    let v1119 = C::subsume(ctx, v1118);
                                                    // Rule at src/opts/icmp.isle line 157.
                                                    returns.extend(Some(v1119));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                let v1124 = C::ty_smax(ctx, v175.0);
                                                let v1125 = C::u64_eq(ctx, v226, v1124);
                                                if v1125 == true {
                                                    let v1116 = constructor_eq(ctx, v1113, v164.0, v164.1);
                                                    // Rule at src/opts/icmp.isle line 177.
                                                    returns.extend(Some(v1116));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            let v52 = C::ty_int(ctx, v2.0);
                            if let Some(v53) = v52 {
                                if v164.0 == v164.1 {
                                    let v1043 = constructor_iconst_u(ctx, v53, 0x1_u64);
                                    let v1044 = C::subsume(ctx, v1043);
                                    // Rule at src/opts/icmp.isle line 9.
                                    returns.extend(Some(v1044));
                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                }
                            }
                            let mut v1000 = C::inst_data_value_tupled_etor_returns::default();
                            C::inst_data_value_tupled_etor(ctx, v164.1, &mut v1000);
                            let mut v1000 = v1000.into_context_iter();
                            while let Some(v1001) = v1000.next(ctx) {
                                let v1002 = C::iconst_sextend_etor(ctx, v1001);
                                if let Some(v1003) = v1002 {
                                    if v1003.1 == 1_i64 {
                                        let v1143 = constructor_iconst_s(ctx, v1003.0, 0_i64);
                                        let v1144 = constructor_sgt(ctx, v2.0, v164.0, v1143);
                                        // Rule at src/opts/icmp.isle line 198.
                                        returns.extend(Some(v1144));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                            }
                        }
                        &IntCC::SignedLessThan => {
                            let v164 = C::unpack_value_array_2(ctx, v162);
                            let mut v174 = C::inst_data_value_etor_returns::default();
                            C::inst_data_value_etor(ctx, v164.1, &mut v174);
                            let mut v174 = v174.into_context_iter();
                            while let Some(v175) = v174.next(ctx) {
                                match &v175.1 {
                                    &InstructionData::Binary {
                                        opcode: ref v178,
                                        args: ref v179,
                                    } => {
                                        if let &Opcode::Smin = v178 {
                                            let v608 = C::fits_in_64(ctx, v2.0);
                                            if let Some(v609) = v608 {
                                                let v180 = C::unpack_value_array_2(ctx, v179);
                                                if v164.0 == v180.0 {
                                                    let v1216 = constructor_iconst_u(ctx, v609, 0x0_u64);
                                                    // Rule at src/opts/selects.isle line 107.
                                                    returns.extend(Some(v1216));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v164.0 == v180.1 {
                                                    let v1216 = constructor_iconst_u(ctx, v609, 0x0_u64);
                                                    // Rule at src/opts/selects.isle line 108.
                                                    returns.extend(Some(v1216));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                    }
                                    &InstructionData::Unary {
                                        opcode: ref v1211,
                                        arg: v1212,
                                    } => {
                                        if let &Opcode::Bnot = v1211 {
                                            let mut v167 = C::inst_data_value_etor_returns::default();
                                            C::inst_data_value_etor(ctx, v164.0, &mut v167);
                                            let mut v167 = v167.into_context_iter();
                                            while let Some(v168) = v167.next(ctx) {
                                                if let &InstructionData::Unary {
                                                    opcode: ref v992,
                                                    arg: v993,
                                                } = &v168.1 {
                                                    if let &Opcode::Bnot = v992 {
                                                        if v168.0 == v175.0 {
                                                            let v1214 = constructor_sgt(ctx, v2.0, v993, v1212);
                                                            // Rule at src/opts/icmp.isle line 309.
                                                            returns.extend(Some(v1214));
                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    &InstructionData::UnaryImm {
                                        opcode: ref v224,
                                        imm: v225,
                                    } => {
                                        if let &Opcode::Iconst = v224 {
                                            let v608 = C::fits_in_64(ctx, v2.0);
                                            if let Some(v609) = v608 {
                                                let v1112 = C::ty_int(ctx, v609);
                                                if let Some(v1113) = v1112 {
                                                    let v226 = C::u64_from_imm64(ctx, v225);
                                                    let v1122 = C::ty_smin(ctx, v175.0);
                                                    let v1123 = C::u64_eq(ctx, v226, v1122);
                                                    if v1123 == true {
                                                        let v1114 = constructor_iconst_u(ctx, v1113, 0x0_u64);
                                                        let v1115 = C::subsume(ctx, v1114);
                                                        // Rule at src/opts/icmp.isle line 142.
                                                        returns.extend(Some(v1115));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                    let v1124 = C::ty_smax(ctx, v175.0);
                                                    let v1125 = C::u64_eq(ctx, v226, v1124);
                                                    if v1125 == true {
                                                        let v1117 = constructor_ne(ctx, v1113, v164.0, v164.1);
                                                        // Rule at src/opts/icmp.isle line 162.
                                                        returns.extend(Some(v1117));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            let v226 = C::u64_from_imm64(ctx, v225);
                                            if v226 == 0x0_u64 {
                                                let mut v167 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v164.0, &mut v167);
                                                let mut v167 = v167.into_context_iter();
                                                while let Some(v168) = v167.next(ctx) {
                                                    if v168.0 == I64 {
                                                        if let &InstructionData::Unary {
                                                            opcode: ref v992,
                                                            arg: v993,
                                                        } = &v168.1 {
                                                            if let &Opcode::Uextend = v992 {
                                                                let v994 = C::value_type(ctx, v993);
                                                                if v994 == I32 {
                                                                    let v995 = constructor_iconst_u(ctx, v2.0, 0x0_u64);
                                                                    let v996 = C::subsume(ctx, v995);
                                                                    // Rule at src/opts/extends.isle line 27.
                                                                    returns.extend(Some(v996));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    _ => {}
                                }
                            }
                            let mut v1000 = C::inst_data_value_tupled_etor_returns::default();
                            C::inst_data_value_tupled_etor(ctx, v164.1, &mut v1000);
                            let mut v1000 = v1000.into_context_iter();
                            while let Some(v1001) = v1000.next(ctx) {
                                let v1002 = C::iconst_sextend_etor(ctx, v1001);
                                if let Some(v1003) = v1002 {
                                    match v1003.1 {
                                        0_i64 => {
                                            let mut v167 = C::inst_data_value_etor_returns::default();
                                            C::inst_data_value_etor(ctx, v164.0, &mut v167);
                                            let mut v167 = v167.into_context_iter();
                                            while let Some(v168) = v167.next(ctx) {
                                                if v168.0 == I8 {
                                                    if let &InstructionData::Binary {
                                                        opcode: ref v212,
                                                        args: ref v213,
                                                    } = &v168.1 {
                                                        if let &Opcode::Isub = v212 {
                                                            let v214 = C::unpack_value_array_2(ctx, v213);
                                                            let mut v217 = C::inst_data_value_etor_returns::default();
                                                            C::inst_data_value_etor(ctx, v214.1, &mut v217);
                                                            let mut v217 = v217.into_context_iter();
                                                            while let Some(v218) = v217.next(ctx) {
                                                                if let &InstructionData::IntCompare {
                                                                    opcode: ref v1519,
                                                                    args: ref v1520,
                                                                    cond: ref v1521,
                                                                } = &v218.1 {
                                                                    if let &Opcode::Icmp = v1519 {
                                                                        match v1521 {
                                                                            &IntCC::SignedLessThan => {
                                                                                let mut v234 = C::inst_data_value_etor_returns::default();
                                                                                C::inst_data_value_etor(ctx, v214.0, &mut v234);
                                                                                let mut v234 = v234.into_context_iter();
                                                                                while let Some(v235) = v234.next(ctx) {
                                                                                    if let &InstructionData::IntCompare {
                                                                                        opcode: ref v1513,
                                                                                        args: ref v1514,
                                                                                        cond: ref v1515,
                                                                                    } = &v235.1 {
                                                                                        if let &Opcode::Icmp = v1513 {
                                                                                            if let &IntCC::SignedGreaterThan = v1515 {
                                                                                                if v218.0 == v235.0 {
                                                                                                    let v1516 = C::unpack_value_array_2(ctx, v1514);
                                                                                                    let v1522 = C::unpack_value_array_2(ctx, v1520);
                                                                                                    if v1516.0 == v1522.0 {
                                                                                                        if v1516.1 == v1522.1 {
                                                                                                            let v1527 = constructor_slt(ctx, v235.0, v1516.0, v1516.1);
                                                                                                            // Rule at src/opts/spaceship.isle line 156.
                                                                                                            returns.extend(Some(v1527));
                                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                            &IntCC::UnsignedLessThan => {
                                                                                let mut v234 = C::inst_data_value_etor_returns::default();
                                                                                C::inst_data_value_etor(ctx, v214.0, &mut v234);
                                                                                let mut v234 = v234.into_context_iter();
                                                                                while let Some(v235) = v234.next(ctx) {
                                                                                    if let &InstructionData::IntCompare {
                                                                                        opcode: ref v1513,
                                                                                        args: ref v1514,
                                                                                        cond: ref v1515,
                                                                                    } = &v235.1 {
                                                                                        if let &Opcode::Icmp = v1513 {
                                                                                            if let &IntCC::UnsignedGreaterThan = v1515 {
                                                                                                if v218.0 == v235.0 {
                                                                                                    let v1516 = C::unpack_value_array_2(ctx, v1514);
                                                                                                    let v1522 = C::unpack_value_array_2(ctx, v1520);
                                                                                                    if v1516.0 == v1522.0 {
                                                                                                        if v1516.1 == v1522.1 {
                                                                                                            let v1528 = constructor_ult(ctx, v235.0, v1516.0, v1516.1);
                                                                                                            // Rule at src/opts/spaceship.isle line 158.
                                                                                                            returns.extend(Some(v1528));
                                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                            _ => {}
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        1_i64 => {
                                            let v1143 = constructor_iconst_s(ctx, v1003.0, 0_i64);
                                            let v1145 = constructor_sle(ctx, v2.0, v164.0, v1143);
                                            // Rule at src/opts/icmp.isle line 201.
                                            returns.extend(Some(v1145));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        _ => {}
                                    }
                                }
                            }
                            let v52 = C::ty_int(ctx, v2.0);
                            if let Some(v53) = v52 {
                                if v164.0 == v164.1 {
                                    let v55 = constructor_iconst_u(ctx, v53, 0x0_u64);
                                    let v56 = C::subsume(ctx, v55);
                                    // Rule at src/opts/icmp.isle line 12.
                                    returns.extend(Some(v56));
                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                }
                            }
                        }
                        &IntCC::SignedLessThanOrEqual => {
                            let v164 = C::unpack_value_array_2(ctx, v162);
                            let mut v1000 = C::inst_data_value_tupled_etor_returns::default();
                            C::inst_data_value_tupled_etor(ctx, v164.1, &mut v1000);
                            let mut v1000 = v1000.into_context_iter();
                            while let Some(v1001) = v1000.next(ctx) {
                                let v1002 = C::iconst_sextend_etor(ctx, v1001);
                                if let Some(v1003) = v1002 {
                                    match v1003.1 {
                                        -1_i64 => {
                                            let v1143 = constructor_iconst_s(ctx, v1003.0, 0_i64);
                                            let v1147 = constructor_slt(ctx, v2.0, v164.0, v1143);
                                            // Rule at src/opts/icmp.isle line 207.
                                            returns.extend(Some(v1147));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        0_i64 => {
                                            let mut v167 = C::inst_data_value_etor_returns::default();
                                            C::inst_data_value_etor(ctx, v164.0, &mut v167);
                                            let mut v167 = v167.into_context_iter();
                                            while let Some(v168) = v167.next(ctx) {
                                                if v168.0 == I8 {
                                                    if let &InstructionData::Binary {
                                                        opcode: ref v212,
                                                        args: ref v213,
                                                    } = &v168.1 {
                                                        if let &Opcode::Isub = v212 {
                                                            let v214 = C::unpack_value_array_2(ctx, v213);
                                                            let mut v217 = C::inst_data_value_etor_returns::default();
                                                            C::inst_data_value_etor(ctx, v214.1, &mut v217);
                                                            let mut v217 = v217.into_context_iter();
                                                            while let Some(v218) = v217.next(ctx) {
                                                                if let &InstructionData::IntCompare {
                                                                    opcode: ref v1519,
                                                                    args: ref v1520,
                                                                    cond: ref v1521,
                                                                } = &v218.1 {
                                                                    if let &Opcode::Icmp = v1519 {
                                                                        match v1521 {
                                                                            &IntCC::SignedLessThan => {
                                                                                let mut v234 = C::inst_data_value_etor_returns::default();
                                                                                C::inst_data_value_etor(ctx, v214.0, &mut v234);
                                                                                let mut v234 = v234.into_context_iter();
                                                                                while let Some(v235) = v234.next(ctx) {
                                                                                    if let &InstructionData::IntCompare {
                                                                                        opcode: ref v1513,
                                                                                        args: ref v1514,
                                                                                        cond: ref v1515,
                                                                                    } = &v235.1 {
                                                                                        if let &Opcode::Icmp = v1513 {
                                                                                            if let &IntCC::SignedGreaterThan = v1515 {
                                                                                                if v218.0 == v235.0 {
                                                                                                    let v1516 = C::unpack_value_array_2(ctx, v1514);
                                                                                                    let v1522 = C::unpack_value_array_2(ctx, v1520);
                                                                                                    if v1516.0 == v1522.0 {
                                                                                                        if v1516.1 == v1522.1 {
                                                                                                            let v1529 = constructor_sle(ctx, v235.0, v1516.0, v1516.1);
                                                                                                            // Rule at src/opts/spaceship.isle line 161.
                                                                                                            returns.extend(Some(v1529));
                                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                            &IntCC::UnsignedLessThan => {
                                                                                let mut v234 = C::inst_data_value_etor_returns::default();
                                                                                C::inst_data_value_etor(ctx, v214.0, &mut v234);
                                                                                let mut v234 = v234.into_context_iter();
                                                                                while let Some(v235) = v234.next(ctx) {
                                                                                    if let &InstructionData::IntCompare {
                                                                                        opcode: ref v1513,
                                                                                        args: ref v1514,
                                                                                        cond: ref v1515,
                                                                                    } = &v235.1 {
                                                                                        if let &Opcode::Icmp = v1513 {
                                                                                            if let &IntCC::UnsignedGreaterThan = v1515 {
                                                                                                if v218.0 == v235.0 {
                                                                                                    let v1516 = C::unpack_value_array_2(ctx, v1514);
                                                                                                    let v1522 = C::unpack_value_array_2(ctx, v1520);
                                                                                                    if v1516.0 == v1522.0 {
                                                                                                        if v1516.1 == v1522.1 {
                                                                                                            let v1530 = constructor_ule(ctx, v235.0, v1516.0, v1516.1);
                                                                                                            // Rule at src/opts/spaceship.isle line 163.
                                                                                                            returns.extend(Some(v1530));
                                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                            _ => {}
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        _ => {}
                                    }
                                }
                            }
                            let v608 = C::fits_in_64(ctx, v2.0);
                            if let Some(v609) = v608 {
                                let v1112 = C::ty_int(ctx, v609);
                                if let Some(v1113) = v1112 {
                                    let mut v174 = C::inst_data_value_etor_returns::default();
                                    C::inst_data_value_etor(ctx, v164.1, &mut v174);
                                    let mut v174 = v174.into_context_iter();
                                    while let Some(v175) = v174.next(ctx) {
                                        if let &InstructionData::UnaryImm {
                                            opcode: ref v224,
                                            imm: v225,
                                        } = &v175.1 {
                                            if let &Opcode::Iconst = v224 {
                                                let v226 = C::u64_from_imm64(ctx, v225);
                                                let v1122 = C::ty_smin(ctx, v175.0);
                                                let v1123 = C::u64_eq(ctx, v226, v1122);
                                                if v1123 == true {
                                                    let v1116 = constructor_eq(ctx, v1113, v164.0, v164.1);
                                                    // Rule at src/opts/icmp.isle line 147.
                                                    returns.extend(Some(v1116));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                let v1124 = C::ty_smax(ctx, v175.0);
                                                let v1125 = C::u64_eq(ctx, v226, v1124);
                                                if v1125 == true {
                                                    let v1118 = constructor_iconst_u(ctx, v1113, 0x1_u64);
                                                    let v1119 = C::subsume(ctx, v1118);
                                                    // Rule at src/opts/icmp.isle line 167.
                                                    returns.extend(Some(v1119));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            let v52 = C::ty_int(ctx, v2.0);
                            if let Some(v53) = v52 {
                                if v164.0 == v164.1 {
                                    let v1043 = constructor_iconst_u(ctx, v53, 0x1_u64);
                                    let v1044 = C::subsume(ctx, v1043);
                                    // Rule at src/opts/icmp.isle line 13.
                                    returns.extend(Some(v1044));
                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                }
                            }
                        }
                        &IntCC::UnsignedGreaterThan => {
                            let v608 = C::fits_in_64(ctx, v2.0);
                            if let Some(v609) = v608 {
                                let v1112 = C::ty_int(ctx, v609);
                                if let Some(v1113) = v1112 {
                                    let v164 = C::unpack_value_array_2(ctx, v162);
                                    let mut v174 = C::inst_data_value_etor_returns::default();
                                    C::inst_data_value_etor(ctx, v164.1, &mut v174);
                                    let mut v174 = v174.into_context_iter();
                                    while let Some(v175) = v174.next(ctx) {
                                        if let &InstructionData::UnaryImm {
                                            opcode: ref v224,
                                            imm: v225,
                                        } = &v175.1 {
                                            if let &Opcode::Iconst = v224 {
                                                let v226 = C::u64_from_imm64(ctx, v225);
                                                if v226 == 0x0_u64 {
                                                    let v1117 = constructor_ne(ctx, v1113, v164.0, v164.1);
                                                    // Rule at src/opts/icmp.isle line 114.
                                                    returns.extend(Some(v1117));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                let v1120 = C::ty_umax(ctx, v175.0);
                                                let v1121 = C::u64_eq(ctx, v226, v1120);
                                                if v1121 == true {
                                                    let v1114 = constructor_iconst_u(ctx, v1113, 0x0_u64);
                                                    let v1115 = C::subsume(ctx, v1114);
                                                    // Rule at src/opts/icmp.isle line 132.
                                                    returns.extend(Some(v1115));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                    }
                                }
                                let v164 = C::unpack_value_array_2(ctx, v162);
                                let mut v167 = C::inst_data_value_etor_returns::default();
                                C::inst_data_value_etor(ctx, v164.0, &mut v167);
                                let mut v167 = v167.into_context_iter();
                                while let Some(v168) = v167.next(ctx) {
                                    if let &InstructionData::Binary {
                                        opcode: ref v212,
                                        args: ref v213,
                                    } = &v168.1 {
                                        if let &Opcode::Umin = v212 {
                                            let v214 = C::unpack_value_array_2(ctx, v213);
                                            if v164.1 == v214.0 {
                                                let v1216 = constructor_iconst_u(ctx, v609, 0x0_u64);
                                                // Rule at src/opts/selects.isle line 109.
                                                returns.extend(Some(v1216));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                            if v164.1 == v214.1 {
                                                let v1216 = constructor_iconst_u(ctx, v609, 0x0_u64);
                                                // Rule at src/opts/selects.isle line 110.
                                                returns.extend(Some(v1216));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                    }
                                }
                            }
                            let v52 = C::ty_int(ctx, v2.0);
                            if let Some(v53) = v52 {
                                let v164 = C::unpack_value_array_2(ctx, v162);
                                if v164.0 == v164.1 {
                                    let v55 = constructor_iconst_u(ctx, v53, 0x0_u64);
                                    let v56 = C::subsume(ctx, v55);
                                    // Rule at src/opts/icmp.isle line 6.
                                    returns.extend(Some(v56));
                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                }
                            }
                            let v164 = C::unpack_value_array_2(ctx, v162);
                            let mut v167 = C::inst_data_value_etor_returns::default();
                            C::inst_data_value_etor(ctx, v164.0, &mut v167);
                            let mut v167 = v167.into_context_iter();
                            while let Some(v168) = v167.next(ctx) {
                                if let &InstructionData::Binary {
                                    opcode: ref v212,
                                    args: ref v213,
                                } = &v168.1 {
                                    if let &Opcode::Isub = v212 {
                                        let v214 = C::unpack_value_array_2(ctx, v213);
                                        if v164.1 == v214.0 {
                                            let v1191 = constructor_ugt(ctx, v2.0, v214.1, v214.0);
                                            // Rule at src/opts/icmp.isle line 301.
                                            returns.extend(Some(v1191));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                    }
                                }
                            }
                        }
                        &IntCC::UnsignedGreaterThanOrEqual => {
                            let v164 = C::unpack_value_array_2(ctx, v162);
                            let mut v174 = C::inst_data_value_etor_returns::default();
                            C::inst_data_value_etor(ctx, v164.1, &mut v174);
                            let mut v174 = v174.into_context_iter();
                            while let Some(v175) = v174.next(ctx) {
                                if let &InstructionData::UnaryImm {
                                    opcode: ref v224,
                                    imm: v225,
                                } = &v175.1 {
                                    if let &Opcode::Iconst = v224 {
                                        let v226 = C::u64_from_imm64(ctx, v225);
                                        match v226 {
                                            0x0_u64 => {
                                                let v608 = C::fits_in_64(ctx, v2.0);
                                                if let Some(v609) = v608 {
                                                    let v1112 = C::ty_int(ctx, v609);
                                                    if let Some(v1113) = v1112 {
                                                        let v1118 = constructor_iconst_u(ctx, v1113, 0x1_u64);
                                                        let v1119 = C::subsume(ctx, v1118);
                                                        // Rule at src/opts/icmp.isle line 118.
                                                        returns.extend(Some(v1119));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            0x1_u64 => {
                                                let v1140 = constructor_iconst_u(ctx, v175.0, 0x0_u64);
                                                let v1141 = constructor_ne(ctx, v2.0, v164.0, v1140);
                                                // Rule at src/opts/icmp.isle line 192.
                                                returns.extend(Some(v1141));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                            _ => {}
                                        }
                                        let v608 = C::fits_in_64(ctx, v2.0);
                                        if let Some(v609) = v608 {
                                            let v1112 = C::ty_int(ctx, v609);
                                            if let Some(v1113) = v1112 {
                                                let v1120 = C::ty_umax(ctx, v175.0);
                                                let v1121 = C::u64_eq(ctx, v226, v1120);
                                                if v1121 == true {
                                                    let v1116 = constructor_eq(ctx, v1113, v164.0, v164.1);
                                                    // Rule at src/opts/icmp.isle line 137.
                                                    returns.extend(Some(v1116));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            let v52 = C::ty_int(ctx, v2.0);
                            if let Some(v53) = v52 {
                                if v164.0 == v164.1 {
                                    let v1043 = constructor_iconst_u(ctx, v53, 0x1_u64);
                                    let v1044 = C::subsume(ctx, v1043);
                                    // Rule at src/opts/icmp.isle line 7.
                                    returns.extend(Some(v1044));
                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                }
                            }
                        }
                        &IntCC::UnsignedLessThan => {
                            let v164 = C::unpack_value_array_2(ctx, v162);
                            let mut v174 = C::inst_data_value_etor_returns::default();
                            C::inst_data_value_etor(ctx, v164.1, &mut v174);
                            let mut v174 = v174.into_context_iter();
                            while let Some(v175) = v174.next(ctx) {
                                match &v175.1 {
                                    &InstructionData::Binary {
                                        opcode: ref v178,
                                        args: ref v179,
                                    } => {
                                        if let &Opcode::Umin = v178 {
                                            let v608 = C::fits_in_64(ctx, v2.0);
                                            if let Some(v609) = v608 {
                                                let v180 = C::unpack_value_array_2(ctx, v179);
                                                if v164.0 == v180.0 {
                                                    let v1216 = constructor_iconst_u(ctx, v609, 0x0_u64);
                                                    // Rule at src/opts/selects.isle line 111.
                                                    returns.extend(Some(v1216));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                if v164.0 == v180.1 {
                                                    let v1216 = constructor_iconst_u(ctx, v609, 0x0_u64);
                                                    // Rule at src/opts/selects.isle line 112.
                                                    returns.extend(Some(v1216));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                    }
                                    &InstructionData::Unary {
                                        opcode: ref v1211,
                                        arg: v1212,
                                    } => {
                                        if let &Opcode::Bnot = v1211 {
                                            let mut v167 = C::inst_data_value_etor_returns::default();
                                            C::inst_data_value_etor(ctx, v164.0, &mut v167);
                                            let mut v167 = v167.into_context_iter();
                                            while let Some(v168) = v167.next(ctx) {
                                                if let &InstructionData::Unary {
                                                    opcode: ref v992,
                                                    arg: v993,
                                                } = &v168.1 {
                                                    if let &Opcode::Bnot = v992 {
                                                        if v168.0 == v175.0 {
                                                            let v1213 = constructor_ugt(ctx, v2.0, v993, v1212);
                                                            // Rule at src/opts/icmp.isle line 308.
                                                            returns.extend(Some(v1213));
                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    &InstructionData::UnaryImm {
                                        opcode: ref v224,
                                        imm: v225,
                                    } => {
                                        if let &Opcode::Iconst = v224 {
                                            let v226 = C::u64_from_imm64(ctx, v225);
                                            match v226 {
                                                0x0_u64 => {
                                                    let v608 = C::fits_in_64(ctx, v2.0);
                                                    if let Some(v609) = v608 {
                                                        let v1112 = C::ty_int(ctx, v609);
                                                        if let Some(v1113) = v1112 {
                                                            let v1114 = constructor_iconst_u(ctx, v1113, 0x0_u64);
                                                            let v1115 = C::subsume(ctx, v1114);
                                                            // Rule at src/opts/icmp.isle line 106.
                                                            returns.extend(Some(v1115));
                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                        }
                                                    }
                                                }
                                                0x1_u64 => {
                                                    let v1140 = constructor_iconst_u(ctx, v175.0, 0x0_u64);
                                                    let v1142 = constructor_eq(ctx, v2.0, v164.0, v1140);
                                                    // Rule at src/opts/icmp.isle line 195.
                                                    returns.extend(Some(v1142));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                _ => {}
                                            }
                                            let v608 = C::fits_in_64(ctx, v2.0);
                                            if let Some(v609) = v608 {
                                                let v1112 = C::ty_int(ctx, v609);
                                                if let Some(v1113) = v1112 {
                                                    let v1120 = C::ty_umax(ctx, v175.0);
                                                    let v1121 = C::u64_eq(ctx, v226, v1120);
                                                    if v1121 == true {
                                                        let v1117 = constructor_ne(ctx, v1113, v164.0, v164.1);
                                                        // Rule at src/opts/icmp.isle line 122.
                                                        returns.extend(Some(v1117));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    _ => {}
                                }
                            }
                            let v52 = C::ty_int(ctx, v2.0);
                            if let Some(v53) = v52 {
                                if v164.0 == v164.1 {
                                    let v55 = constructor_iconst_u(ctx, v53, 0x0_u64);
                                    let v56 = C::subsume(ctx, v55);
                                    // Rule at src/opts/icmp.isle line 10.
                                    returns.extend(Some(v56));
                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                }
                            }
                        }
                        &IntCC::UnsignedLessThanOrEqual => {
                            let v608 = C::fits_in_64(ctx, v2.0);
                            if let Some(v609) = v608 {
                                let v1112 = C::ty_int(ctx, v609);
                                if let Some(v1113) = v1112 {
                                    let v164 = C::unpack_value_array_2(ctx, v162);
                                    let mut v174 = C::inst_data_value_etor_returns::default();
                                    C::inst_data_value_etor(ctx, v164.1, &mut v174);
                                    let mut v174 = v174.into_context_iter();
                                    while let Some(v175) = v174.next(ctx) {
                                        if let &InstructionData::UnaryImm {
                                            opcode: ref v224,
                                            imm: v225,
                                        } = &v175.1 {
                                            if let &Opcode::Iconst = v224 {
                                                let v226 = C::u64_from_imm64(ctx, v225);
                                                if v226 == 0x0_u64 {
                                                    let v1116 = constructor_eq(ctx, v1113, v164.0, v164.1);
                                                    // Rule at src/opts/icmp.isle line 110.
                                                    returns.extend(Some(v1116));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                let v1120 = C::ty_umax(ctx, v175.0);
                                                let v1121 = C::u64_eq(ctx, v226, v1120);
                                                if v1121 == true {
                                                    let v1118 = constructor_iconst_u(ctx, v1113, 0x1_u64);
                                                    let v1119 = C::subsume(ctx, v1118);
                                                    // Rule at src/opts/icmp.isle line 127.
                                                    returns.extend(Some(v1119));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            let v52 = C::ty_int(ctx, v2.0);
                            if let Some(v53) = v52 {
                                let v164 = C::unpack_value_array_2(ctx, v162);
                                if v164.0 == v164.1 {
                                    let v1043 = constructor_iconst_u(ctx, v53, 0x1_u64);
                                    let v1044 = C::subsume(ctx, v1043);
                                    // Rule at src/opts/icmp.isle line 11.
                                    returns.extend(Some(v1044));
                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                }
                            }
                            let v164 = C::unpack_value_array_2(ctx, v162);
                            let mut v167 = C::inst_data_value_etor_returns::default();
                            C::inst_data_value_etor(ctx, v164.0, &mut v167);
                            let mut v167 = v167.into_context_iter();
                            while let Some(v168) = v167.next(ctx) {
                                if let &InstructionData::Binary {
                                    opcode: ref v212,
                                    args: ref v213,
                                } = &v168.1 {
                                    if let &Opcode::Isub = v212 {
                                        let v214 = C::unpack_value_array_2(ctx, v213);
                                        if v164.1 == v214.0 {
                                            let v1192 = constructor_ule(ctx, v2.0, v214.1, v214.0);
                                            // Rule at src/opts/icmp.isle line 302.
                                            returns.extend(Some(v1192));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                    }
                                }
                            }
                        }
                        _ => {}
                    }
                    let v164 = C::unpack_value_array_2(ctx, v162);
                    let mut v167 = C::inst_data_value_etor_returns::default();
                    C::inst_data_value_etor(ctx, v164.0, &mut v167);
                    let mut v167 = v167.into_context_iter();
                    while let Some(v168) = v167.next(ctx) {
                        match &v168.1 {
                            &InstructionData::Unary {
                                opcode: ref v992,
                                arg: v993,
                            } => {
                                if let &Opcode::Sextend = v992 {
                                    let v1010 = &C::signed_cond_code(ctx, v163);
                                    if let Some(v1011) = v1010 {
                                        let mut v1000 = C::inst_data_value_tupled_etor_returns::default();
                                        C::inst_data_value_tupled_etor(ctx, v164.1, &mut v1000);
                                        let mut v1000 = v1000.into_context_iter();
                                        while let Some(v1001) = v1000.next(ctx) {
                                            let v1002 = C::iconst_sextend_etor(ctx, v1001);
                                            if let Some(v1003) = v1002 {
                                                if v1003.1 == 0_i64 {
                                                    let v994 = C::value_type(ctx, v993);
                                                    let v1007 = constructor_iconst_s(ctx, v994, 0_i64);
                                                    let v1012 = constructor_icmp(ctx, v994, v163, v993, v1007);
                                                    // Rule at src/opts/extends.isle line 43.
                                                    returns.extend(Some(v1012));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            &InstructionData::UnaryImm {
                                opcode: ref v171,
                                imm: v172,
                            } => {
                                if let &Opcode::Iconst = v171 {
                                    let mut v174 = C::inst_data_value_etor_returns::default();
                                    C::inst_data_value_etor(ctx, v164.1, &mut v174);
                                    let mut v174 = v174.into_context_iter();
                                    while let Some(v175) = v174.next(ctx) {
                                        if let &InstructionData::UnaryImm {
                                            opcode: ref v224,
                                            imm: v225,
                                        } = &v175.1 {
                                            if let &Opcode::Iconst = v224 {
                                                if v168.0 == v175.0 {
                                                    let v671 = C::imm64_icmp(ctx, v168.0, v163, v172, v225);
                                                    let v672 = constructor_iconst(ctx, v2.0, v671);
                                                    let v673 = C::subsume(ctx, v672);
                                                    // Rule at src/opts/cprop.isle line 103.
                                                    returns.extend(Some(v673));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                    }
                                    let v681 = &C::intcc_swap_args(ctx, v163);
                                    let v682 = constructor_icmp(ctx, v2.0, v681, v164.1, v164.0);
                                    // Rule at src/opts/cprop.isle line 137.
                                    returns.extend(Some(v682));
                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                }
                            }
                            _ => {}
                        }
                    }
                }
            }
            &InstructionData::Ternary {
                opcode: ref v84,
                args: ref v85,
            } => {
                match v84 {
                    &Opcode::Select => {
                        let v86 = C::unpack_value_array_3(ctx, v85);
                        let mut v90 = C::inst_data_value_etor_returns::default();
                        C::inst_data_value_etor(ctx, v86.0, &mut v90);
                        let mut v90 = v90.into_context_iter();
                        while let Some(v91) = v90.next(ctx) {
                            match &v91.1 {
                                &InstructionData::IntCompare {
                                    opcode: ref v1148,
                                    args: ref v1149,
                                    cond: ref v1150,
                                } => {
                                    if let &Opcode::Icmp = v1148 {
                                        match v1150 {
                                            &IntCC::Equal => {
                                                let mut v1164 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v86.2, &mut v1164);
                                                let mut v1164 = v1164.into_context_iter();
                                                while let Some(v1165) = v1164.next(ctx) {
                                                    match &v1165.1 {
                                                        &InstructionData::IntCompare {
                                                            opcode: ref v1168,
                                                            args: ref v1169,
                                                            cond: ref v1170,
                                                        } => {
                                                            if let &Opcode::Icmp = v1168 {
                                                                match v1170 {
                                                                    &IntCC::SignedGreaterThan => {
                                                                        let v1151 = C::unpack_value_array_2(ctx, v1149);
                                                                        let v1154 = C::value_type(ctx, v1151.0);
                                                                        if v1154 == I64 {
                                                                            let v1155 = C::value_type(ctx, v1151.1);
                                                                            if v1155 == I64 {
                                                                                if v2.0 == v1165.0 {
                                                                                    let v1171 = C::unpack_value_array_2(ctx, v1169);
                                                                                    if v1151.0 == v1171.0 {
                                                                                        if v1151.1 == v1171.1 {
                                                                                            let mut v96 = C::inst_data_value_etor_returns::default();
                                                                                            C::inst_data_value_etor(ctx, v86.1, &mut v96);
                                                                                            let mut v96 = v96.into_context_iter();
                                                                                            while let Some(v97) = v96.next(ctx) {
                                                                                                if let &InstructionData::IntCompare {
                                                                                                    opcode: ref v1156,
                                                                                                    args: ref v1157,
                                                                                                    cond: ref v1158,
                                                                                                } = &v97.1 {
                                                                                                    if let &Opcode::Icmp = v1156 {
                                                                                                        if let &IntCC::UnsignedGreaterThan = v1158 {
                                                                                                            let v1159 = C::unpack_value_array_2(ctx, v1157);
                                                                                                            let v1162 = C::value_type(ctx, v1159.0);
                                                                                                            if v1162 == I64 {
                                                                                                                let v1163 = C::value_type(ctx, v1159.1);
                                                                                                                if v1163 == I64 {
                                                                                                                    if v2.0 == v97.0 {
                                                                                                                        let v1174 = constructor_iconcat(ctx, I64, v1159.0, v1151.0);
                                                                                                                        let v1175 = constructor_iconcat(ctx, I64, v1159.1, v1151.1);
                                                                                                                        let v1179 = constructor_sgt(ctx, v2.0, v1174, v1175);
                                                                                                                        // Rule at src/opts/icmp.isle line 271.
                                                                                                                        returns.extend(Some(v1179));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::SignedGreaterThanOrEqual => {
                                                                        let v1151 = C::unpack_value_array_2(ctx, v1149);
                                                                        let v1154 = C::value_type(ctx, v1151.0);
                                                                        if v1154 == I64 {
                                                                            let v1155 = C::value_type(ctx, v1151.1);
                                                                            if v1155 == I64 {
                                                                                if v2.0 == v1165.0 {
                                                                                    let v1171 = C::unpack_value_array_2(ctx, v1169);
                                                                                    if v1151.0 == v1171.0 {
                                                                                        if v1151.1 == v1171.1 {
                                                                                            let mut v96 = C::inst_data_value_etor_returns::default();
                                                                                            C::inst_data_value_etor(ctx, v86.1, &mut v96);
                                                                                            let mut v96 = v96.into_context_iter();
                                                                                            while let Some(v97) = v96.next(ctx) {
                                                                                                if let &InstructionData::IntCompare {
                                                                                                    opcode: ref v1156,
                                                                                                    args: ref v1157,
                                                                                                    cond: ref v1158,
                                                                                                } = &v97.1 {
                                                                                                    if let &Opcode::Icmp = v1156 {
                                                                                                        if let &IntCC::UnsignedGreaterThanOrEqual = v1158 {
                                                                                                            let v1159 = C::unpack_value_array_2(ctx, v1157);
                                                                                                            let v1162 = C::value_type(ctx, v1159.0);
                                                                                                            if v1162 == I64 {
                                                                                                                let v1163 = C::value_type(ctx, v1159.1);
                                                                                                                if v1163 == I64 {
                                                                                                                    if v2.0 == v97.0 {
                                                                                                                        let v1174 = constructor_iconcat(ctx, I64, v1159.0, v1151.0);
                                                                                                                        let v1175 = constructor_iconcat(ctx, I64, v1159.1, v1151.1);
                                                                                                                        let v1177 = constructor_sge(ctx, v2.0, v1174, v1175);
                                                                                                                        // Rule at src/opts/icmp.isle line 261.
                                                                                                                        returns.extend(Some(v1177));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::SignedLessThan => {
                                                                        let v1151 = C::unpack_value_array_2(ctx, v1149);
                                                                        let v1154 = C::value_type(ctx, v1151.0);
                                                                        if v1154 == I64 {
                                                                            let v1155 = C::value_type(ctx, v1151.1);
                                                                            if v1155 == I64 {
                                                                                if v2.0 == v1165.0 {
                                                                                    let v1171 = C::unpack_value_array_2(ctx, v1169);
                                                                                    if v1151.0 == v1171.0 {
                                                                                        if v1151.1 == v1171.1 {
                                                                                            let mut v96 = C::inst_data_value_etor_returns::default();
                                                                                            C::inst_data_value_etor(ctx, v86.1, &mut v96);
                                                                                            let mut v96 = v96.into_context_iter();
                                                                                            while let Some(v97) = v96.next(ctx) {
                                                                                                if let &InstructionData::IntCompare {
                                                                                                    opcode: ref v1156,
                                                                                                    args: ref v1157,
                                                                                                    cond: ref v1158,
                                                                                                } = &v97.1 {
                                                                                                    if let &Opcode::Icmp = v1156 {
                                                                                                        if let &IntCC::UnsignedLessThan = v1158 {
                                                                                                            let v1159 = C::unpack_value_array_2(ctx, v1157);
                                                                                                            let v1162 = C::value_type(ctx, v1159.0);
                                                                                                            if v1162 == I64 {
                                                                                                                let v1163 = C::value_type(ctx, v1159.1);
                                                                                                                if v1163 == I64 {
                                                                                                                    if v2.0 == v97.0 {
                                                                                                                        let v1174 = constructor_iconcat(ctx, I64, v1159.0, v1151.0);
                                                                                                                        let v1175 = constructor_iconcat(ctx, I64, v1159.1, v1151.1);
                                                                                                                        let v1183 = constructor_slt(ctx, v2.0, v1174, v1175);
                                                                                                                        // Rule at src/opts/icmp.isle line 291.
                                                                                                                        returns.extend(Some(v1183));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::SignedLessThanOrEqual => {
                                                                        let v1151 = C::unpack_value_array_2(ctx, v1149);
                                                                        let v1154 = C::value_type(ctx, v1151.0);
                                                                        if v1154 == I64 {
                                                                            let v1155 = C::value_type(ctx, v1151.1);
                                                                            if v1155 == I64 {
                                                                                if v2.0 == v1165.0 {
                                                                                    let v1171 = C::unpack_value_array_2(ctx, v1169);
                                                                                    if v1151.0 == v1171.0 {
                                                                                        if v1151.1 == v1171.1 {
                                                                                            let mut v96 = C::inst_data_value_etor_returns::default();
                                                                                            C::inst_data_value_etor(ctx, v86.1, &mut v96);
                                                                                            let mut v96 = v96.into_context_iter();
                                                                                            while let Some(v97) = v96.next(ctx) {
                                                                                                if let &InstructionData::IntCompare {
                                                                                                    opcode: ref v1156,
                                                                                                    args: ref v1157,
                                                                                                    cond: ref v1158,
                                                                                                } = &v97.1 {
                                                                                                    if let &Opcode::Icmp = v1156 {
                                                                                                        if let &IntCC::UnsignedLessThanOrEqual = v1158 {
                                                                                                            let v1159 = C::unpack_value_array_2(ctx, v1157);
                                                                                                            let v1162 = C::value_type(ctx, v1159.0);
                                                                                                            if v1162 == I64 {
                                                                                                                let v1163 = C::value_type(ctx, v1159.1);
                                                                                                                if v1163 == I64 {
                                                                                                                    if v2.0 == v97.0 {
                                                                                                                        let v1174 = constructor_iconcat(ctx, I64, v1159.0, v1151.0);
                                                                                                                        let v1175 = constructor_iconcat(ctx, I64, v1159.1, v1151.1);
                                                                                                                        let v1181 = constructor_sle(ctx, v2.0, v1174, v1175);
                                                                                                                        // Rule at src/opts/icmp.isle line 281.
                                                                                                                        returns.extend(Some(v1181));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::UnsignedGreaterThan => {
                                                                        let v1151 = C::unpack_value_array_2(ctx, v1149);
                                                                        let v1154 = C::value_type(ctx, v1151.0);
                                                                        if v1154 == I64 {
                                                                            let v1155 = C::value_type(ctx, v1151.1);
                                                                            if v1155 == I64 {
                                                                                if v2.0 == v1165.0 {
                                                                                    let v1171 = C::unpack_value_array_2(ctx, v1169);
                                                                                    if v1151.0 == v1171.0 {
                                                                                        if v1151.1 == v1171.1 {
                                                                                            let mut v96 = C::inst_data_value_etor_returns::default();
                                                                                            C::inst_data_value_etor(ctx, v86.1, &mut v96);
                                                                                            let mut v96 = v96.into_context_iter();
                                                                                            while let Some(v97) = v96.next(ctx) {
                                                                                                if let &InstructionData::IntCompare {
                                                                                                    opcode: ref v1156,
                                                                                                    args: ref v1157,
                                                                                                    cond: ref v1158,
                                                                                                } = &v97.1 {
                                                                                                    if let &Opcode::Icmp = v1156 {
                                                                                                        if let &IntCC::UnsignedGreaterThan = v1158 {
                                                                                                            let v1159 = C::unpack_value_array_2(ctx, v1157);
                                                                                                            let v1162 = C::value_type(ctx, v1159.0);
                                                                                                            if v1162 == I64 {
                                                                                                                let v1163 = C::value_type(ctx, v1159.1);
                                                                                                                if v1163 == I64 {
                                                                                                                    if v2.0 == v97.0 {
                                                                                                                        let v1174 = constructor_iconcat(ctx, I64, v1159.0, v1151.0);
                                                                                                                        let v1175 = constructor_iconcat(ctx, I64, v1159.1, v1151.1);
                                                                                                                        let v1178 = constructor_ugt(ctx, v2.0, v1174, v1175);
                                                                                                                        // Rule at src/opts/icmp.isle line 266.
                                                                                                                        returns.extend(Some(v1178));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::UnsignedGreaterThanOrEqual => {
                                                                        let v1151 = C::unpack_value_array_2(ctx, v1149);
                                                                        let v1154 = C::value_type(ctx, v1151.0);
                                                                        if v1154 == I64 {
                                                                            let v1155 = C::value_type(ctx, v1151.1);
                                                                            if v1155 == I64 {
                                                                                if v2.0 == v1165.0 {
                                                                                    let v1171 = C::unpack_value_array_2(ctx, v1169);
                                                                                    if v1151.0 == v1171.0 {
                                                                                        if v1151.1 == v1171.1 {
                                                                                            let mut v96 = C::inst_data_value_etor_returns::default();
                                                                                            C::inst_data_value_etor(ctx, v86.1, &mut v96);
                                                                                            let mut v96 = v96.into_context_iter();
                                                                                            while let Some(v97) = v96.next(ctx) {
                                                                                                if let &InstructionData::IntCompare {
                                                                                                    opcode: ref v1156,
                                                                                                    args: ref v1157,
                                                                                                    cond: ref v1158,
                                                                                                } = &v97.1 {
                                                                                                    if let &Opcode::Icmp = v1156 {
                                                                                                        if let &IntCC::UnsignedGreaterThanOrEqual = v1158 {
                                                                                                            let v1159 = C::unpack_value_array_2(ctx, v1157);
                                                                                                            let v1162 = C::value_type(ctx, v1159.0);
                                                                                                            if v1162 == I64 {
                                                                                                                let v1163 = C::value_type(ctx, v1159.1);
                                                                                                                if v1163 == I64 {
                                                                                                                    if v2.0 == v97.0 {
                                                                                                                        let v1174 = constructor_iconcat(ctx, I64, v1159.0, v1151.0);
                                                                                                                        let v1175 = constructor_iconcat(ctx, I64, v1159.1, v1151.1);
                                                                                                                        let v1176 = constructor_uge(ctx, v2.0, v1174, v1175);
                                                                                                                        // Rule at src/opts/icmp.isle line 256.
                                                                                                                        returns.extend(Some(v1176));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::UnsignedLessThan => {
                                                                        let v1151 = C::unpack_value_array_2(ctx, v1149);
                                                                        let v1154 = C::value_type(ctx, v1151.0);
                                                                        if v1154 == I64 {
                                                                            let v1155 = C::value_type(ctx, v1151.1);
                                                                            if v1155 == I64 {
                                                                                if v2.0 == v1165.0 {
                                                                                    let v1171 = C::unpack_value_array_2(ctx, v1169);
                                                                                    if v1151.0 == v1171.0 {
                                                                                        if v1151.1 == v1171.1 {
                                                                                            let mut v96 = C::inst_data_value_etor_returns::default();
                                                                                            C::inst_data_value_etor(ctx, v86.1, &mut v96);
                                                                                            let mut v96 = v96.into_context_iter();
                                                                                            while let Some(v97) = v96.next(ctx) {
                                                                                                if let &InstructionData::IntCompare {
                                                                                                    opcode: ref v1156,
                                                                                                    args: ref v1157,
                                                                                                    cond: ref v1158,
                                                                                                } = &v97.1 {
                                                                                                    if let &Opcode::Icmp = v1156 {
                                                                                                        if let &IntCC::UnsignedLessThan = v1158 {
                                                                                                            let v1159 = C::unpack_value_array_2(ctx, v1157);
                                                                                                            let v1162 = C::value_type(ctx, v1159.0);
                                                                                                            if v1162 == I64 {
                                                                                                                let v1163 = C::value_type(ctx, v1159.1);
                                                                                                                if v1163 == I64 {
                                                                                                                    if v2.0 == v97.0 {
                                                                                                                        let v1174 = constructor_iconcat(ctx, I64, v1159.0, v1151.0);
                                                                                                                        let v1175 = constructor_iconcat(ctx, I64, v1159.1, v1151.1);
                                                                                                                        let v1182 = constructor_ult(ctx, v2.0, v1174, v1175);
                                                                                                                        // Rule at src/opts/icmp.isle line 286.
                                                                                                                        returns.extend(Some(v1182));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    &IntCC::UnsignedLessThanOrEqual => {
                                                                        let v1151 = C::unpack_value_array_2(ctx, v1149);
                                                                        let v1154 = C::value_type(ctx, v1151.0);
                                                                        if v1154 == I64 {
                                                                            let v1155 = C::value_type(ctx, v1151.1);
                                                                            if v1155 == I64 {
                                                                                if v2.0 == v1165.0 {
                                                                                    let v1171 = C::unpack_value_array_2(ctx, v1169);
                                                                                    if v1151.0 == v1171.0 {
                                                                                        if v1151.1 == v1171.1 {
                                                                                            let mut v96 = C::inst_data_value_etor_returns::default();
                                                                                            C::inst_data_value_etor(ctx, v86.1, &mut v96);
                                                                                            let mut v96 = v96.into_context_iter();
                                                                                            while let Some(v97) = v96.next(ctx) {
                                                                                                if let &InstructionData::IntCompare {
                                                                                                    opcode: ref v1156,
                                                                                                    args: ref v1157,
                                                                                                    cond: ref v1158,
                                                                                                } = &v97.1 {
                                                                                                    if let &Opcode::Icmp = v1156 {
                                                                                                        if let &IntCC::UnsignedLessThanOrEqual = v1158 {
                                                                                                            let v1159 = C::unpack_value_array_2(ctx, v1157);
                                                                                                            let v1162 = C::value_type(ctx, v1159.0);
                                                                                                            if v1162 == I64 {
                                                                                                                let v1163 = C::value_type(ctx, v1159.1);
                                                                                                                if v1163 == I64 {
                                                                                                                    if v2.0 == v97.0 {
                                                                                                                        let v1174 = constructor_iconcat(ctx, I64, v1159.0, v1151.0);
                                                                                                                        let v1175 = constructor_iconcat(ctx, I64, v1159.1, v1151.1);
                                                                                                                        let v1180 = constructor_ule(ctx, v2.0, v1174, v1175);
                                                                                                                        // Rule at src/opts/icmp.isle line 276.
                                                                                                                        returns.extend(Some(v1180));
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                    _ => {}
                                                                }
                                                            }
                                                        }
                                                        &InstructionData::Ternary {
                                                            opcode: ref v1361,
                                                            args: ref v1362,
                                                        } => {
                                                            if let &Opcode::Select = v1361 {
                                                                if v2.0 == v1165.0 {
                                                                    let mut v1289 = C::inst_data_value_tupled_etor_returns::default();
                                                                    C::inst_data_value_tupled_etor(ctx, v86.1, &mut v1289);
                                                                    let mut v1289 = v1289.into_context_iter();
                                                                    while let Some(v1290) = v1289.next(ctx) {
                                                                        let v1291 = C::iconst_sextend_etor(ctx, v1290);
                                                                        if let Some(v1292) = v1291 {
                                                                            if v1292.1 == 0_i64 {
                                                                                if v2.0 == v1292.0 {
                                                                                    let v1363 = C::unpack_value_array_3(ctx, v1362);
                                                                                    let mut v1479 = C::inst_data_value_etor_returns::default();
                                                                                    C::inst_data_value_etor(ctx, v1363.0, &mut v1479);
                                                                                    let mut v1479 = v1479.into_context_iter();
                                                                                    while let Some(v1480) = v1479.next(ctx) {
                                                                                        if let &InstructionData::IntCompare {
                                                                                            opcode: ref v1483,
                                                                                            args: ref v1484,
                                                                                            cond: ref v1485,
                                                                                        } = &v1480.1 {
                                                                                            if let &Opcode::Icmp = v1483 {
                                                                                                match v1485 {
                                                                                                    &IntCC::SignedGreaterThan => {
                                                                                                        if v91.0 == v1480.0 {
                                                                                                            let v1151 = C::unpack_value_array_2(ctx, v1149);
                                                                                                            let v1486 = C::unpack_value_array_2(ctx, v1484);
                                                                                                            if v1151.0 == v1486.0 {
                                                                                                                if v1151.1 == v1486.1 {
                                                                                                                    let mut v1489 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1363.1, &mut v1489);
                                                                                                                    let mut v1489 = v1489.into_context_iter();
                                                                                                                    while let Some(v1490) = v1489.next(ctx) {
                                                                                                                        let v1491 = C::iconst_sextend_etor(ctx, v1490);
                                                                                                                        if let Some(v1492) = v1491 {
                                                                                                                            if v1492.1 == 1_i64 {
                                                                                                                                if v2.0 == v1492.0 {
                                                                                                                                    let mut v1495 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1363.2, &mut v1495);
                                                                                                                                    let mut v1495 = v1495.into_context_iter();
                                                                                                                                    while let Some(v1496) = v1495.next(ctx) {
                                                                                                                                        let v1497 = C::iconst_sextend_etor(ctx, v1496);
                                                                                                                                        if let Some(v1498) = v1497 {
                                                                                                                                            if v1498.1 == -1_i64 {
                                                                                                                                                if v2.0 == v1498.0 {
                                                                                                                                                    let v1511 = constructor_spaceship_s(ctx, v91.0, v1151.0, v1151.1);
                                                                                                                                                    let v1512 = constructor_sextend_maybe(ctx, v2.0, v1511);
                                                                                                                                                    // Rule at src/opts/spaceship.isle line 103.
                                                                                                                                                    returns.extend(Some(v1512));
                                                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                                                }
                                                                                                                                            }
                                                                                                                                        }
                                                                                                                                    }
                                                                                                                                }
                                                                                                                            }
                                                                                                                        }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                    &IntCC::SignedGreaterThanOrEqual => {
                                                                                                        if v91.0 == v1480.0 {
                                                                                                            let v1151 = C::unpack_value_array_2(ctx, v1149);
                                                                                                            let v1486 = C::unpack_value_array_2(ctx, v1484);
                                                                                                            if v1151.0 == v1486.0 {
                                                                                                                if v1151.1 == v1486.1 {
                                                                                                                    let mut v1489 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1363.1, &mut v1489);
                                                                                                                    let mut v1489 = v1489.into_context_iter();
                                                                                                                    while let Some(v1490) = v1489.next(ctx) {
                                                                                                                        let v1491 = C::iconst_sextend_etor(ctx, v1490);
                                                                                                                        if let Some(v1492) = v1491 {
                                                                                                                            if v1492.1 == 1_i64 {
                                                                                                                                if v2.0 == v1492.0 {
                                                                                                                                    let mut v1495 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1363.2, &mut v1495);
                                                                                                                                    let mut v1495 = v1495.into_context_iter();
                                                                                                                                    while let Some(v1496) = v1495.next(ctx) {
                                                                                                                                        let v1497 = C::iconst_sextend_etor(ctx, v1496);
                                                                                                                                        if let Some(v1498) = v1497 {
                                                                                                                                            if v1498.1 == -1_i64 {
                                                                                                                                                if v2.0 == v1498.0 {
                                                                                                                                                    let v1511 = constructor_spaceship_s(ctx, v91.0, v1151.0, v1151.1);
                                                                                                                                                    let v1512 = constructor_sextend_maybe(ctx, v2.0, v1511);
                                                                                                                                                    // Rule at src/opts/spaceship.isle line 110.
                                                                                                                                                    returns.extend(Some(v1512));
                                                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                                                }
                                                                                                                                            }
                                                                                                                                        }
                                                                                                                                    }
                                                                                                                                }
                                                                                                                            }
                                                                                                                        }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                    &IntCC::SignedLessThan => {
                                                                                                        if v91.0 == v1480.0 {
                                                                                                            let v1151 = C::unpack_value_array_2(ctx, v1149);
                                                                                                            let v1486 = C::unpack_value_array_2(ctx, v1484);
                                                                                                            if v1151.0 == v1486.0 {
                                                                                                                if v1151.1 == v1486.1 {
                                                                                                                    let mut v1489 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1363.1, &mut v1489);
                                                                                                                    let mut v1489 = v1489.into_context_iter();
                                                                                                                    while let Some(v1490) = v1489.next(ctx) {
                                                                                                                        let v1491 = C::iconst_sextend_etor(ctx, v1490);
                                                                                                                        if let Some(v1492) = v1491 {
                                                                                                                            if v1492.1 == -1_i64 {
                                                                                                                                if v2.0 == v1492.0 {
                                                                                                                                    let mut v1495 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1363.2, &mut v1495);
                                                                                                                                    let mut v1495 = v1495.into_context_iter();
                                                                                                                                    while let Some(v1496) = v1495.next(ctx) {
                                                                                                                                        let v1497 = C::iconst_sextend_etor(ctx, v1496);
                                                                                                                                        if let Some(v1498) = v1497 {
                                                                                                                                            if v1498.1 == 1_i64 {
                                                                                                                                                if v2.0 == v1498.0 {
                                                                                                                                                    let v1511 = constructor_spaceship_s(ctx, v91.0, v1151.0, v1151.1);
                                                                                                                                                    let v1512 = constructor_sextend_maybe(ctx, v2.0, v1511);
                                                                                                                                                    // Rule at src/opts/spaceship.isle line 89.
                                                                                                                                                    returns.extend(Some(v1512));
                                                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                                                }
                                                                                                                                            }
                                                                                                                                        }
                                                                                                                                    }
                                                                                                                                }
                                                                                                                            }
                                                                                                                        }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                    &IntCC::SignedLessThanOrEqual => {
                                                                                                        if v91.0 == v1480.0 {
                                                                                                            let v1151 = C::unpack_value_array_2(ctx, v1149);
                                                                                                            let v1486 = C::unpack_value_array_2(ctx, v1484);
                                                                                                            if v1151.0 == v1486.0 {
                                                                                                                if v1151.1 == v1486.1 {
                                                                                                                    let mut v1489 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1363.1, &mut v1489);
                                                                                                                    let mut v1489 = v1489.into_context_iter();
                                                                                                                    while let Some(v1490) = v1489.next(ctx) {
                                                                                                                        let v1491 = C::iconst_sextend_etor(ctx, v1490);
                                                                                                                        if let Some(v1492) = v1491 {
                                                                                                                            if v1492.1 == -1_i64 {
                                                                                                                                if v2.0 == v1492.0 {
                                                                                                                                    let mut v1495 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1363.2, &mut v1495);
                                                                                                                                    let mut v1495 = v1495.into_context_iter();
                                                                                                                                    while let Some(v1496) = v1495.next(ctx) {
                                                                                                                                        let v1497 = C::iconst_sextend_etor(ctx, v1496);
                                                                                                                                        if let Some(v1498) = v1497 {
                                                                                                                                            if v1498.1 == 1_i64 {
                                                                                                                                                if v2.0 == v1498.0 {
                                                                                                                                                    let v1511 = constructor_spaceship_s(ctx, v91.0, v1151.0, v1151.1);
                                                                                                                                                    let v1512 = constructor_sextend_maybe(ctx, v2.0, v1511);
                                                                                                                                                    // Rule at src/opts/spaceship.isle line 96.
                                                                                                                                                    returns.extend(Some(v1512));
                                                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                                                }
                                                                                                                                            }
                                                                                                                                        }
                                                                                                                                    }
                                                                                                                                }
                                                                                                                            }
                                                                                                                        }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                    &IntCC::UnsignedGreaterThan => {
                                                                                                        if v91.0 == v1480.0 {
                                                                                                            let v1151 = C::unpack_value_array_2(ctx, v1149);
                                                                                                            let v1486 = C::unpack_value_array_2(ctx, v1484);
                                                                                                            if v1151.0 == v1486.0 {
                                                                                                                if v1151.1 == v1486.1 {
                                                                                                                    let mut v1489 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1363.1, &mut v1489);
                                                                                                                    let mut v1489 = v1489.into_context_iter();
                                                                                                                    while let Some(v1490) = v1489.next(ctx) {
                                                                                                                        let v1491 = C::iconst_sextend_etor(ctx, v1490);
                                                                                                                        if let Some(v1492) = v1491 {
                                                                                                                            if v1492.1 == 1_i64 {
                                                                                                                                if v2.0 == v1492.0 {
                                                                                                                                    let mut v1495 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1363.2, &mut v1495);
                                                                                                                                    let mut v1495 = v1495.into_context_iter();
                                                                                                                                    while let Some(v1496) = v1495.next(ctx) {
                                                                                                                                        let v1497 = C::iconst_sextend_etor(ctx, v1496);
                                                                                                                                        if let Some(v1498) = v1497 {
                                                                                                                                            if v1498.1 == -1_i64 {
                                                                                                                                                if v2.0 == v1498.0 {
                                                                                                                                                    let v1477 = constructor_spaceship_u(ctx, v91.0, v1151.0, v1151.1);
                                                                                                                                                    let v1478 = constructor_sextend_maybe(ctx, v2.0, v1477);
                                                                                                                                                    // Rule at src/opts/spaceship.isle line 38.
                                                                                                                                                    returns.extend(Some(v1478));
                                                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                                                }
                                                                                                                                            }
                                                                                                                                        }
                                                                                                                                    }
                                                                                                                                }
                                                                                                                            }
                                                                                                                        }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                    &IntCC::UnsignedGreaterThanOrEqual => {
                                                                                                        if v91.0 == v1480.0 {
                                                                                                            let v1151 = C::unpack_value_array_2(ctx, v1149);
                                                                                                            let v1486 = C::unpack_value_array_2(ctx, v1484);
                                                                                                            if v1151.0 == v1486.0 {
                                                                                                                if v1151.1 == v1486.1 {
                                                                                                                    let mut v1489 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1363.1, &mut v1489);
                                                                                                                    let mut v1489 = v1489.into_context_iter();
                                                                                                                    while let Some(v1490) = v1489.next(ctx) {
                                                                                                                        let v1491 = C::iconst_sextend_etor(ctx, v1490);
                                                                                                                        if let Some(v1492) = v1491 {
                                                                                                                            if v1492.1 == 1_i64 {
                                                                                                                                if v2.0 == v1492.0 {
                                                                                                                                    let mut v1495 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1363.2, &mut v1495);
                                                                                                                                    let mut v1495 = v1495.into_context_iter();
                                                                                                                                    while let Some(v1496) = v1495.next(ctx) {
                                                                                                                                        let v1497 = C::iconst_sextend_etor(ctx, v1496);
                                                                                                                                        if let Some(v1498) = v1497 {
                                                                                                                                            if v1498.1 == -1_i64 {
                                                                                                                                                if v2.0 == v1498.0 {
                                                                                                                                                    let v1477 = constructor_spaceship_u(ctx, v91.0, v1151.0, v1151.1);
                                                                                                                                                    let v1478 = constructor_sextend_maybe(ctx, v2.0, v1477);
                                                                                                                                                    // Rule at src/opts/spaceship.isle line 45.
                                                                                                                                                    returns.extend(Some(v1478));
                                                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                                                }
                                                                                                                                            }
                                                                                                                                        }
                                                                                                                                    }
                                                                                                                                }
                                                                                                                            }
                                                                                                                        }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                    &IntCC::UnsignedLessThan => {
                                                                                                        if v91.0 == v1480.0 {
                                                                                                            let v1151 = C::unpack_value_array_2(ctx, v1149);
                                                                                                            let v1486 = C::unpack_value_array_2(ctx, v1484);
                                                                                                            if v1151.0 == v1486.0 {
                                                                                                                if v1151.1 == v1486.1 {
                                                                                                                    let mut v1489 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1363.1, &mut v1489);
                                                                                                                    let mut v1489 = v1489.into_context_iter();
                                                                                                                    while let Some(v1490) = v1489.next(ctx) {
                                                                                                                        let v1491 = C::iconst_sextend_etor(ctx, v1490);
                                                                                                                        if let Some(v1492) = v1491 {
                                                                                                                            if v1492.1 == -1_i64 {
                                                                                                                                if v2.0 == v1492.0 {
                                                                                                                                    let mut v1495 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1363.2, &mut v1495);
                                                                                                                                    let mut v1495 = v1495.into_context_iter();
                                                                                                                                    while let Some(v1496) = v1495.next(ctx) {
                                                                                                                                        let v1497 = C::iconst_sextend_etor(ctx, v1496);
                                                                                                                                        if let Some(v1498) = v1497 {
                                                                                                                                            if v1498.1 == 1_i64 {
                                                                                                                                                if v2.0 == v1498.0 {
                                                                                                                                                    let v1477 = constructor_spaceship_u(ctx, v91.0, v1151.0, v1151.1);
                                                                                                                                                    let v1478 = constructor_sextend_maybe(ctx, v2.0, v1477);
                                                                                                                                                    // Rule at src/opts/spaceship.isle line 24.
                                                                                                                                                    returns.extend(Some(v1478));
                                                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                                                }
                                                                                                                                            }
                                                                                                                                        }
                                                                                                                                    }
                                                                                                                                }
                                                                                                                            }
                                                                                                                        }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                    &IntCC::UnsignedLessThanOrEqual => {
                                                                                                        if v91.0 == v1480.0 {
                                                                                                            let v1151 = C::unpack_value_array_2(ctx, v1149);
                                                                                                            let v1486 = C::unpack_value_array_2(ctx, v1484);
                                                                                                            if v1151.0 == v1486.0 {
                                                                                                                if v1151.1 == v1486.1 {
                                                                                                                    let mut v1489 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1363.1, &mut v1489);
                                                                                                                    let mut v1489 = v1489.into_context_iter();
                                                                                                                    while let Some(v1490) = v1489.next(ctx) {
                                                                                                                        let v1491 = C::iconst_sextend_etor(ctx, v1490);
                                                                                                                        if let Some(v1492) = v1491 {
                                                                                                                            if v1492.1 == -1_i64 {
                                                                                                                                if v2.0 == v1492.0 {
                                                                                                                                    let mut v1495 = C::inst_data_value_tupled_etor_returns::default();
                                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1363.2, &mut v1495);
                                                                                                                                    let mut v1495 = v1495.into_context_iter();
                                                                                                                                    while let Some(v1496) = v1495.next(ctx) {
                                                                                                                                        let v1497 = C::iconst_sextend_etor(ctx, v1496);
                                                                                                                                        if let Some(v1498) = v1497 {
                                                                                                                                            if v1498.1 == 1_i64 {
                                                                                                                                                if v2.0 == v1498.0 {
                                                                                                                                                    let v1477 = constructor_spaceship_u(ctx, v91.0, v1151.0, v1151.1);
                                                                                                                                                    let v1478 = constructor_sextend_maybe(ctx, v2.0, v1477);
                                                                                                                                                    // Rule at src/opts/spaceship.isle line 31.
                                                                                                                                                    returns.extend(Some(v1478));
                                                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                                                }
                                                                                                                                            }
                                                                                                                                        }
                                                                                                                                    }
                                                                                                                                }
                                                                                                                            }
                                                                                                                        }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                    _ => {}
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                            }
                                            &IntCC::SignedGreaterThan => {
                                                let mut v1164 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v86.2, &mut v1164);
                                                let mut v1164 = v1164.into_context_iter();
                                                while let Some(v1165) = v1164.next(ctx) {
                                                    if let &InstructionData::Unary {
                                                        opcode: ref v1319,
                                                        arg: v1320,
                                                    } = &v1165.1 {
                                                        match v1319 {
                                                            &Opcode::Ineg => {
                                                                if v91.0 == v1165.0 {
                                                                    let mut v1289 = C::inst_data_value_tupled_etor_returns::default();
                                                                    C::inst_data_value_tupled_etor(ctx, v86.1, &mut v1289);
                                                                    let mut v1289 = v1289.into_context_iter();
                                                                    while let Some(v1290) = v1289.next(ctx) {
                                                                        let v1291 = C::iconst_sextend_etor(ctx, v1290);
                                                                        if let Some(v1292) = v1291 {
                                                                            if v1292.1 == 1_i64 {
                                                                                if v2.0 == v1292.0 {
                                                                                    let mut v1501 = C::inst_data_value_etor_returns::default();
                                                                                    C::inst_data_value_etor(ctx, v1320, &mut v1501);
                                                                                    let mut v1501 = v1501.into_context_iter();
                                                                                    while let Some(v1502) = v1501.next(ctx) {
                                                                                        if let &InstructionData::IntCompare {
                                                                                            opcode: ref v1505,
                                                                                            args: ref v1506,
                                                                                            cond: ref v1507,
                                                                                        } = &v1502.1 {
                                                                                            if let &Opcode::Icmp = v1505 {
                                                                                                match v1507 {
                                                                                                    &IntCC::NotEqual => {
                                                                                                        if v91.0 == v1502.0 {
                                                                                                            let v1151 = C::unpack_value_array_2(ctx, v1149);
                                                                                                            let v1508 = C::unpack_value_array_2(ctx, v1506);
                                                                                                            if v1151.0 == v1508.0 {
                                                                                                                if v1151.1 == v1508.1 {
                                                                                                                    let v1511 = constructor_spaceship_s(ctx, v91.0, v1151.0, v1151.1);
                                                                                                                    let v1512 = constructor_sextend_maybe(ctx, v2.0, v1511);
                                                                                                                    // Rule at src/opts/spaceship.isle line 129.
                                                                                                                    returns.extend(Some(v1512));
                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                    &IntCC::SignedLessThan => {
                                                                                                        if v91.0 == v1502.0 {
                                                                                                            let v1151 = C::unpack_value_array_2(ctx, v1149);
                                                                                                            let v1508 = C::unpack_value_array_2(ctx, v1506);
                                                                                                            if v1151.0 == v1508.0 {
                                                                                                                if v1151.1 == v1508.1 {
                                                                                                                    let v1511 = constructor_spaceship_s(ctx, v91.0, v1151.0, v1151.1);
                                                                                                                    let v1512 = constructor_sextend_maybe(ctx, v2.0, v1511);
                                                                                                                    // Rule at src/opts/spaceship.isle line 119.
                                                                                                                    returns.extend(Some(v1512));
                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                    _ => {}
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                if v2.0 == v1165.0 {
                                                                    let v1151 = C::unpack_value_array_2(ctx, v1149);
                                                                    if v86.1 == v1151.0 {
                                                                        if v86.1 == v1320 {
                                                                            let mut v1325 = C::inst_data_value_etor_returns::default();
                                                                            C::inst_data_value_etor(ctx, v1151.1, &mut v1325);
                                                                            let mut v1325 = v1325.into_context_iter();
                                                                            while let Some(v1326) = v1325.next(ctx) {
                                                                                if let &InstructionData::UnaryImm {
                                                                                    opcode: ref v1329,
                                                                                    imm: v1330,
                                                                                } = &v1326.1 {
                                                                                    if let &Opcode::Iconst = v1329 {
                                                                                        let v1331 = C::u64_from_imm64(ctx, v1330);
                                                                                        if v1331 == 0x0_u64 {
                                                                                            if v2.0 == v1326.0 {
                                                                                                let v1332 = constructor_iabs(ctx, v2.0, v1151.0);
                                                                                                let v1333 = C::subsume(ctx, v1332);
                                                                                                // Rule at src/opts/selects.isle line 89.
                                                                                                returns.extend(Some(v1333));
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            &Opcode::Bmask => {
                                                                if v2.0 == v1165.0 {
                                                                    let mut v1289 = C::inst_data_value_tupled_etor_returns::default();
                                                                    C::inst_data_value_tupled_etor(ctx, v86.1, &mut v1289);
                                                                    let mut v1289 = v1289.into_context_iter();
                                                                    while let Some(v1290) = v1289.next(ctx) {
                                                                        let v1291 = C::iconst_sextend_etor(ctx, v1290);
                                                                        if let Some(v1292) = v1291 {
                                                                            if v1292.1 == 1_i64 {
                                                                                if v2.0 == v1292.0 {
                                                                                    let mut v1501 = C::inst_data_value_etor_returns::default();
                                                                                    C::inst_data_value_etor(ctx, v1320, &mut v1501);
                                                                                    let mut v1501 = v1501.into_context_iter();
                                                                                    while let Some(v1502) = v1501.next(ctx) {
                                                                                        if let &InstructionData::IntCompare {
                                                                                            opcode: ref v1505,
                                                                                            args: ref v1506,
                                                                                            cond: ref v1507,
                                                                                        } = &v1502.1 {
                                                                                            if let &Opcode::Icmp = v1505 {
                                                                                                match v1507 {
                                                                                                    &IntCC::NotEqual => {
                                                                                                        if v91.0 == v1502.0 {
                                                                                                            let v1151 = C::unpack_value_array_2(ctx, v1149);
                                                                                                            let v1508 = C::unpack_value_array_2(ctx, v1506);
                                                                                                            if v1151.0 == v1508.0 {
                                                                                                                if v1151.1 == v1508.1 {
                                                                                                                    let v1511 = constructor_spaceship_s(ctx, v91.0, v1151.0, v1151.1);
                                                                                                                    let v1512 = constructor_sextend_maybe(ctx, v2.0, v1511);
                                                                                                                    // Rule at src/opts/spaceship.isle line 133.
                                                                                                                    returns.extend(Some(v1512));
                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                    &IntCC::SignedLessThan => {
                                                                                                        if v91.0 == v1502.0 {
                                                                                                            let v1151 = C::unpack_value_array_2(ctx, v1149);
                                                                                                            let v1508 = C::unpack_value_array_2(ctx, v1506);
                                                                                                            if v1151.0 == v1508.0 {
                                                                                                                if v1151.1 == v1508.1 {
                                                                                                                    let v1511 = constructor_spaceship_s(ctx, v91.0, v1151.0, v1151.1);
                                                                                                                    let v1512 = constructor_sextend_maybe(ctx, v2.0, v1511);
                                                                                                                    // Rule at src/opts/spaceship.isle line 123.
                                                                                                                    returns.extend(Some(v1512));
                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                    _ => {}
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            _ => {}
                                                        }
                                                    }
                                                }
                                                let v1151 = C::unpack_value_array_2(ctx, v1149);
                                                if v86.1 == v1151.0 {
                                                    if v86.2 == v1151.1 {
                                                        let v1302 = constructor_smax(ctx, v2.0, v1151.0, v1151.1);
                                                        // Rule at src/opts/selects.isle line 25.
                                                        returns.extend(Some(v1302));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v86.2 == v1151.0 {
                                                    if v86.1 == v1151.1 {
                                                        let v1304 = constructor_smin(ctx, v2.0, v1151.0, v1151.1);
                                                        // Rule at src/opts/selects.isle line 39.
                                                        returns.extend(Some(v1304));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            &IntCC::SignedGreaterThanOrEqual => {
                                                let v1151 = C::unpack_value_array_2(ctx, v1149);
                                                if v86.1 == v1151.0 {
                                                    if v86.2 == v1151.1 {
                                                        let v1302 = constructor_smax(ctx, v2.0, v1151.0, v1151.1);
                                                        // Rule at src/opts/selects.isle line 26.
                                                        returns.extend(Some(v1302));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                    let mut v1164 = C::inst_data_value_etor_returns::default();
                                                    C::inst_data_value_etor(ctx, v86.2, &mut v1164);
                                                    let mut v1164 = v1164.into_context_iter();
                                                    while let Some(v1165) = v1164.next(ctx) {
                                                        if let &InstructionData::Unary {
                                                            opcode: ref v1319,
                                                            arg: v1320,
                                                        } = &v1165.1 {
                                                            if let &Opcode::Ineg = v1319 {
                                                                if v86.1 == v1320 {
                                                                    if v2.0 == v1165.0 {
                                                                        let mut v1325 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v1151.1, &mut v1325);
                                                                        let mut v1325 = v1325.into_context_iter();
                                                                        while let Some(v1326) = v1325.next(ctx) {
                                                                            if let &InstructionData::UnaryImm {
                                                                                opcode: ref v1329,
                                                                                imm: v1330,
                                                                            } = &v1326.1 {
                                                                                if let &Opcode::Iconst = v1329 {
                                                                                    let v1331 = C::u64_from_imm64(ctx, v1330);
                                                                                    if v1331 == 0x0_u64 {
                                                                                        if v2.0 == v1326.0 {
                                                                                            let v1332 = constructor_iabs(ctx, v2.0, v1151.0);
                                                                                            let v1333 = C::subsume(ctx, v1332);
                                                                                            // Rule at src/opts/selects.isle line 90.
                                                                                            returns.extend(Some(v1333));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                if v86.1 == v1151.1 {
                                                    if v86.2 == v1151.0 {
                                                        let v1304 = constructor_smin(ctx, v2.0, v1151.0, v1151.1);
                                                        // Rule at src/opts/selects.isle line 40.
                                                        returns.extend(Some(v1304));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            &IntCC::SignedLessThan => {
                                                let v1151 = C::unpack_value_array_2(ctx, v1149);
                                                if v86.2 == v1151.0 {
                                                    if v86.1 == v1151.1 {
                                                        let v1302 = constructor_smax(ctx, v2.0, v1151.0, v1151.1);
                                                        // Rule at src/opts/selects.isle line 35.
                                                        returns.extend(Some(v1302));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                    let mut v96 = C::inst_data_value_etor_returns::default();
                                                    C::inst_data_value_etor(ctx, v86.1, &mut v96);
                                                    let mut v96 = v96.into_context_iter();
                                                    while let Some(v97) = v96.next(ctx) {
                                                        if let &InstructionData::Unary {
                                                            opcode: ref v100,
                                                            arg: v101,
                                                        } = &v97.1 {
                                                            if let &Opcode::Ineg = v100 {
                                                                if v86.2 == v101 {
                                                                    if v2.0 == v97.0 {
                                                                        let mut v1325 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v1151.1, &mut v1325);
                                                                        let mut v1325 = v1325.into_context_iter();
                                                                        while let Some(v1326) = v1325.next(ctx) {
                                                                            if let &InstructionData::UnaryImm {
                                                                                opcode: ref v1329,
                                                                                imm: v1330,
                                                                            } = &v1326.1 {
                                                                                if let &Opcode::Iconst = v1329 {
                                                                                    let v1331 = C::u64_from_imm64(ctx, v1330);
                                                                                    if v1331 == 0x0_u64 {
                                                                                        if v2.0 == v1326.0 {
                                                                                            let v1332 = constructor_iabs(ctx, v2.0, v1151.0);
                                                                                            let v1333 = C::subsume(ctx, v1332);
                                                                                            // Rule at src/opts/selects.isle line 92.
                                                                                            returns.extend(Some(v1333));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                let mut v1289 = C::inst_data_value_tupled_etor_returns::default();
                                                C::inst_data_value_tupled_etor(ctx, v86.1, &mut v1289);
                                                let mut v1289 = v1289.into_context_iter();
                                                while let Some(v1290) = v1289.next(ctx) {
                                                    let v1291 = C::iconst_sextend_etor(ctx, v1290);
                                                    if let Some(v1292) = v1291 {
                                                        if v1292.1 == -1_i64 {
                                                            if v2.0 == v1292.0 {
                                                                let mut v1463 = C::uextend_maybe_etor_returns::default();
                                                                C::uextend_maybe_etor(ctx, v86.2, &mut v1463);
                                                                let mut v1463 = v1463.into_context_iter();
                                                                while let Some(v1464) = v1463.next(ctx) {
                                                                    if v2.0 == v1464.0 {
                                                                        let mut v1467 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v1464.1, &mut v1467);
                                                                        let mut v1467 = v1467.into_context_iter();
                                                                        while let Some(v1468) = v1467.next(ctx) {
                                                                            if let &InstructionData::IntCompare {
                                                                                opcode: ref v1471,
                                                                                args: ref v1472,
                                                                                cond: ref v1473,
                                                                            } = &v1468.1 {
                                                                                if let &Opcode::Icmp = v1471 {
                                                                                    match v1473 {
                                                                                        &IntCC::NotEqual => {
                                                                                            if v91.0 == v1468.0 {
                                                                                                let v1474 = C::unpack_value_array_2(ctx, v1472);
                                                                                                if v1151.0 == v1474.0 {
                                                                                                    if v1151.1 == v1474.1 {
                                                                                                        let v1511 = constructor_spaceship_s(ctx, v91.0, v1151.0, v1151.1);
                                                                                                        let v1512 = constructor_sextend_maybe(ctx, v2.0, v1511);
                                                                                                        // Rule at src/opts/spaceship.isle line 77.
                                                                                                        returns.extend(Some(v1512));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                        &IntCC::SignedGreaterThan => {
                                                                                            if v91.0 == v1468.0 {
                                                                                                let v1474 = C::unpack_value_array_2(ctx, v1472);
                                                                                                if v1151.0 == v1474.0 {
                                                                                                    if v1151.1 == v1474.1 {
                                                                                                        let v1511 = constructor_spaceship_s(ctx, v91.0, v1151.0, v1151.1);
                                                                                                        let v1512 = constructor_sextend_maybe(ctx, v2.0, v1511);
                                                                                                        // Rule at src/opts/spaceship.isle line 83.
                                                                                                        returns.extend(Some(v1512));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                        _ => {}
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                if v86.1 == v1151.0 {
                                                    if v86.2 == v1151.1 {
                                                        let v1304 = constructor_smin(ctx, v2.0, v1151.0, v1151.1);
                                                        // Rule at src/opts/selects.isle line 29.
                                                        returns.extend(Some(v1304));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            &IntCC::SignedLessThanOrEqual => {
                                                let v1151 = C::unpack_value_array_2(ctx, v1149);
                                                if v86.2 == v1151.0 {
                                                    if v86.1 == v1151.1 {
                                                        let v1302 = constructor_smax(ctx, v2.0, v1151.0, v1151.1);
                                                        // Rule at src/opts/selects.isle line 36.
                                                        returns.extend(Some(v1302));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                    let mut v96 = C::inst_data_value_etor_returns::default();
                                                    C::inst_data_value_etor(ctx, v86.1, &mut v96);
                                                    let mut v96 = v96.into_context_iter();
                                                    while let Some(v97) = v96.next(ctx) {
                                                        if let &InstructionData::Unary {
                                                            opcode: ref v100,
                                                            arg: v101,
                                                        } = &v97.1 {
                                                            if let &Opcode::Ineg = v100 {
                                                                if v86.2 == v101 {
                                                                    if v2.0 == v97.0 {
                                                                        let mut v1325 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v1151.1, &mut v1325);
                                                                        let mut v1325 = v1325.into_context_iter();
                                                                        while let Some(v1326) = v1325.next(ctx) {
                                                                            if let &InstructionData::UnaryImm {
                                                                                opcode: ref v1329,
                                                                                imm: v1330,
                                                                            } = &v1326.1 {
                                                                                if let &Opcode::Iconst = v1329 {
                                                                                    let v1331 = C::u64_from_imm64(ctx, v1330);
                                                                                    if v1331 == 0x0_u64 {
                                                                                        if v2.0 == v1326.0 {
                                                                                            let v1332 = constructor_iabs(ctx, v2.0, v1151.0);
                                                                                            let v1333 = C::subsume(ctx, v1332);
                                                                                            // Rule at src/opts/selects.isle line 91.
                                                                                            returns.extend(Some(v1333));
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                if v86.1 == v1151.0 {
                                                    if v86.2 == v1151.1 {
                                                        let v1304 = constructor_smin(ctx, v2.0, v1151.0, v1151.1);
                                                        // Rule at src/opts/selects.isle line 30.
                                                        returns.extend(Some(v1304));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            &IntCC::UnsignedGreaterThan => {
                                                let mut v1164 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v86.2, &mut v1164);
                                                let mut v1164 = v1164.into_context_iter();
                                                while let Some(v1165) = v1164.next(ctx) {
                                                    if let &InstructionData::Unary {
                                                        opcode: ref v1319,
                                                        arg: v1320,
                                                    } = &v1165.1 {
                                                        match v1319 {
                                                            &Opcode::Ineg => {
                                                                if v91.0 == v1165.0 {
                                                                    let mut v1289 = C::inst_data_value_tupled_etor_returns::default();
                                                                    C::inst_data_value_tupled_etor(ctx, v86.1, &mut v1289);
                                                                    let mut v1289 = v1289.into_context_iter();
                                                                    while let Some(v1290) = v1289.next(ctx) {
                                                                        let v1291 = C::iconst_sextend_etor(ctx, v1290);
                                                                        if let Some(v1292) = v1291 {
                                                                            if v1292.1 == 1_i64 {
                                                                                if v2.0 == v1292.0 {
                                                                                    let mut v1501 = C::inst_data_value_etor_returns::default();
                                                                                    C::inst_data_value_etor(ctx, v1320, &mut v1501);
                                                                                    let mut v1501 = v1501.into_context_iter();
                                                                                    while let Some(v1502) = v1501.next(ctx) {
                                                                                        if let &InstructionData::IntCompare {
                                                                                            opcode: ref v1505,
                                                                                            args: ref v1506,
                                                                                            cond: ref v1507,
                                                                                        } = &v1502.1 {
                                                                                            if let &Opcode::Icmp = v1505 {
                                                                                                match v1507 {
                                                                                                    &IntCC::NotEqual => {
                                                                                                        if v91.0 == v1502.0 {
                                                                                                            let v1151 = C::unpack_value_array_2(ctx, v1149);
                                                                                                            let v1508 = C::unpack_value_array_2(ctx, v1506);
                                                                                                            if v1151.0 == v1508.0 {
                                                                                                                if v1151.1 == v1508.1 {
                                                                                                                    let v1477 = constructor_spaceship_u(ctx, v91.0, v1151.0, v1151.1);
                                                                                                                    let v1478 = constructor_sextend_maybe(ctx, v2.0, v1477);
                                                                                                                    // Rule at src/opts/spaceship.isle line 64.
                                                                                                                    returns.extend(Some(v1478));
                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                    &IntCC::UnsignedLessThan => {
                                                                                                        if v91.0 == v1502.0 {
                                                                                                            let v1151 = C::unpack_value_array_2(ctx, v1149);
                                                                                                            let v1508 = C::unpack_value_array_2(ctx, v1506);
                                                                                                            if v1151.0 == v1508.0 {
                                                                                                                if v1151.1 == v1508.1 {
                                                                                                                    let v1477 = constructor_spaceship_u(ctx, v91.0, v1151.0, v1151.1);
                                                                                                                    let v1478 = constructor_sextend_maybe(ctx, v2.0, v1477);
                                                                                                                    // Rule at src/opts/spaceship.isle line 54.
                                                                                                                    returns.extend(Some(v1478));
                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                    _ => {}
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            &Opcode::Bmask => {
                                                                if v2.0 == v1165.0 {
                                                                    let mut v1289 = C::inst_data_value_tupled_etor_returns::default();
                                                                    C::inst_data_value_tupled_etor(ctx, v86.1, &mut v1289);
                                                                    let mut v1289 = v1289.into_context_iter();
                                                                    while let Some(v1290) = v1289.next(ctx) {
                                                                        let v1291 = C::iconst_sextend_etor(ctx, v1290);
                                                                        if let Some(v1292) = v1291 {
                                                                            if v1292.1 == 1_i64 {
                                                                                if v2.0 == v1292.0 {
                                                                                    let mut v1501 = C::inst_data_value_etor_returns::default();
                                                                                    C::inst_data_value_etor(ctx, v1320, &mut v1501);
                                                                                    let mut v1501 = v1501.into_context_iter();
                                                                                    while let Some(v1502) = v1501.next(ctx) {
                                                                                        if let &InstructionData::IntCompare {
                                                                                            opcode: ref v1505,
                                                                                            args: ref v1506,
                                                                                            cond: ref v1507,
                                                                                        } = &v1502.1 {
                                                                                            if let &Opcode::Icmp = v1505 {
                                                                                                match v1507 {
                                                                                                    &IntCC::NotEqual => {
                                                                                                        if v91.0 == v1502.0 {
                                                                                                            let v1151 = C::unpack_value_array_2(ctx, v1149);
                                                                                                            let v1508 = C::unpack_value_array_2(ctx, v1506);
                                                                                                            if v1151.0 == v1508.0 {
                                                                                                                if v1151.1 == v1508.1 {
                                                                                                                    let v1477 = constructor_spaceship_u(ctx, v91.0, v1151.0, v1151.1);
                                                                                                                    let v1478 = constructor_sextend_maybe(ctx, v2.0, v1477);
                                                                                                                    // Rule at src/opts/spaceship.isle line 68.
                                                                                                                    returns.extend(Some(v1478));
                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                    &IntCC::UnsignedLessThan => {
                                                                                                        if v91.0 == v1502.0 {
                                                                                                            let v1151 = C::unpack_value_array_2(ctx, v1149);
                                                                                                            let v1508 = C::unpack_value_array_2(ctx, v1506);
                                                                                                            if v1151.0 == v1508.0 {
                                                                                                                if v1151.1 == v1508.1 {
                                                                                                                    let v1477 = constructor_spaceship_u(ctx, v91.0, v1151.0, v1151.1);
                                                                                                                    let v1478 = constructor_sextend_maybe(ctx, v2.0, v1477);
                                                                                                                    // Rule at src/opts/spaceship.isle line 58.
                                                                                                                    returns.extend(Some(v1478));
                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                    _ => {}
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            _ => {}
                                                        }
                                                    }
                                                }
                                                let v1151 = C::unpack_value_array_2(ctx, v1149);
                                                if v86.1 == v1151.0 {
                                                    if v86.2 == v1151.1 {
                                                        let v1303 = constructor_umax(ctx, v2.0, v1151.0, v1151.1);
                                                        // Rule at src/opts/selects.isle line 27.
                                                        returns.extend(Some(v1303));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v86.2 == v1151.0 {
                                                    if v86.1 == v1151.1 {
                                                        let v1305 = constructor_umin(ctx, v2.0, v1151.0, v1151.1);
                                                        // Rule at src/opts/selects.isle line 41.
                                                        returns.extend(Some(v1305));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            &IntCC::UnsignedGreaterThanOrEqual => {
                                                let v1151 = C::unpack_value_array_2(ctx, v1149);
                                                if v86.1 == v1151.0 {
                                                    if v86.2 == v1151.1 {
                                                        let v1303 = constructor_umax(ctx, v2.0, v1151.0, v1151.1);
                                                        // Rule at src/opts/selects.isle line 28.
                                                        returns.extend(Some(v1303));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v86.1 == v1151.1 {
                                                    if v86.2 == v1151.0 {
                                                        let v1305 = constructor_umin(ctx, v2.0, v1151.0, v1151.1);
                                                        // Rule at src/opts/selects.isle line 42.
                                                        returns.extend(Some(v1305));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            &IntCC::UnsignedLessThan => {
                                                let mut v1289 = C::inst_data_value_tupled_etor_returns::default();
                                                C::inst_data_value_tupled_etor(ctx, v86.1, &mut v1289);
                                                let mut v1289 = v1289.into_context_iter();
                                                while let Some(v1290) = v1289.next(ctx) {
                                                    let v1291 = C::iconst_sextend_etor(ctx, v1290);
                                                    if let Some(v1292) = v1291 {
                                                        if v1292.1 == -1_i64 {
                                                            if v2.0 == v1292.0 {
                                                                let mut v1463 = C::uextend_maybe_etor_returns::default();
                                                                C::uextend_maybe_etor(ctx, v86.2, &mut v1463);
                                                                let mut v1463 = v1463.into_context_iter();
                                                                while let Some(v1464) = v1463.next(ctx) {
                                                                    if v2.0 == v1464.0 {
                                                                        let mut v1467 = C::inst_data_value_etor_returns::default();
                                                                        C::inst_data_value_etor(ctx, v1464.1, &mut v1467);
                                                                        let mut v1467 = v1467.into_context_iter();
                                                                        while let Some(v1468) = v1467.next(ctx) {
                                                                            if let &InstructionData::IntCompare {
                                                                                opcode: ref v1471,
                                                                                args: ref v1472,
                                                                                cond: ref v1473,
                                                                            } = &v1468.1 {
                                                                                if let &Opcode::Icmp = v1471 {
                                                                                    match v1473 {
                                                                                        &IntCC::NotEqual => {
                                                                                            if v91.0 == v1468.0 {
                                                                                                let v1151 = C::unpack_value_array_2(ctx, v1149);
                                                                                                let v1474 = C::unpack_value_array_2(ctx, v1472);
                                                                                                if v1151.0 == v1474.0 {
                                                                                                    if v1151.1 == v1474.1 {
                                                                                                        let v1477 = constructor_spaceship_u(ctx, v91.0, v1151.0, v1151.1);
                                                                                                        let v1478 = constructor_sextend_maybe(ctx, v2.0, v1477);
                                                                                                        // Rule at src/opts/spaceship.isle line 12.
                                                                                                        returns.extend(Some(v1478));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                        &IntCC::UnsignedGreaterThan => {
                                                                                            if v91.0 == v1468.0 {
                                                                                                let v1151 = C::unpack_value_array_2(ctx, v1149);
                                                                                                let v1474 = C::unpack_value_array_2(ctx, v1472);
                                                                                                if v1151.0 == v1474.0 {
                                                                                                    if v1151.1 == v1474.1 {
                                                                                                        let v1477 = constructor_spaceship_u(ctx, v91.0, v1151.0, v1151.1);
                                                                                                        let v1478 = constructor_sextend_maybe(ctx, v2.0, v1477);
                                                                                                        // Rule at src/opts/spaceship.isle line 18.
                                                                                                        returns.extend(Some(v1478));
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                        _ => {}
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                let v1151 = C::unpack_value_array_2(ctx, v1149);
                                                if v86.1 == v1151.0 {
                                                    if v86.2 == v1151.1 {
                                                        let v1305 = constructor_umin(ctx, v2.0, v1151.0, v1151.1);
                                                        // Rule at src/opts/selects.isle line 31.
                                                        returns.extend(Some(v1305));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v86.1 == v1151.1 {
                                                    if v86.2 == v1151.0 {
                                                        let v1303 = constructor_umax(ctx, v2.0, v1151.0, v1151.1);
                                                        // Rule at src/opts/selects.isle line 37.
                                                        returns.extend(Some(v1303));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            &IntCC::UnsignedLessThanOrEqual => {
                                                let v1151 = C::unpack_value_array_2(ctx, v1149);
                                                if v86.1 == v1151.0 {
                                                    if v86.2 == v1151.1 {
                                                        let v1305 = constructor_umin(ctx, v2.0, v1151.0, v1151.1);
                                                        // Rule at src/opts/selects.isle line 32.
                                                        returns.extend(Some(v1305));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v86.1 == v1151.1 {
                                                    if v86.2 == v1151.0 {
                                                        let v1303 = constructor_umax(ctx, v2.0, v1151.0, v1151.1);
                                                        // Rule at src/opts/selects.isle line 38.
                                                        returns.extend(Some(v1303));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            _ => {}
                                        }
                                        let mut v96 = C::inst_data_value_etor_returns::default();
                                        C::inst_data_value_etor(ctx, v86.1, &mut v96);
                                        let mut v96 = v96.into_context_iter();
                                        while let Some(v97) = v96.next(ctx) {
                                            if let &InstructionData::UnaryImm {
                                                opcode: ref v1277,
                                                imm: v1278,
                                            } = &v97.1 {
                                                if let &Opcode::Iconst = v1277 {
                                                    let v1279 = C::u64_from_imm64(ctx, v1278);
                                                    match v1279 {
                                                        0x0_u64 => {
                                                            let mut v1164 = C::inst_data_value_etor_returns::default();
                                                            C::inst_data_value_etor(ctx, v86.2, &mut v1164);
                                                            let mut v1164 = v1164.into_context_iter();
                                                            while let Some(v1165) = v1164.next(ctx) {
                                                                if let &InstructionData::UnaryImm {
                                                                    opcode: ref v1280,
                                                                    imm: v1281,
                                                                } = &v1165.1 {
                                                                    if let &Opcode::Iconst = v1280 {
                                                                        let v1282 = C::u64_from_imm64(ctx, v1281);
                                                                        let v1283 = C::u64_matches_non_zero(ctx, v1282);
                                                                        if let Some(v1284) = v1283 {
                                                                            if v1284 == true {
                                                                                let v1285 = &C::intcc_complement(ctx, v1150);
                                                                                let v1151 = C::unpack_value_array_2(ctx, v1149);
                                                                                let v1286 = constructor_icmp(ctx, v91.0, v1285, v1151.0, v1151.1);
                                                                                let v1287 = constructor_select(ctx, v2.0, v1286, v86.2, v86.1);
                                                                                // Rule at src/opts/selects.isle line 8.
                                                                                returns.extend(Some(v1287));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        0x1_u64 => {
                                                            let mut v1164 = C::inst_data_value_etor_returns::default();
                                                            C::inst_data_value_etor(ctx, v86.2, &mut v1164);
                                                            let mut v1164 = v1164.into_context_iter();
                                                            while let Some(v1165) = v1164.next(ctx) {
                                                                if let &InstructionData::UnaryImm {
                                                                    opcode: ref v1280,
                                                                    imm: v1281,
                                                                } = &v1165.1 {
                                                                    if let &Opcode::Iconst = v1280 {
                                                                        let v1282 = C::u64_from_imm64(ctx, v1281);
                                                                        if v1282 == 0x0_u64 {
                                                                            let v1288 = constructor_uextend_maybe(ctx, v2.0, v86.0);
                                                                            // Rule at src/opts/selects.isle line 14.
                                                                            returns.extend(Some(v1288));
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                            }
                                        }
                                        let mut v1289 = C::inst_data_value_tupled_etor_returns::default();
                                        C::inst_data_value_tupled_etor(ctx, v86.1, &mut v1289);
                                        let mut v1289 = v1289.into_context_iter();
                                        while let Some(v1290) = v1289.next(ctx) {
                                            let v1291 = C::iconst_sextend_etor(ctx, v1290);
                                            if let Some(v1292) = v1291 {
                                                if v1292.1 == -1_i64 {
                                                    let mut v1295 = C::inst_data_value_tupled_etor_returns::default();
                                                    C::inst_data_value_tupled_etor(ctx, v86.2, &mut v1295);
                                                    let mut v1295 = v1295.into_context_iter();
                                                    while let Some(v1296) = v1295.next(ctx) {
                                                        let v1297 = C::iconst_sextend_etor(ctx, v1296);
                                                        if let Some(v1298) = v1297 {
                                                            if v1298.1 == 0_i64 {
                                                                let v1301 = constructor_bmask(ctx, v2.0, v86.0);
                                                                // Rule at src/opts/selects.isle line 19.
                                                                returns.extend(Some(v1301));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v94,
                                    arg: v95,
                                } => {
                                    if let &Opcode::Uextend = v94 {
                                        let mut v1089 = C::inst_data_value_etor_returns::default();
                                        C::inst_data_value_etor(ctx, v95, &mut v1089);
                                        let mut v1089 = v1089.into_context_iter();
                                        while let Some(v1090) = v1089.next(ctx) {
                                            if let &InstructionData::IntCompare {
                                                opcode: ref v1093,
                                                args: ref v1094,
                                                cond: ref v1095,
                                            } = &v1090.1 {
                                                if let &Opcode::Icmp = v1093 {
                                                    let v1099 = constructor_select(ctx, v2.0, v95, v86.1, v86.2);
                                                    // Rule at src/opts/icmp.isle line 83.
                                                    returns.extend(Some(v1099));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    // Rule at src/opts/icmp.isle line 86.
                                                    returns.extend(Some(v1099));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::UnaryImm {
                                    opcode: ref v713,
                                    imm: v714,
                                } => {
                                    if let &Opcode::Iconst = v713 {
                                        let v715 = C::u64_from_imm64(ctx, v714);
                                        if v715 == 0x0_u64 {
                                            let v719 = C::subsume(ctx, v86.2);
                                            // Rule at src/opts/cprop.isle line 192.
                                            returns.extend(Some(v719));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        let v716 = C::u64_matches_non_zero(ctx, v715);
                                        if let Some(v717) = v716 {
                                            if v717 == true {
                                                let v718 = C::subsume(ctx, v86.1);
                                                // Rule at src/opts/cprop.isle line 190.
                                                returns.extend(Some(v718));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                    }
                                }
                                _ => {}
                            }
                        }
                        let mut v96 = C::inst_data_value_etor_returns::default();
                        C::inst_data_value_etor(ctx, v86.1, &mut v96);
                        let mut v96 = v96.into_context_iter();
                        while let Some(v97) = v96.next(ctx) {
                            match &v97.1 {
                                &InstructionData::Ternary {
                                    opcode: ref v1368,
                                    args: ref v1369,
                                } => {
                                    if let &Opcode::Select = v1368 {
                                        if v2.0 == v97.0 {
                                            let v1370 = C::unpack_value_array_3(ctx, v1369);
                                            if v86.0 == v1370.0 {
                                                let v1374 = constructor_select(ctx, v2.0, v86.0, v1370.1, v86.2);
                                                // Rule at src/opts/selects.isle line 102.
                                                returns.extend(Some(v1374));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v100,
                                    arg: v101,
                                } => {
                                    match v100 {
                                        &Opcode::Uextend => {
                                            if v2.0 == v97.0 {
                                                let mut v1164 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v86.2, &mut v1164);
                                                let mut v1164 = v1164.into_context_iter();
                                                while let Some(v1165) = v1164.next(ctx) {
                                                    if let &InstructionData::Unary {
                                                        opcode: ref v1319,
                                                        arg: v1320,
                                                    } = &v1165.1 {
                                                        if let &Opcode::Uextend = v1319 {
                                                            if v2.0 == v1165.0 {
                                                                let v1318 = C::value_type(ctx, v101);
                                                                let v1321 = C::value_type(ctx, v1320);
                                                                if v1318 == v1321 {
                                                                    let v1322 = constructor_select(ctx, v1318, v86.0, v101, v1320);
                                                                    let v1323 = constructor_uextend(ctx, v2.0, v1322);
                                                                    // Rule at src/opts/selects.isle line 80.
                                                                    returns.extend(Some(v1323));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        &Opcode::Sextend => {
                                            if v2.0 == v97.0 {
                                                let mut v1164 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v86.2, &mut v1164);
                                                let mut v1164 = v1164.into_context_iter();
                                                while let Some(v1165) = v1164.next(ctx) {
                                                    if let &InstructionData::Unary {
                                                        opcode: ref v1319,
                                                        arg: v1320,
                                                    } = &v1165.1 {
                                                        if let &Opcode::Sextend = v1319 {
                                                            if v2.0 == v1165.0 {
                                                                let v1318 = C::value_type(ctx, v101);
                                                                let v1321 = C::value_type(ctx, v1320);
                                                                if v1318 == v1321 {
                                                                    let v1322 = constructor_select(ctx, v1318, v86.0, v101, v1320);
                                                                    let v1324 = constructor_sextend(ctx, v2.0, v1322);
                                                                    // Rule at src/opts/selects.isle line 84.
                                                                    returns.extend(Some(v1324));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        _ => {}
                                    }
                                }
                                _ => {}
                            }
                        }
                        if v86.1 == v86.2 {
                            let v718 = C::subsume(ctx, v86.1);
                            // Rule at src/opts/selects.isle line 3.
                            returns.extend(Some(v718));
                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                        }
                        let mut v282 = ContextIterWrapper::<ConstructorVec<_>, _>::default();
                        constructor_truthy(ctx, v86.0, &mut v282);
                        let mut v282 = v282.into_context_iter();
                        while let Some(v283) = v282.next(ctx) {
                            let v284 = constructor_select(ctx, v2.0, v283, v86.1, v86.2);
                            // Rule at src/opts/bitops.isle line 112.
                            returns.extend(Some(v284));
                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                        }
                        let mut v1164 = C::inst_data_value_etor_returns::default();
                        C::inst_data_value_etor(ctx, v86.2, &mut v1164);
                        let mut v1164 = v1164.into_context_iter();
                        while let Some(v1165) = v1164.next(ctx) {
                            if let &InstructionData::Ternary {
                                opcode: ref v1361,
                                args: ref v1362,
                            } = &v1165.1 {
                                if let &Opcode::Select = v1361 {
                                    if v2.0 == v1165.0 {
                                        let v1363 = C::unpack_value_array_3(ctx, v1362);
                                        if v86.0 == v1363.0 {
                                            let v1367 = constructor_select(ctx, v2.0, v86.0, v86.1, v1363.2);
                                            // Rule at src/opts/selects.isle line 101.
                                            returns.extend(Some(v1367));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                    }
                                }
                            }
                        }
                    }
                    &Opcode::SelectSpectreGuard => {
                        let v86 = C::unpack_value_array_3(ctx, v85);
                        let mut v90 = C::inst_data_value_etor_returns::default();
                        C::inst_data_value_etor(ctx, v86.0, &mut v90);
                        let mut v90 = v90.into_context_iter();
                        while let Some(v91) = v90.next(ctx) {
                            if let &InstructionData::UnaryImm {
                                opcode: ref v713,
                                imm: v714,
                            } = &v91.1 {
                                if let &Opcode::Iconst = v713 {
                                    let v715 = C::u64_from_imm64(ctx, v714);
                                    if v715 == 0x0_u64 {
                                        let v719 = C::subsume(ctx, v86.2);
                                        // Rule at src/opts/spectre.isle line 13.
                                        returns.extend(Some(v719));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                    let v716 = C::u64_matches_non_zero(ctx, v715);
                                    if let Some(v717) = v716 {
                                        if v717 == true {
                                            let v718 = C::subsume(ctx, v86.1);
                                            // Rule at src/opts/spectre.isle line 11.
                                            returns.extend(Some(v718));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                    }
                                }
                            }
                        }
                        if v86.1 == v86.2 {
                            let v718 = C::subsume(ctx, v86.1);
                            // Rule at src/opts/spectre.isle line 9.
                            returns.extend(Some(v718));
                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                        }
                    }
                    &Opcode::Bitselect => {
                        let v1306 = C::multi_lane(ctx, v2.0);
                        if let Some(v1307) = v1306 {
                            let v86 = C::unpack_value_array_3(ctx, v85);
                            let mut v90 = C::inst_data_value_etor_returns::default();
                            C::inst_data_value_etor(ctx, v86.0, &mut v90);
                            let mut v90 = v90.into_context_iter();
                            while let Some(v91) = v90.next(ctx) {
                                if let &InstructionData::IntCompare {
                                    opcode: ref v1148,
                                    args: ref v1149,
                                    cond: ref v1150,
                                } = &v91.1 {
                                    if let &Opcode::Icmp = v1148 {
                                        match v1150 {
                                            &IntCC::SignedGreaterThan => {
                                                let v1151 = C::unpack_value_array_2(ctx, v1149);
                                                if v86.1 == v1151.0 {
                                                    if v86.2 == v1151.1 {
                                                        let v1302 = constructor_smax(ctx, v2.0, v1151.0, v1151.1);
                                                        // Rule at src/opts/selects.isle line 45.
                                                        returns.extend(Some(v1302));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v86.1 == v1151.1 {
                                                    if v86.2 == v1151.0 {
                                                        let v1304 = constructor_smin(ctx, v2.0, v1151.0, v1151.1);
                                                        // Rule at src/opts/selects.isle line 59.
                                                        returns.extend(Some(v1304));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            &IntCC::SignedGreaterThanOrEqual => {
                                                let v1151 = C::unpack_value_array_2(ctx, v1149);
                                                if v86.1 == v1151.0 {
                                                    if v86.2 == v1151.1 {
                                                        let v1302 = constructor_smax(ctx, v2.0, v1151.0, v1151.1);
                                                        // Rule at src/opts/selects.isle line 46.
                                                        returns.extend(Some(v1302));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v86.1 == v1151.1 {
                                                    if v86.2 == v1151.0 {
                                                        let v1304 = constructor_smin(ctx, v2.0, v1151.0, v1151.1);
                                                        // Rule at src/opts/selects.isle line 60.
                                                        returns.extend(Some(v1304));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            &IntCC::SignedLessThan => {
                                                let v1151 = C::unpack_value_array_2(ctx, v1149);
                                                if v86.1 == v1151.0 {
                                                    if v86.2 == v1151.1 {
                                                        let v1304 = constructor_smin(ctx, v2.0, v1151.0, v1151.1);
                                                        // Rule at src/opts/selects.isle line 49.
                                                        returns.extend(Some(v1304));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v86.1 == v1151.1 {
                                                    if v86.2 == v1151.0 {
                                                        let v1302 = constructor_smax(ctx, v2.0, v1151.0, v1151.1);
                                                        // Rule at src/opts/selects.isle line 55.
                                                        returns.extend(Some(v1302));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            &IntCC::SignedLessThanOrEqual => {
                                                let v1151 = C::unpack_value_array_2(ctx, v1149);
                                                if v86.1 == v1151.0 {
                                                    if v86.2 == v1151.1 {
                                                        let v1304 = constructor_smin(ctx, v2.0, v1151.0, v1151.1);
                                                        // Rule at src/opts/selects.isle line 50.
                                                        returns.extend(Some(v1304));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v86.1 == v1151.1 {
                                                    if v86.2 == v1151.0 {
                                                        let v1302 = constructor_smax(ctx, v2.0, v1151.0, v1151.1);
                                                        // Rule at src/opts/selects.isle line 56.
                                                        returns.extend(Some(v1302));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            &IntCC::UnsignedGreaterThan => {
                                                let v1151 = C::unpack_value_array_2(ctx, v1149);
                                                if v86.1 == v1151.0 {
                                                    if v86.2 == v1151.1 {
                                                        let v1303 = constructor_umax(ctx, v2.0, v1151.0, v1151.1);
                                                        // Rule at src/opts/selects.isle line 47.
                                                        returns.extend(Some(v1303));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v86.1 == v1151.1 {
                                                    if v86.2 == v1151.0 {
                                                        let v1305 = constructor_umin(ctx, v2.0, v1151.0, v1151.1);
                                                        // Rule at src/opts/selects.isle line 61.
                                                        returns.extend(Some(v1305));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            &IntCC::UnsignedGreaterThanOrEqual => {
                                                let v1151 = C::unpack_value_array_2(ctx, v1149);
                                                if v86.1 == v1151.0 {
                                                    if v86.2 == v1151.1 {
                                                        let v1303 = constructor_umax(ctx, v2.0, v1151.0, v1151.1);
                                                        // Rule at src/opts/selects.isle line 48.
                                                        returns.extend(Some(v1303));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v86.1 == v1151.1 {
                                                    if v86.2 == v1151.0 {
                                                        let v1305 = constructor_umin(ctx, v2.0, v1151.0, v1151.1);
                                                        // Rule at src/opts/selects.isle line 62.
                                                        returns.extend(Some(v1305));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            &IntCC::UnsignedLessThan => {
                                                let v1151 = C::unpack_value_array_2(ctx, v1149);
                                                if v86.1 == v1151.0 {
                                                    if v86.2 == v1151.1 {
                                                        let v1305 = constructor_umin(ctx, v2.0, v1151.0, v1151.1);
                                                        // Rule at src/opts/selects.isle line 51.
                                                        returns.extend(Some(v1305));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v86.1 == v1151.1 {
                                                    if v86.2 == v1151.0 {
                                                        let v1303 = constructor_umax(ctx, v2.0, v1151.0, v1151.1);
                                                        // Rule at src/opts/selects.isle line 57.
                                                        returns.extend(Some(v1303));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            &IntCC::UnsignedLessThanOrEqual => {
                                                let v1151 = C::unpack_value_array_2(ctx, v1149);
                                                if v86.1 == v1151.0 {
                                                    if v86.2 == v1151.1 {
                                                        let v1305 = constructor_umin(ctx, v2.0, v1151.0, v1151.1);
                                                        // Rule at src/opts/selects.isle line 52.
                                                        returns.extend(Some(v1305));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                                if v86.1 == v1151.1 {
                                                    if v86.2 == v1151.0 {
                                                        let v1303 = constructor_umax(ctx, v2.0, v1151.0, v1151.1);
                                                        // Rule at src/opts/selects.isle line 58.
                                                        returns.extend(Some(v1303));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                            _ => {}
                                        }
                                    }
                                }
                            }
                        }
                        let v86 = C::unpack_value_array_3(ctx, v85);
                        if v86.1 == v86.2 {
                            let v718 = C::subsume(ctx, v86.1);
                            // Rule at src/opts/selects.isle line 4.
                            returns.extend(Some(v718));
                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                        }
                    }
                    &Opcode::Fma => {
                        let v86 = C::unpack_value_array_3(ctx, v85);
                        let mut v90 = C::inst_data_value_etor_returns::default();
                        C::inst_data_value_etor(ctx, v86.0, &mut v90);
                        let mut v90 = v90.into_context_iter();
                        while let Some(v91) = v90.next(ctx) {
                            if let &InstructionData::Unary {
                                opcode: ref v94,
                                arg: v95,
                            } = &v91.1 {
                                if let &Opcode::Fneg = v94 {
                                    if v2.0 == v91.0 {
                                        let mut v96 = C::inst_data_value_etor_returns::default();
                                        C::inst_data_value_etor(ctx, v86.1, &mut v96);
                                        let mut v96 = v96.into_context_iter();
                                        while let Some(v97) = v96.next(ctx) {
                                            if let &InstructionData::Unary {
                                                opcode: ref v100,
                                                arg: v101,
                                            } = &v97.1 {
                                                if let &Opcode::Fneg = v100 {
                                                    if v2.0 == v97.0 {
                                                        let v102 = constructor_fma(ctx, v2.0, v95, v101, v86.2);
                                                        // Rule at src/opts/arithmetic.isle line 190.
                                                        returns.extend(Some(v102));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                    _ => {}
                }
            }
            &InstructionData::Unary {
                opcode: ref v32,
                arg: v33,
            } => {
                match v32 {
                    &Opcode::Splat => {
                        let v737 = C::ty_vec128(ctx, v2.0);
                        if let Some(v738) = v737 {
                            let mut v34 = C::inst_data_value_etor_returns::default();
                            C::inst_data_value_etor(ctx, v33, &mut v34);
                            let mut v34 = v34.into_context_iter();
                            while let Some(v35) = v34.next(ctx) {
                                match &v35.1 {
                                    &InstructionData::UnaryIeee32 {
                                        opcode: ref v754,
                                        imm: v755,
                                    } => {
                                        if let &Opcode::F32const = v754 {
                                            let v756 = C::u32_from_ieee32(ctx, v755);
                                            let v757 = C::u32_into_u64(ctx, v756);
                                            let v758 = constructor_splat32(ctx, v757);
                                            let v759 = constructor_vconst(ctx, v738, v758);
                                            // Rule at src/opts/cprop.isle line 234.
                                            returns.extend(Some(v759));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                    }
                                    &InstructionData::UnaryIeee64 {
                                        opcode: ref v760,
                                        imm: v761,
                                    } => {
                                        if let &Opcode::F64const = v760 {
                                            let v762 = C::u64_from_ieee64(ctx, v761);
                                            let v763 = C::splat64(ctx, v762);
                                            let v764 = constructor_vconst(ctx, v738, v763);
                                            // Rule at src/opts/cprop.isle line 236.
                                            returns.extend(Some(v764));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                    }
                                    &InstructionData::UnaryImm {
                                        opcode: ref v610,
                                        imm: v611,
                                    } => {
                                        if let &Opcode::Iconst = v610 {
                                            match v35.0 {
                                                I8 => {
                                                    let v739 = C::u64_uextend_imm64(ctx, I8, v611);
                                                    let v740 = constructor_splat8(ctx, v739);
                                                    let v741 = constructor_vconst(ctx, v738, v740);
                                                    // Rule at src/opts/cprop.isle line 226.
                                                    returns.extend(Some(v741));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                I16 => {
                                                    let v743 = C::u64_uextend_imm64(ctx, I16, v611);
                                                    let v744 = constructor_splat16(ctx, v743);
                                                    let v745 = constructor_vconst(ctx, v738, v744);
                                                    // Rule at src/opts/cprop.isle line 228.
                                                    returns.extend(Some(v745));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                I32 => {
                                                    let v747 = C::u64_uextend_imm64(ctx, I32, v611);
                                                    let v748 = constructor_splat32(ctx, v747);
                                                    let v749 = constructor_vconst(ctx, v738, v748);
                                                    // Rule at src/opts/cprop.isle line 230.
                                                    returns.extend(Some(v749));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                I64 => {
                                                    let v751 = C::u64_uextend_imm64(ctx, I64, v611);
                                                    let v752 = C::splat64(ctx, v751);
                                                    let v753 = constructor_vconst(ctx, v738, v752);
                                                    // Rule at src/opts/cprop.isle line 232.
                                                    returns.extend(Some(v753));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                _ => {}
                                            }
                                        }
                                    }
                                    _ => {}
                                }
                            }
                        }
                    }
                    &Opcode::Ineg => {
                        let mut v34 = C::inst_data_value_etor_returns::default();
                        C::inst_data_value_etor(ctx, v33, &mut v34);
                        let mut v34 = v34.into_context_iter();
                        while let Some(v35) = v34.next(ctx) {
                            match &v35.1 {
                                &InstructionData::Binary {
                                    opcode: ref v38,
                                    args: ref v39,
                                } => {
                                    match v38 {
                                        &Opcode::Isub => {
                                            if v2.0 == v35.0 {
                                                let v40 = C::unpack_value_array_2(ctx, v39);
                                                let v43 = constructor_isub(ctx, v2.0, v40.1, v40.0);
                                                // Rule at src/opts/arithmetic.isle line 27.
                                                returns.extend(Some(v43));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                        &Opcode::Ushr => {
                                            if v2.0 == v35.0 {
                                                let v40 = C::unpack_value_array_2(ctx, v39);
                                                let mut v1401 = C::inst_data_value_etor_returns::default();
                                                C::inst_data_value_etor(ctx, v40.1, &mut v1401);
                                                let mut v1401 = v1401.into_context_iter();
                                                while let Some(v1402) = v1401.next(ctx) {
                                                    if let &InstructionData::UnaryImm {
                                                        opcode: ref v1405,
                                                        imm: v1406,
                                                    } = &v1402.1 {
                                                        if let &Opcode::Iconst = v1405 {
                                                            let v1407 = C::u64_from_imm64(ctx, v1406);
                                                            let v267 = constructor_ty_shift_mask(ctx, v2.0);
                                                            let v1408 = C::u64_eq(ctx, v1407, v267);
                                                            if v1408 == true {
                                                                if v2.0 == v1402.0 {
                                                                    let v1409 = constructor_sshr(ctx, v2.0, v40.0, v40.1);
                                                                    // Rule at src/opts/shifts.isle line 98.
                                                                    returns.extend(Some(v1409));
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        _ => {}
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v45,
                                    arg: v46,
                                } => {
                                    match v45 {
                                        &Opcode::Splat => {
                                            if v2.0 == v35.0 {
                                                let v1425 = C::lane_type(ctx, v2.0);
                                                let v1559 = constructor_ineg(ctx, v1425, v46);
                                                let v1560 = constructor_splat(ctx, v2.0, v1559);
                                                // Rule at src/opts/vector.isle line 45.
                                                returns.extend(Some(v1560));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                        &Opcode::Ineg => {
                                            if v2.0 == v35.0 {
                                                let v47 = C::subsume(ctx, v46);
                                                // Rule at src/opts/arithmetic.isle line 34.
                                                returns.extend(Some(v47));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                        _ => {}
                                    }
                                }
                                _ => {}
                            }
                        }
                    }
                    &Opcode::Iabs => {
                        let mut v34 = C::inst_data_value_etor_returns::default();
                        C::inst_data_value_etor(ctx, v33, &mut v34);
                        let mut v34 = v34.into_context_iter();
                        while let Some(v35) = v34.next(ctx) {
                            if let &InstructionData::Unary {
                                opcode: ref v45,
                                arg: v46,
                            } = &v35.1 {
                                match v45 {
                                    &Opcode::Splat => {
                                        if v2.0 == v35.0 {
                                            let v1425 = C::lane_type(ctx, v2.0);
                                            let v1561 = constructor_iabs(ctx, v1425, v46);
                                            let v1562 = constructor_splat(ctx, v2.0, v1561);
                                            // Rule at src/opts/vector.isle line 48.
                                            returns.extend(Some(v1562));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                    }
                                    &Opcode::Ineg => {
                                        if v2.0 == v35.0 {
                                            let v50 = constructor_iabs(ctx, v2.0, v46);
                                            // Rule at src/opts/arithmetic.isle line 41.
                                            returns.extend(Some(v50));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                    }
                                    &Opcode::Iabs => {
                                        if v2.0 == v35.0 {
                                            let v51 = C::subsume(ctx, v33);
                                            // Rule at src/opts/arithmetic.isle line 45.
                                            returns.extend(Some(v51));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                    }
                                    _ => {}
                                }
                            }
                        }
                    }
                    &Opcode::Bnot => {
                        let mut v34 = C::inst_data_value_etor_returns::default();
                        C::inst_data_value_etor(ctx, v33, &mut v34);
                        let mut v34 = v34.into_context_iter();
                        while let Some(v35) = v34.next(ctx) {
                            match &v35.1 {
                                &InstructionData::Binary {
                                    opcode: ref v38,
                                    args: ref v39,
                                } => {
                                    match v38 {
                                        &Opcode::Iadd => {
                                            if v2.0 == v35.0 {
                                                let v40 = C::unpack_value_array_2(ctx, v39);
                                                let mut v66 = C::inst_data_value_tupled_etor_returns::default();
                                                C::inst_data_value_tupled_etor(ctx, v40.1, &mut v66);
                                                let mut v66 = v66.into_context_iter();
                                                while let Some(v67) = v66.next(ctx) {
                                                    let v68 = C::iconst_sextend_etor(ctx, v67);
                                                    if let Some(v69) = v68 {
                                                        if v69.1 == -1_i64 {
                                                            if v2.0 == v69.0 {
                                                                let v72 = constructor_ineg(ctx, v2.0, v40.0);
                                                                // Rule at src/opts/arithmetic.isle line 74.
                                                                returns.extend(Some(v72));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        &Opcode::Isub => {
                                            if v2.0 == v35.0 {
                                                let v40 = C::unpack_value_array_2(ctx, v39);
                                                let mut v66 = C::inst_data_value_tupled_etor_returns::default();
                                                C::inst_data_value_tupled_etor(ctx, v40.1, &mut v66);
                                                let mut v66 = v66.into_context_iter();
                                                while let Some(v67) = v66.next(ctx) {
                                                    let v68 = C::iconst_sextend_etor(ctx, v67);
                                                    if let Some(v69) = v68 {
                                                        if v69.1 == 1_i64 {
                                                            if v2.0 == v69.0 {
                                                                let v72 = constructor_ineg(ctx, v2.0, v40.0);
                                                                // Rule at src/opts/arithmetic.isle line 72.
                                                                returns.extend(Some(v72));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        _ => {}
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v45,
                                    arg: v46,
                                } => {
                                    match v45 {
                                        &Opcode::Splat => {
                                            let v1539 = C::ty_vector_not_float(ctx, v2.0);
                                            if let Some(v1540) = v1539 {
                                                if v2.0 == v35.0 {
                                                    let v1425 = C::lane_type(ctx, v2.0);
                                                    let v1547 = constructor_bnot(ctx, v1425, v46);
                                                    let v1548 = constructor_splat(ctx, v2.0, v1547);
                                                    // Rule at src/opts/vector.isle line 26.
                                                    returns.extend(Some(v1548));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                        &Opcode::Bnot => {
                                            if v2.0 == v35.0 {
                                                let v47 = C::subsume(ctx, v46);
                                                // Rule at src/opts/bitops.isle line 41.
                                                returns.extend(Some(v47));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                        _ => {}
                                    }
                                }
                                &InstructionData::UnaryImm {
                                    opcode: ref v610,
                                    imm: v611,
                                } => {
                                    if let &Opcode::Iconst = v610 {
                                        let v608 = C::fits_in_64(ctx, v2.0);
                                        if let Some(v609) = v608 {
                                            if v35.0 == v609 {
                                                let v642 = C::u64_from_imm64(ctx, v611);
                                                let v643 = C::u64_not(ctx, v642);
                                                let v644 = C::imm64_masked(ctx, v609, v643);
                                                let v645 = constructor_iconst(ctx, v609, v644);
                                                let v646 = C::subsume(ctx, v645);
                                                // Rule at src/opts/cprop.isle line 73.
                                                returns.extend(Some(v646));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                    }
                                }
                                _ => {}
                            }
                        }
                        let v1270 = C::remat(ctx, arg0);
                        // Rule at src/opts/remat.isle line 23.
                        returns.extend(Some(v1270));
                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                    }
                    &Opcode::Bitrev => {
                        let mut v34 = C::inst_data_value_etor_returns::default();
                        C::inst_data_value_etor(ctx, v33, &mut v34);
                        let mut v34 = v34.into_context_iter();
                        while let Some(v35) = v34.next(ctx) {
                            if let &InstructionData::Unary {
                                opcode: ref v45,
                                arg: v46,
                            } = &v35.1 {
                                if let &Opcode::Bitrev = v45 {
                                    if v2.0 == v35.0 {
                                        let v47 = C::subsume(ctx, v46);
                                        // Rule at src/opts/bitops.isle line 131.
                                        returns.extend(Some(v47));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                            }
                        }
                    }
                    &Opcode::Clz => {
                        let v608 = C::fits_in_64(ctx, v2.0);
                        if let Some(v609) = v608 {
                            let mut v34 = C::inst_data_value_etor_returns::default();
                            C::inst_data_value_etor(ctx, v33, &mut v34);
                            let mut v34 = v34.into_context_iter();
                            while let Some(v35) = v34.next(ctx) {
                                if let &InstructionData::UnaryImm {
                                    opcode: ref v610,
                                    imm: v611,
                                } = &v35.1 {
                                    if let &Opcode::Iconst = v610 {
                                        if v35.0 == v609 {
                                            let v612 = C::imm64_clz(ctx, v609, v611);
                                            let v613 = constructor_iconst(ctx, v609, v612);
                                            let v614 = C::subsume(ctx, v613);
                                            // Rule at src/opts/cprop.isle line 2.
                                            returns.extend(Some(v614));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                    }
                                }
                            }
                        }
                    }
                    &Opcode::Ctz => {
                        let v608 = C::fits_in_64(ctx, v2.0);
                        if let Some(v609) = v608 {
                            let mut v34 = C::inst_data_value_etor_returns::default();
                            C::inst_data_value_etor(ctx, v33, &mut v34);
                            let mut v34 = v34.into_context_iter();
                            while let Some(v35) = v34.next(ctx) {
                                if let &InstructionData::UnaryImm {
                                    opcode: ref v610,
                                    imm: v611,
                                } = &v35.1 {
                                    if let &Opcode::Iconst = v610 {
                                        if v35.0 == v609 {
                                            let v615 = C::imm64_ctz(ctx, v609, v611);
                                            let v616 = constructor_iconst(ctx, v609, v615);
                                            let v617 = C::subsume(ctx, v616);
                                            // Rule at src/opts/cprop.isle line 8.
                                            returns.extend(Some(v617));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                    }
                                }
                            }
                        }
                    }
                    &Opcode::Bswap => {
                        let mut v34 = C::inst_data_value_etor_returns::default();
                        C::inst_data_value_etor(ctx, v33, &mut v34);
                        let mut v34 = v34.into_context_iter();
                        while let Some(v35) = v34.next(ctx) {
                            match &v35.1 {
                                &InstructionData::Unary {
                                    opcode: ref v45,
                                    arg: v46,
                                } => {
                                    if let &Opcode::Bswap = v45 {
                                        if v2.0 == v35.0 {
                                            let v47 = C::subsume(ctx, v46);
                                            // Rule at src/opts/bitops.isle line 128.
                                            returns.extend(Some(v47));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                    }
                                }
                                &InstructionData::UnaryImm {
                                    opcode: ref v610,
                                    imm: v611,
                                } => {
                                    if let &Opcode::Iconst = v610 {
                                        match v2.0 {
                                            I16 => {
                                                let v642 = C::u64_from_imm64(ctx, v611);
                                                let v798 = C::u64_bswap16(ctx, v642);
                                                let v799 = C::imm64(ctx, v798);
                                                let v800 = constructor_iconst(ctx, I16, v799);
                                                let v801 = C::subsume(ctx, v800);
                                                // Rule at src/opts/cprop.isle line 306.
                                                returns.extend(Some(v801));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                            I32 => {
                                                let v642 = C::u64_from_imm64(ctx, v611);
                                                let v802 = C::u64_bswap32(ctx, v642);
                                                let v803 = C::imm64(ctx, v802);
                                                let v804 = constructor_iconst(ctx, I32, v803);
                                                let v805 = C::subsume(ctx, v804);
                                                // Rule at src/opts/cprop.isle line 308.
                                                returns.extend(Some(v805));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                            I64 => {
                                                let v642 = C::u64_from_imm64(ctx, v611);
                                                let v806 = C::u64_bswap64(ctx, v642);
                                                let v807 = C::imm64(ctx, v806);
                                                let v808 = constructor_iconst(ctx, I64, v807);
                                                let v809 = C::subsume(ctx, v808);
                                                // Rule at src/opts/cprop.isle line 310.
                                                returns.extend(Some(v809));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                            _ => {}
                                        }
                                    }
                                }
                                _ => {}
                            }
                        }
                    }
                    &Opcode::Popcnt => {
                        let mut v34 = C::inst_data_value_etor_returns::default();
                        C::inst_data_value_etor(ctx, v33, &mut v34);
                        let mut v34 = v34.into_context_iter();
                        while let Some(v35) = v34.next(ctx) {
                            if let &InstructionData::Unary {
                                opcode: ref v45,
                                arg: v46,
                            } = &v35.1 {
                                if let &Opcode::Splat = v45 {
                                    if v2.0 == v35.0 {
                                        let v1425 = C::lane_type(ctx, v2.0);
                                        let v1563 = constructor_popcnt(ctx, v1425, v46);
                                        let v1564 = constructor_splat(ctx, v2.0, v1563);
                                        // Rule at src/opts/vector.isle line 51.
                                        returns.extend(Some(v1564));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                            }
                        }
                    }
                    &Opcode::Sqrt => {
                        match v2.0 {
                            F32 => {
                                let mut v34 = C::inst_data_value_etor_returns::default();
                                C::inst_data_value_etor(ctx, v33, &mut v34);
                                let mut v34 = v34.into_context_iter();
                                while let Some(v35) = v34.next(ctx) {
                                    if v35.0 == F32 {
                                        if let &InstructionData::UnaryIeee32 {
                                            opcode: ref v754,
                                            imm: v755,
                                        } = &v35.1 {
                                            if let &Opcode::F32const = v754 {
                                                let v850 = C::f32_sqrt(ctx, v755);
                                                if let Some(v851) = v850 {
                                                    let v852 = constructor_f32const(ctx, F32, v851);
                                                    let v853 = C::subsume(ctx, v852);
                                                    // Rule at src/opts/cprop.isle line 357.
                                                    returns.extend(Some(v853));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            F64 => {
                                let mut v34 = C::inst_data_value_etor_returns::default();
                                C::inst_data_value_etor(ctx, v33, &mut v34);
                                let mut v34 = v34.into_context_iter();
                                while let Some(v35) = v34.next(ctx) {
                                    if v35.0 == F64 {
                                        if let &InstructionData::UnaryIeee64 {
                                            opcode: ref v760,
                                            imm: v761,
                                        } = &v35.1 {
                                            if let &Opcode::F64const = v760 {
                                                let v854 = C::f64_sqrt(ctx, v761);
                                                if let Some(v855) = v854 {
                                                    let v856 = constructor_f64const(ctx, F64, v855);
                                                    let v857 = C::subsume(ctx, v856);
                                                    // Rule at src/opts/cprop.isle line 360.
                                                    returns.extend(Some(v857));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            _ => {}
                        }
                    }
                    &Opcode::Fneg => {
                        let mut v34 = C::inst_data_value_etor_returns::default();
                        C::inst_data_value_etor(ctx, v33, &mut v34);
                        let mut v34 = v34.into_context_iter();
                        while let Some(v35) = v34.next(ctx) {
                            match &v35.1 {
                                &InstructionData::Unary {
                                    opcode: ref v45,
                                    arg: v46,
                                } => {
                                    if let &Opcode::Fneg = v45 {
                                        if v2.0 == v35.0 {
                                            let v47 = C::subsume(ctx, v46);
                                            // Rule at src/opts/arithmetic.isle line 186.
                                            returns.extend(Some(v47));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                    }
                                }
                                &InstructionData::UnaryConst {
                                    opcode: ref v949,
                                    constant_handle: v950,
                                } => {
                                    if let &Opcode::F128const = v949 {
                                        if v2.0 == F128 {
                                            if v35.0 == F128 {
                                                let v951 = C::ieee128_constant_extractor(ctx, v950);
                                                if let Some(v952) = v951 {
                                                    let v953 = C::f128_neg(ctx, v952);
                                                    let v954 = C::ieee128_constant(ctx, v953);
                                                    let v955 = constructor_f128const(ctx, F128, v954);
                                                    let v956 = C::subsume(ctx, v955);
                                                    // Rule at src/opts/cprop.isle line 424.
                                                    returns.extend(Some(v956));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::UnaryIeee16 {
                                    opcode: ref v938,
                                    imm: v939,
                                } => {
                                    if let &Opcode::F16const = v938 {
                                        if v2.0 == F16 {
                                            if v35.0 == F16 {
                                                let v940 = C::f16_neg(ctx, v939);
                                                let v941 = constructor_f16const(ctx, F16, v940);
                                                let v942 = C::subsume(ctx, v941);
                                                // Rule at src/opts/cprop.isle line 418.
                                                returns.extend(Some(v942));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::UnaryIeee32 {
                                    opcode: ref v754,
                                    imm: v755,
                                } => {
                                    if let &Opcode::F32const = v754 {
                                        if v2.0 == F32 {
                                            if v35.0 == F32 {
                                                let v943 = C::f32_neg(ctx, v755);
                                                let v944 = constructor_f32const(ctx, F32, v943);
                                                let v945 = C::subsume(ctx, v944);
                                                // Rule at src/opts/cprop.isle line 420.
                                                returns.extend(Some(v945));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::UnaryIeee64 {
                                    opcode: ref v760,
                                    imm: v761,
                                } => {
                                    if let &Opcode::F64const = v760 {
                                        if v2.0 == F64 {
                                            if v35.0 == F64 {
                                                let v946 = C::f64_neg(ctx, v761);
                                                let v947 = constructor_f64const(ctx, F64, v946);
                                                let v948 = C::subsume(ctx, v947);
                                                // Rule at src/opts/cprop.isle line 422.
                                                returns.extend(Some(v948));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                    }
                                }
                                _ => {}
                            }
                        }
                    }
                    &Opcode::Fabs => {
                        match v2.0 {
                            F16 => {
                                let mut v34 = C::inst_data_value_etor_returns::default();
                                C::inst_data_value_etor(ctx, v33, &mut v34);
                                let mut v34 = v34.into_context_iter();
                                while let Some(v35) = v34.next(ctx) {
                                    if v35.0 == F16 {
                                        if let &InstructionData::UnaryIeee16 {
                                            opcode: ref v938,
                                            imm: v939,
                                        } = &v35.1 {
                                            if let &Opcode::F16const = v938 {
                                                let v957 = C::f16_abs(ctx, v939);
                                                let v958 = constructor_f16const(ctx, F16, v957);
                                                let v959 = C::subsume(ctx, v958);
                                                // Rule at src/opts/cprop.isle line 427.
                                                returns.extend(Some(v959));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                    }
                                }
                            }
                            F32 => {
                                let mut v34 = C::inst_data_value_etor_returns::default();
                                C::inst_data_value_etor(ctx, v33, &mut v34);
                                let mut v34 = v34.into_context_iter();
                                while let Some(v35) = v34.next(ctx) {
                                    if v35.0 == F32 {
                                        if let &InstructionData::UnaryIeee32 {
                                            opcode: ref v754,
                                            imm: v755,
                                        } = &v35.1 {
                                            if let &Opcode::F32const = v754 {
                                                let v960 = C::f32_abs(ctx, v755);
                                                let v961 = constructor_f32const(ctx, F32, v960);
                                                let v962 = C::subsume(ctx, v961);
                                                // Rule at src/opts/cprop.isle line 429.
                                                returns.extend(Some(v962));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                    }
                                }
                            }
                            F64 => {
                                let mut v34 = C::inst_data_value_etor_returns::default();
                                C::inst_data_value_etor(ctx, v33, &mut v34);
                                let mut v34 = v34.into_context_iter();
                                while let Some(v35) = v34.next(ctx) {
                                    if v35.0 == F64 {
                                        if let &InstructionData::UnaryIeee64 {
                                            opcode: ref v760,
                                            imm: v761,
                                        } = &v35.1 {
                                            if let &Opcode::F64const = v760 {
                                                let v963 = C::f64_abs(ctx, v761);
                                                let v964 = constructor_f64const(ctx, F64, v963);
                                                let v965 = C::subsume(ctx, v964);
                                                // Rule at src/opts/cprop.isle line 431.
                                                returns.extend(Some(v965));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                    }
                                }
                            }
                            F128 => {
                                let mut v34 = C::inst_data_value_etor_returns::default();
                                C::inst_data_value_etor(ctx, v33, &mut v34);
                                let mut v34 = v34.into_context_iter();
                                while let Some(v35) = v34.next(ctx) {
                                    if v35.0 == F128 {
                                        if let &InstructionData::UnaryConst {
                                            opcode: ref v949,
                                            constant_handle: v950,
                                        } = &v35.1 {
                                            if let &Opcode::F128const = v949 {
                                                let v951 = C::ieee128_constant_extractor(ctx, v950);
                                                if let Some(v952) = v951 {
                                                    let v966 = C::f128_abs(ctx, v952);
                                                    let v967 = C::ieee128_constant(ctx, v966);
                                                    let v968 = constructor_f128const(ctx, F128, v967);
                                                    let v969 = C::subsume(ctx, v968);
                                                    // Rule at src/opts/cprop.isle line 433.
                                                    returns.extend(Some(v969));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            _ => {}
                        }
                    }
                    &Opcode::Ceil => {
                        match v2.0 {
                            F32 => {
                                let mut v34 = C::inst_data_value_etor_returns::default();
                                C::inst_data_value_etor(ctx, v33, &mut v34);
                                let mut v34 = v34.into_context_iter();
                                while let Some(v35) = v34.next(ctx) {
                                    if v35.0 == F32 {
                                        if let &InstructionData::UnaryIeee32 {
                                            opcode: ref v754,
                                            imm: v755,
                                        } = &v35.1 {
                                            if let &Opcode::F32const = v754 {
                                                let v858 = C::f32_ceil(ctx, v755);
                                                if let Some(v859) = v858 {
                                                    let v860 = constructor_f32const(ctx, F32, v859);
                                                    let v861 = C::subsume(ctx, v860);
                                                    // Rule at src/opts/cprop.isle line 364.
                                                    returns.extend(Some(v861));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            F64 => {
                                let mut v34 = C::inst_data_value_etor_returns::default();
                                C::inst_data_value_etor(ctx, v33, &mut v34);
                                let mut v34 = v34.into_context_iter();
                                while let Some(v35) = v34.next(ctx) {
                                    if v35.0 == F64 {
                                        if let &InstructionData::UnaryIeee64 {
                                            opcode: ref v760,
                                            imm: v761,
                                        } = &v35.1 {
                                            if let &Opcode::F64const = v760 {
                                                let v862 = C::f64_ceil(ctx, v761);
                                                if let Some(v863) = v862 {
                                                    let v864 = constructor_f64const(ctx, F64, v863);
                                                    let v865 = C::subsume(ctx, v864);
                                                    // Rule at src/opts/cprop.isle line 367.
                                                    returns.extend(Some(v865));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            _ => {}
                        }
                    }
                    &Opcode::Floor => {
                        match v2.0 {
                            F32 => {
                                let mut v34 = C::inst_data_value_etor_returns::default();
                                C::inst_data_value_etor(ctx, v33, &mut v34);
                                let mut v34 = v34.into_context_iter();
                                while let Some(v35) = v34.next(ctx) {
                                    if v35.0 == F32 {
                                        if let &InstructionData::UnaryIeee32 {
                                            opcode: ref v754,
                                            imm: v755,
                                        } = &v35.1 {
                                            if let &Opcode::F32const = v754 {
                                                let v866 = C::f32_floor(ctx, v755);
                                                if let Some(v867) = v866 {
                                                    let v868 = constructor_f32const(ctx, F32, v867);
                                                    let v869 = C::subsume(ctx, v868);
                                                    // Rule at src/opts/cprop.isle line 371.
                                                    returns.extend(Some(v869));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            F64 => {
                                let mut v34 = C::inst_data_value_etor_returns::default();
                                C::inst_data_value_etor(ctx, v33, &mut v34);
                                let mut v34 = v34.into_context_iter();
                                while let Some(v35) = v34.next(ctx) {
                                    if v35.0 == F64 {
                                        if let &InstructionData::UnaryIeee64 {
                                            opcode: ref v760,
                                            imm: v761,
                                        } = &v35.1 {
                                            if let &Opcode::F64const = v760 {
                                                let v870 = C::f64_floor(ctx, v761);
                                                if let Some(v871) = v870 {
                                                    let v872 = constructor_f64const(ctx, F64, v871);
                                                    let v873 = C::subsume(ctx, v872);
                                                    // Rule at src/opts/cprop.isle line 374.
                                                    returns.extend(Some(v873));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            _ => {}
                        }
                    }
                    &Opcode::Trunc => {
                        match v2.0 {
                            F32 => {
                                let mut v34 = C::inst_data_value_etor_returns::default();
                                C::inst_data_value_etor(ctx, v33, &mut v34);
                                let mut v34 = v34.into_context_iter();
                                while let Some(v35) = v34.next(ctx) {
                                    if v35.0 == F32 {
                                        if let &InstructionData::UnaryIeee32 {
                                            opcode: ref v754,
                                            imm: v755,
                                        } = &v35.1 {
                                            if let &Opcode::F32const = v754 {
                                                let v874 = C::f32_trunc(ctx, v755);
                                                if let Some(v875) = v874 {
                                                    let v876 = constructor_f32const(ctx, F32, v875);
                                                    let v877 = C::subsume(ctx, v876);
                                                    // Rule at src/opts/cprop.isle line 378.
                                                    returns.extend(Some(v877));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            F64 => {
                                let mut v34 = C::inst_data_value_etor_returns::default();
                                C::inst_data_value_etor(ctx, v33, &mut v34);
                                let mut v34 = v34.into_context_iter();
                                while let Some(v35) = v34.next(ctx) {
                                    if v35.0 == F64 {
                                        if let &InstructionData::UnaryIeee64 {
                                            opcode: ref v760,
                                            imm: v761,
                                        } = &v35.1 {
                                            if let &Opcode::F64const = v760 {
                                                let v878 = C::f64_trunc(ctx, v761);
                                                if let Some(v879) = v878 {
                                                    let v880 = constructor_f64const(ctx, F64, v879);
                                                    let v881 = C::subsume(ctx, v880);
                                                    // Rule at src/opts/cprop.isle line 381.
                                                    returns.extend(Some(v881));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            _ => {}
                        }
                    }
                    &Opcode::Nearest => {
                        match v2.0 {
                            F32 => {
                                let mut v34 = C::inst_data_value_etor_returns::default();
                                C::inst_data_value_etor(ctx, v33, &mut v34);
                                let mut v34 = v34.into_context_iter();
                                while let Some(v35) = v34.next(ctx) {
                                    if v35.0 == F32 {
                                        if let &InstructionData::UnaryIeee32 {
                                            opcode: ref v754,
                                            imm: v755,
                                        } = &v35.1 {
                                            if let &Opcode::F32const = v754 {
                                                let v882 = C::f32_nearest(ctx, v755);
                                                if let Some(v883) = v882 {
                                                    let v884 = constructor_f32const(ctx, F32, v883);
                                                    let v885 = C::subsume(ctx, v884);
                                                    // Rule at src/opts/cprop.isle line 385.
                                                    returns.extend(Some(v885));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            F64 => {
                                let mut v34 = C::inst_data_value_etor_returns::default();
                                C::inst_data_value_etor(ctx, v33, &mut v34);
                                let mut v34 = v34.into_context_iter();
                                while let Some(v35) = v34.next(ctx) {
                                    if v35.0 == F64 {
                                        if let &InstructionData::UnaryIeee64 {
                                            opcode: ref v760,
                                            imm: v761,
                                        } = &v35.1 {
                                            if let &Opcode::F64const = v760 {
                                                let v886 = C::f64_nearest(ctx, v761);
                                                if let Some(v887) = v886 {
                                                    let v888 = constructor_f64const(ctx, F64, v887);
                                                    let v889 = C::subsume(ctx, v888);
                                                    // Rule at src/opts/cprop.isle line 388.
                                                    returns.extend(Some(v889));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            _ => {}
                        }
                    }
                    &Opcode::Bmask => {
                        if v2.0 == I8 {
                            let mut v34 = C::inst_data_value_etor_returns::default();
                            C::inst_data_value_etor(ctx, v33, &mut v34);
                            let mut v34 = v34.into_context_iter();
                            while let Some(v35) = v34.next(ctx) {
                                if v35.0 == I8 {
                                    if let &InstructionData::IntCompare {
                                        opcode: ref v271,
                                        args: ref v272,
                                        cond: ref v273,
                                    } = &v35.1 {
                                        if let &Opcode::Icmp = v271 {
                                            let v278 = constructor_ineg(ctx, I8, v33);
                                            // Rule at src/opts/bitops.isle line 89.
                                            returns.extend(Some(v278));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                    }
                                }
                            }
                        }
                        let mut v279 = ContextIterWrapper::<ConstructorVec<_>, _>::default();
                        constructor_truthy(ctx, v33, &mut v279);
                        let mut v279 = v279.into_context_iter();
                        while let Some(v280) = v279.next(ctx) {
                            let v281 = constructor_bmask(ctx, v2.0, v280);
                            // Rule at src/opts/bitops.isle line 111.
                            returns.extend(Some(v281));
                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                        }
                    }
                    &Opcode::Ireduce => {
                        let mut v34 = C::inst_data_value_etor_returns::default();
                        C::inst_data_value_etor(ctx, v33, &mut v34);
                        let mut v34 = v34.into_context_iter();
                        while let Some(v35) = v34.next(ctx) {
                            match &v35.1 {
                                &InstructionData::Binary {
                                    opcode: ref v38,
                                    args: ref v39,
                                } => {
                                    match v38 {
                                        &Opcode::Iadd => {
                                            let v40 = C::unpack_value_array_2(ctx, v39);
                                            let v1031 = constructor_ireduce(ctx, v2.0, v40.0);
                                            let v1032 = constructor_ireduce(ctx, v2.0, v40.1);
                                            let v1033 = constructor_iadd(ctx, v2.0, v1031, v1032);
                                            // Rule at src/opts/extends.isle line 85.
                                            returns.extend(Some(v1033));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Isub => {
                                            let v40 = C::unpack_value_array_2(ctx, v39);
                                            let v1031 = constructor_ireduce(ctx, v2.0, v40.0);
                                            let v1032 = constructor_ireduce(ctx, v2.0, v40.1);
                                            let v1034 = constructor_isub(ctx, v2.0, v1031, v1032);
                                            // Rule at src/opts/extends.isle line 86.
                                            returns.extend(Some(v1034));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Imul => {
                                            let v40 = C::unpack_value_array_2(ctx, v39);
                                            let v1031 = constructor_ireduce(ctx, v2.0, v40.0);
                                            let v1032 = constructor_ireduce(ctx, v2.0, v40.1);
                                            let v1035 = constructor_imul(ctx, v2.0, v1031, v1032);
                                            // Rule at src/opts/extends.isle line 87.
                                            returns.extend(Some(v1035));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Band => {
                                            let v40 = C::unpack_value_array_2(ctx, v39);
                                            let v1031 = constructor_ireduce(ctx, v2.0, v40.0);
                                            let v1032 = constructor_ireduce(ctx, v2.0, v40.1);
                                            let v1038 = constructor_band(ctx, v2.0, v1031, v1032);
                                            // Rule at src/opts/extends.isle line 90.
                                            returns.extend(Some(v1038));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Bor => {
                                            let v40 = C::unpack_value_array_2(ctx, v39);
                                            let v1031 = constructor_ireduce(ctx, v2.0, v40.0);
                                            let v1032 = constructor_ireduce(ctx, v2.0, v40.1);
                                            let v1036 = constructor_bor(ctx, v2.0, v1031, v1032);
                                            // Rule at src/opts/extends.isle line 88.
                                            returns.extend(Some(v1036));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Bxor => {
                                            let v40 = C::unpack_value_array_2(ctx, v39);
                                            let v1031 = constructor_ireduce(ctx, v2.0, v40.0);
                                            let v1032 = constructor_ireduce(ctx, v2.0, v40.1);
                                            let v1037 = constructor_bxor(ctx, v2.0, v1031, v1032);
                                            // Rule at src/opts/extends.isle line 89.
                                            returns.extend(Some(v1037));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        _ => {}
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v45,
                                    arg: v46,
                                } => {
                                    match v45 {
                                        &Opcode::Ineg => {
                                            let v1028 = constructor_ireduce(ctx, v2.0, v46);
                                            let v1029 = constructor_ineg(ctx, v2.0, v1028);
                                            // Rule at src/opts/extends.isle line 82.
                                            returns.extend(Some(v1029));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Bnot => {
                                            let v1028 = constructor_ireduce(ctx, v2.0, v46);
                                            let v1030 = constructor_bnot(ctx, v2.0, v1028);
                                            // Rule at src/opts/extends.isle line 83.
                                            returns.extend(Some(v1030));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Bmask => {
                                            let v292 = constructor_bmask(ctx, v2.0, v46);
                                            // Rule at src/opts/bitops.isle line 125.
                                            returns.extend(Some(v292));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Uextend => {
                                            let v52 = C::ty_int(ctx, v2.0);
                                            if let Some(v53) = v52 {
                                                let v1014 = C::ty_bits_u64(ctx, v53);
                                                let v1013 = C::value_type(ctx, v46);
                                                let v1015 = C::ty_bits_u64(ctx, v1013);
                                                let v1016 = C::u64_lt(ctx, v1014, v1015);
                                                if v1016 == true {
                                                    let v1017 = constructor_ireduce(ctx, v53, v46);
                                                    // Rule at src/opts/extends.isle line 57.
                                                    returns.extend(Some(v1017));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                let v1018 = C::u64_lt(ctx, v1015, v1014);
                                                if v1018 == true {
                                                    let v1020 = constructor_uextend(ctx, v53, v46);
                                                    // Rule at src/opts/extends.isle line 64.
                                                    returns.extend(Some(v1020));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                            let v1013 = C::value_type(ctx, v46);
                                            if v2.0 == v1013 {
                                                let v47 = C::subsume(ctx, v46);
                                                // Rule at src/opts/extends.isle line 50.
                                                returns.extend(Some(v47));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                        &Opcode::Sextend => {
                                            let v52 = C::ty_int(ctx, v2.0);
                                            if let Some(v53) = v52 {
                                                let v1014 = C::ty_bits_u64(ctx, v53);
                                                let v1013 = C::value_type(ctx, v46);
                                                let v1015 = C::ty_bits_u64(ctx, v1013);
                                                let v1016 = C::u64_lt(ctx, v1014, v1015);
                                                if v1016 == true {
                                                    let v1017 = constructor_ireduce(ctx, v53, v46);
                                                    // Rule at src/opts/extends.isle line 54.
                                                    returns.extend(Some(v1017));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                                let v1018 = C::u64_lt(ctx, v1015, v1014);
                                                if v1018 == true {
                                                    let v1019 = constructor_sextend(ctx, v53, v46);
                                                    // Rule at src/opts/extends.isle line 61.
                                                    returns.extend(Some(v1019));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                            let v1013 = C::value_type(ctx, v46);
                                            if v2.0 == v1013 {
                                                let v47 = C::subsume(ctx, v46);
                                                // Rule at src/opts/extends.isle line 49.
                                                returns.extend(Some(v47));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                        _ => {}
                                    }
                                }
                                &InstructionData::UnaryImm {
                                    opcode: ref v610,
                                    imm: v611,
                                } => {
                                    if let &Opcode::Iconst = v610 {
                                        let v656 = C::fits_in_64(ctx, v35.0);
                                        if let Some(v657) = v656 {
                                            let v642 = C::u64_from_imm64(ctx, v611);
                                            let v658 = C::imm64_masked(ctx, v2.0, v642);
                                            let v659 = constructor_iconst(ctx, v2.0, v658);
                                            let v660 = C::subsume(ctx, v659);
                                            // Rule at src/opts/cprop.isle line 93.
                                            returns.extend(Some(v660));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                    }
                                }
                                _ => {}
                            }
                        }
                    }
                    &Opcode::SwidenLow => {
                        let mut v34 = C::inst_data_value_etor_returns::default();
                        C::inst_data_value_etor(ctx, v33, &mut v34);
                        let mut v34 = v34.into_context_iter();
                        while let Some(v35) = v34.next(ctx) {
                            if let &InstructionData::Unary {
                                opcode: ref v45,
                                arg: v46,
                            } = &v35.1 {
                                if let &Opcode::Splat = v45 {
                                    let v1425 = C::lane_type(ctx, v2.0);
                                    let v1583 = constructor_sextend(ctx, v1425, v46);
                                    let v1584 = constructor_splat(ctx, v2.0, v1583);
                                    // Rule at src/opts/vector.isle line 85.
                                    returns.extend(Some(v1584));
                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                }
                            }
                        }
                    }
                    &Opcode::SwidenHigh => {
                        let mut v34 = C::inst_data_value_etor_returns::default();
                        C::inst_data_value_etor(ctx, v33, &mut v34);
                        let mut v34 = v34.into_context_iter();
                        while let Some(v35) = v34.next(ctx) {
                            if let &InstructionData::Unary {
                                opcode: ref v45,
                                arg: v46,
                            } = &v35.1 {
                                if let &Opcode::Splat = v45 {
                                    let v1425 = C::lane_type(ctx, v2.0);
                                    let v1583 = constructor_sextend(ctx, v1425, v46);
                                    let v1584 = constructor_splat(ctx, v2.0, v1583);
                                    // Rule at src/opts/vector.isle line 84.
                                    returns.extend(Some(v1584));
                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                }
                            }
                        }
                    }
                    &Opcode::UwidenLow => {
                        let mut v34 = C::inst_data_value_etor_returns::default();
                        C::inst_data_value_etor(ctx, v33, &mut v34);
                        let mut v34 = v34.into_context_iter();
                        while let Some(v35) = v34.next(ctx) {
                            if let &InstructionData::Unary {
                                opcode: ref v45,
                                arg: v46,
                            } = &v35.1 {
                                if let &Opcode::Splat = v45 {
                                    let v1425 = C::lane_type(ctx, v2.0);
                                    let v1585 = constructor_uextend(ctx, v1425, v46);
                                    let v1586 = constructor_splat(ctx, v2.0, v1585);
                                    // Rule at src/opts/vector.isle line 88.
                                    returns.extend(Some(v1586));
                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                }
                            }
                        }
                    }
                    &Opcode::UwidenHigh => {
                        let mut v34 = C::inst_data_value_etor_returns::default();
                        C::inst_data_value_etor(ctx, v33, &mut v34);
                        let mut v34 = v34.into_context_iter();
                        while let Some(v35) = v34.next(ctx) {
                            if let &InstructionData::Unary {
                                opcode: ref v45,
                                arg: v46,
                            } = &v35.1 {
                                if let &Opcode::Splat = v45 {
                                    let v1425 = C::lane_type(ctx, v2.0);
                                    let v1585 = constructor_uextend(ctx, v1425, v46);
                                    let v1586 = constructor_splat(ctx, v2.0, v1585);
                                    // Rule at src/opts/vector.isle line 87.
                                    returns.extend(Some(v1586));
                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                }
                            }
                        }
                    }
                    &Opcode::Uextend => {
                        let mut v34 = C::inst_data_value_etor_returns::default();
                        C::inst_data_value_etor(ctx, v33, &mut v34);
                        let mut v34 = v34.into_context_iter();
                        while let Some(v35) = v34.next(ctx) {
                            match &v35.1 {
                                &InstructionData::Unary {
                                    opcode: ref v45,
                                    arg: v46,
                                } => {
                                    if let &Opcode::Uextend = v45 {
                                        let v983 = constructor_uextend(ctx, v2.0, v46);
                                        // Rule at src/opts/extends.isle line 1.
                                        returns.extend(Some(v983));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                                &InstructionData::UnaryImm {
                                    opcode: ref v610,
                                    imm: v611,
                                } => {
                                    if let &Opcode::Iconst = v610 {
                                        let v608 = C::fits_in_64(ctx, v2.0);
                                        if let Some(v609) = v608 {
                                            let v642 = C::u64_from_imm64(ctx, v611);
                                            let v661 = constructor_iconst_u(ctx, v609, v642);
                                            let v662 = C::subsume(ctx, v661);
                                            // Rule at src/opts/cprop.isle line 98.
                                            returns.extend(Some(v662));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                    }
                                }
                                _ => {}
                            }
                        }
                    }
                    &Opcode::Sextend => {
                        let mut v34 = C::inst_data_value_etor_returns::default();
                        C::inst_data_value_etor(ctx, v33, &mut v34);
                        let mut v34 = v34.into_context_iter();
                        while let Some(v35) = v34.next(ctx) {
                            match &v35.1 {
                                &InstructionData::IntCompare {
                                    opcode: ref v271,
                                    args: ref v272,
                                    cond: ref v273,
                                } => {
                                    if let &Opcode::Icmp = v271 {
                                        let v985 = constructor_uextend(ctx, v2.0, v33);
                                        // Rule at src/opts/extends.isle line 11.
                                        returns.extend(Some(v985));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                                &InstructionData::Unary {
                                    opcode: ref v45,
                                    arg: v46,
                                } => {
                                    match v45 {
                                        &Opcode::Bmask => {
                                            let v292 = constructor_bmask(ctx, v2.0, v46);
                                            // Rule at src/opts/bitops.isle line 124.
                                            returns.extend(Some(v292));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Uextend => {
                                            let v983 = constructor_uextend(ctx, v2.0, v46);
                                            // Rule at src/opts/extends.isle line 7.
                                            returns.extend(Some(v983));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Sextend => {
                                            let v984 = constructor_sextend(ctx, v2.0, v46);
                                            // Rule at src/opts/extends.isle line 3.
                                            returns.extend(Some(v984));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        _ => {}
                                    }
                                }
                                _ => {}
                            }
                        }
                        let v608 = C::fits_in_64(ctx, v2.0);
                        if let Some(v609) = v608 {
                            let mut v663 = C::inst_data_value_tupled_etor_returns::default();
                            C::inst_data_value_tupled_etor(ctx, v33, &mut v663);
                            let mut v663 = v663.into_context_iter();
                            while let Some(v664) = v663.next(ctx) {
                                let v665 = C::iconst_sextend_etor(ctx, v664);
                                if let Some(v666) = v665 {
                                    let v669 = constructor_iconst_s(ctx, v609, v666.1);
                                    let v670 = C::subsume(ctx, v669);
                                    // Rule at src/opts/cprop.isle line 100.
                                    returns.extend(Some(v670));
                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                }
                            }
                        }
                    }
                    &Opcode::FcvtFromUint => {
                        let mut v34 = C::inst_data_value_etor_returns::default();
                        C::inst_data_value_etor(ctx, v33, &mut v34);
                        let mut v34 = v34.into_context_iter();
                        while let Some(v35) = v34.next(ctx) {
                            match &v35.1 {
                                &InstructionData::Unary {
                                    opcode: ref v45,
                                    arg: v46,
                                } => {
                                    match v45 {
                                        &Opcode::Splat => {
                                            let v1425 = C::lane_type(ctx, v2.0);
                                            let v1535 = constructor_fcvt_from_uint(ctx, v1425, v46);
                                            let v1536 = constructor_splat(ctx, v2.0, v1535);
                                            // Rule at src/opts/vector.isle line 6.
                                            returns.extend(Some(v1536));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        &Opcode::Uextend => {
                                            let v132 = constructor_fcvt_from_uint(ctx, v2.0, v46);
                                            // Rule at src/opts/arithmetic.isle line 219.
                                            returns.extend(Some(v132));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        _ => {}
                                    }
                                }
                                &InstructionData::UnaryImm {
                                    opcode: ref v610,
                                    imm: v611,
                                } => {
                                    if let &Opcode::Iconst = v610 {
                                        match v2.0 {
                                            F32 => {
                                                let v642 = C::u64_from_imm64(ctx, v611);
                                                let v789 = C::f32_from_uint(ctx, v642);
                                                let v790 = constructor_f32const(ctx, F32, v789);
                                                // Rule at src/opts/cprop.isle line 287.
                                                returns.extend(Some(v790));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                            F64 => {
                                                let v642 = C::u64_from_imm64(ctx, v611);
                                                let v792 = C::f64_from_uint(ctx, v642);
                                                let v793 = constructor_f64const(ctx, F64, v792);
                                                // Rule at src/opts/cprop.isle line 289.
                                                returns.extend(Some(v793));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                            _ => {}
                                        }
                                    }
                                }
                                _ => {}
                            }
                        }
                    }
                    &Opcode::FcvtFromSint => {
                        match v2.0 {
                            F32 => {
                                let mut v663 = C::inst_data_value_tupled_etor_returns::default();
                                C::inst_data_value_tupled_etor(ctx, v33, &mut v663);
                                let mut v663 = v663.into_context_iter();
                                while let Some(v664) = v663.next(ctx) {
                                    let v665 = C::iconst_sextend_etor(ctx, v664);
                                    if let Some(v666) = v665 {
                                        let v794 = C::f32_from_sint(ctx, v666.1);
                                        let v795 = constructor_f32const(ctx, F32, v794);
                                        // Rule at src/opts/cprop.isle line 291.
                                        returns.extend(Some(v795));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                            }
                            F64 => {
                                let mut v663 = C::inst_data_value_tupled_etor_returns::default();
                                C::inst_data_value_tupled_etor(ctx, v33, &mut v663);
                                let mut v663 = v663.into_context_iter();
                                while let Some(v664) = v663.next(ctx) {
                                    let v665 = C::iconst_sextend_etor(ctx, v664);
                                    if let Some(v666) = v665 {
                                        let v796 = C::f64_from_sint(ctx, v666.1);
                                        let v797 = constructor_f64const(ctx, F64, v796);
                                        // Rule at src/opts/cprop.isle line 293.
                                        returns.extend(Some(v797));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                            }
                            _ => {}
                        }
                        let mut v34 = C::inst_data_value_etor_returns::default();
                        C::inst_data_value_etor(ctx, v33, &mut v34);
                        let mut v34 = v34.into_context_iter();
                        while let Some(v35) = v34.next(ctx) {
                            if let &InstructionData::Unary {
                                opcode: ref v45,
                                arg: v46,
                            } = &v35.1 {
                                match v45 {
                                    &Opcode::Splat => {
                                        let v1425 = C::lane_type(ctx, v2.0);
                                        let v1537 = constructor_fcvt_from_sint(ctx, v1425, v46);
                                        let v1538 = constructor_splat(ctx, v2.0, v1537);
                                        // Rule at src/opts/vector.isle line 8.
                                        returns.extend(Some(v1538));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                    &Opcode::Sextend => {
                                        let v133 = constructor_fcvt_from_sint(ctx, v2.0, v46);
                                        // Rule at src/opts/arithmetic.isle line 221.
                                        returns.extend(Some(v133));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                    _ => {}
                                }
                            }
                        }
                    }
                    _ => {}
                }
            }
            &InstructionData::UnaryIeee32 {
                opcode: ref v1273,
                imm: v1274,
            } => {
                if let &Opcode::F32const = v1273 {
                    let v1270 = C::remat(ctx, arg0);
                    // Rule at src/opts/remat.isle line 27.
                    returns.extend(Some(v1270));
                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                }
            }
            &InstructionData::UnaryIeee64 {
                opcode: ref v1275,
                imm: v1276,
            } => {
                if let &Opcode::F64const = v1275 {
                    let v1270 = C::remat(ctx, arg0);
                    // Rule at src/opts/remat.isle line 29.
                    returns.extend(Some(v1270));
                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                }
            }
            &InstructionData::UnaryImm {
                opcode: ref v1271,
                imm: v1272,
            } => {
                if let &Opcode::Iconst = v1271 {
                    let v1270 = C::remat(ctx, arg0);
                    // Rule at src/opts/remat.isle line 25.
                    returns.extend(Some(v1270));
                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                }
            }
            _ => {}
        }
    }
}

// Generated as internal constructor for term inst_to_skeleton_inst_simplification.
pub fn constructor_inst_to_skeleton_inst_simplification<C: Context>(
    ctx: &mut C,
    arg0: Inst,
) -> SkeletonInstSimplification {
    let v1 = SkeletonInstSimplification::Replace {
        inst: arg0,
    };
    // Rule at src/prelude_opt.isle line 91.
    return v1;
}

// Generated as internal constructor for term value_to_skeleton_inst_simplification.
pub fn constructor_value_to_skeleton_inst_simplification<C: Context>(
    ctx: &mut C,
    arg0: Value,
) -> SkeletonInstSimplification {
    let v1 = SkeletonInstSimplification::RemoveWithVal {
        val: arg0,
    };
    // Rule at src/prelude_opt.isle line 95.
    return v1;
}

// Generated as internal constructor for term remove_inst.
pub fn constructor_remove_inst<C: Context>(
    ctx: &mut C,
) -> SkeletonInstSimplification {
    // Rule at src/prelude_opt.isle line 99.
    return SkeletonInstSimplification::Remove;
}

// Generated as internal constructor for term replace_with_val.
pub fn constructor_replace_with_val<C: Context>(
    ctx: &mut C,
    arg0: Inst,
    arg1: Value,
) -> SkeletonInstSimplification {
    let v2 = SkeletonInstSimplification::ReplaceWithVal {
        inst: arg0,
        val: arg1,
    };
    // Rule at src/prelude_opt.isle line 102.
    return v2;
}

// Generated as internal constructor for term simplify_skeleton.
pub fn constructor_simplify_skeleton<C: Context>(
    ctx: &mut C,
    arg0: Inst,
    returns: &mut (impl Extend<SkeletonInstSimplification> + Length),
) -> () {
    let v1 = &C::inst_data_etor(ctx, arg0);
    if let Some(v2) = v1 {
        match v2 {
            &InstructionData::Binary {
                opcode: ref v3,
                args: ref v4,
            } => {
                match v3 {
                    &Opcode::Udiv => {
                        let v5 = C::unpack_value_array_2(ctx, v4);
                        let mut v15 = C::inst_data_value_etor_returns::default();
                        C::inst_data_value_etor(ctx, v5.1, &mut v15);
                        let mut v15 = v15.into_context_iter();
                        while let Some(v16) = v15.next(ctx) {
                            match &v16.1 {
                                &InstructionData::Ternary {
                                    opcode: ref v189,
                                    args: ref v190,
                                } => {
                                    if let &Opcode::Select = v189 {
                                        let v191 = C::unpack_value_array_3(ctx, v190);
                                        let mut v195 = C::inst_data_value_etor_returns::default();
                                        C::inst_data_value_etor(ctx, v191.1, &mut v195);
                                        let mut v195 = v195.into_context_iter();
                                        while let Some(v196) = v195.next(ctx) {
                                            if let &InstructionData::UnaryImm {
                                                opcode: ref v199,
                                                imm: v200,
                                            } = &v196.1 {
                                                if let &Opcode::Iconst = v199 {
                                                    let v201 = C::imm64_power_of_two(ctx, v200);
                                                    if let Some(v202) = v201 {
                                                        if v16.0 == v196.0 {
                                                            let mut v203 = C::inst_data_value_etor_returns::default();
                                                            C::inst_data_value_etor(ctx, v191.2, &mut v203);
                                                            let mut v203 = v203.into_context_iter();
                                                            while let Some(v204) = v203.next(ctx) {
                                                                if let &InstructionData::UnaryImm {
                                                                    opcode: ref v207,
                                                                    imm: v208,
                                                                } = &v204.1 {
                                                                    if let &Opcode::Iconst = v207 {
                                                                        let v209 = C::imm64_power_of_two(ctx, v208);
                                                                        if let Some(v210) = v209 {
                                                                            if v16.0 == v204.0 {
                                                                                let v211 = C::imm64(ctx, v202);
                                                                                let v212 = constructor_iconst(ctx, v16.0, v211);
                                                                                let v213 = C::imm64(ctx, v210);
                                                                                let v214 = constructor_iconst(ctx, v16.0, v213);
                                                                                let v215 = constructor_select(ctx, v16.0, v191.0, v212, v214);
                                                                                let v216 = constructor_ushr(ctx, v16.0, v5.0, v215);
                                                                                let v217 = &constructor_value_to_skeleton_inst_simplification(ctx, v216);
                                                                                // Rule at src/opts/skeleton.isle line 40.
                                                                                returns.extend(Some(v217.clone()));
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                                &InstructionData::UnaryImm {
                                    opcode: ref v19,
                                    imm: v20,
                                } => {
                                    if let &Opcode::Iconst = v19 {
                                        match v16.0 {
                                            I32 => {
                                                let v21 = C::u64_from_imm64(ctx, v20);
                                                let v70 = C::u64_matches_non_zero(ctx, v21);
                                                if let Some(v71) = v70 {
                                                    if v71 == true {
                                                        let v72 = C::u64_from_u32(ctx, v21);
                                                        if let Some(v73) = v72 {
                                                            let v74 = C::u32_is_power_of_two(ctx, v73);
                                                            if v74 == false {
                                                                let v76 = constructor_apply_div_const_magic_u32(ctx, &Opcode::Udiv, v5.0, v73);
                                                                let v77 = &constructor_value_to_skeleton_inst_simplification(ctx, v76);
                                                                // Rule at src/opts/arithmetic.isle line 113.
                                                                returns.extend(Some(v77.clone()));
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                            I64 => {
                                                let v21 = C::u64_from_imm64(ctx, v20);
                                                let v70 = C::u64_matches_non_zero(ctx, v21);
                                                if let Some(v71) = v70 {
                                                    if v71 == true {
                                                        let v78 = C::u64_is_power_of_two(ctx, v21);
                                                        if v78 == false {
                                                            let v79 = constructor_apply_div_const_magic_u64(ctx, &Opcode::Udiv, v5.0, v21);
                                                            let v80 = &constructor_value_to_skeleton_inst_simplification(ctx, v79);
                                                            // Rule at src/opts/arithmetic.isle line 116.
                                                            returns.extend(Some(v80.clone()));
                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                        }
                                                    }
                                                }
                                            }
                                            _ => {}
                                        }
                                        let v21 = C::u64_from_imm64(ctx, v20);
                                        if v21 == 0x1_u64 {
                                            let v14 = &constructor_value_to_skeleton_inst_simplification(ctx, v5.0);
                                            // Rule at src/opts/arithmetic.isle line 79.
                                            returns.extend(Some(v14.clone()));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                        let v22 = C::u64_matches_power_of_two(ctx, v21);
                                        if let Some(v23) = v22 {
                                            if v23 == true {
                                                let v24 = C::u64_ilog2(ctx, v21);
                                                let v25 = C::u32_into_u64(ctx, v24);
                                                let v26 = constructor_iconst_u(ctx, v16.0, v25);
                                                let v27 = constructor_ushr(ctx, v16.0, v5.0, v26);
                                                let v28 = &constructor_value_to_skeleton_inst_simplification(ctx, v27);
                                                // Rule at src/opts/arithmetic.isle line 82.
                                                returns.extend(Some(v28.clone()));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                        let mut v121 = C::inst_data_value_etor_returns::default();
                                        C::inst_data_value_etor(ctx, v5.0, &mut v121);
                                        let mut v121 = v121.into_context_iter();
                                        while let Some(v122) = v121.next(ctx) {
                                            if let &InstructionData::UnaryImm {
                                                opcode: ref v125,
                                                imm: v126,
                                            } = &v122.1 {
                                                if let &Opcode::Iconst = v125 {
                                                    let v135 = C::u64_from_imm64(ctx, v126);
                                                    let v136 = C::u64_checked_div(ctx, v135, v21);
                                                    if let Some(v137) = v136 {
                                                        if v16.0 == v122.0 {
                                                            let v138 = C::imm64_masked(ctx, v122.0, v137);
                                                            let v139 = constructor_iconst(ctx, v122.0, v138);
                                                            let v140 = &constructor_value_to_skeleton_inst_simplification(ctx, v139);
                                                            // Rule at src/opts/cprop.isle line 43.
                                                            returns.extend(Some(v140.clone()));
                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                                _ => {}
                            }
                        }
                    }
                    &Opcode::Sdiv => {
                        let v5 = C::unpack_value_array_2(ctx, v4);
                        let mut v8 = C::inst_data_value_tupled_etor_returns::default();
                        C::inst_data_value_tupled_etor(ctx, v5.1, &mut v8);
                        let mut v8 = v8.into_context_iter();
                        while let Some(v9) = v8.next(ctx) {
                            let v10 = C::iconst_sextend_etor(ctx, v9);
                            if let Some(v11) = v10 {
                                match v11.0 {
                                    I32 => {
                                        let v81 = C::i64_matches_non_zero(ctx, v11.1);
                                        if let Some(v82) = v81 {
                                            if v82 == true {
                                                let v83 = C::i64_from_i32(ctx, v11.1);
                                                if let Some(v84) = v83 {
                                                    let v85 = C::i32_into_i64(ctx, v84);
                                                    let v86 = constructor_i64_is_any_sign_power_of_two(ctx, v85);
                                                    if v86 == false {
                                                        let v88 = constructor_apply_div_const_magic_s32(ctx, &Opcode::Sdiv, v5.0, v84);
                                                        let v89 = &constructor_value_to_skeleton_inst_simplification(ctx, v88);
                                                        // Rule at src/opts/arithmetic.isle line 121.
                                                        returns.extend(Some(v89.clone()));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    I64 => {
                                        let v81 = C::i64_matches_non_zero(ctx, v11.1);
                                        if let Some(v82) = v81 {
                                            if v82 == true {
                                                let v90 = constructor_i64_is_any_sign_power_of_two(ctx, v11.1);
                                                if v90 == false {
                                                    let v91 = constructor_apply_div_const_magic_s64(ctx, &Opcode::Sdiv, v5.0, v11.1);
                                                    let v92 = &constructor_value_to_skeleton_inst_simplification(ctx, v91);
                                                    // Rule at src/opts/arithmetic.isle line 124.
                                                    returns.extend(Some(v92.clone()));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                    }
                                    _ => {}
                                }
                                if v11.1 == 1_i64 {
                                    let v14 = &constructor_value_to_skeleton_inst_simplification(ctx, v5.0);
                                    // Rule at src/opts/arithmetic.isle line 78.
                                    returns.extend(Some(v14.clone()));
                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                }
                                let v50 = constructor_i64_is_negative_power_of_two(ctx, v11.1);
                                if v50 == true {
                                    let v52 = C::i64_ne(ctx, v11.1, -1_i64);
                                    if v52 == true {
                                        let v53 = C::i64_trailing_zeros(ctx, v11.1);
                                        let v54 = C::u32_sub(ctx, v53, 0x1_u32);
                                        let v55 = C::u32_into_u64(ctx, v54);
                                        let v56 = constructor_iconst_u(ctx, v11.0, v55);
                                        let v57 = constructor_sshr(ctx, v11.0, v5.0, v56);
                                        let v58 = C::ty_bits(ctx, v11.0);
                                        let v59 = C::u8_into_u32(ctx, v58);
                                        let v60 = C::u32_sub(ctx, v59, v53);
                                        let v61 = C::u32_into_u64(ctx, v60);
                                        let v62 = constructor_iconst_u(ctx, v11.0, v61);
                                        let v63 = constructor_ushr(ctx, v11.0, v57, v62);
                                        let v64 = constructor_iadd(ctx, v11.0, v5.0, v63);
                                        let v65 = C::u32_into_i64(ctx, v53);
                                        let v66 = constructor_iconst_s(ctx, v11.0, v65);
                                        let v67 = constructor_sshr(ctx, v11.0, v64, v66);
                                        let v68 = constructor_ineg(ctx, v11.0, v67);
                                        let v69 = &constructor_value_to_skeleton_inst_simplification(ctx, v68);
                                        // Rule at src/opts/arithmetic.isle line 101.
                                        returns.extend(Some(v69.clone()));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                            }
                        }
                        let mut v15 = C::inst_data_value_etor_returns::default();
                        C::inst_data_value_etor(ctx, v5.1, &mut v15);
                        let mut v15 = v15.into_context_iter();
                        while let Some(v16) = v15.next(ctx) {
                            if let &InstructionData::UnaryImm {
                                opcode: ref v19,
                                imm: v20,
                            } = &v16.1 {
                                if let &Opcode::Iconst = v19 {
                                    let v21 = C::u64_from_imm64(ctx, v20);
                                    let v22 = C::u64_matches_power_of_two(ctx, v21);
                                    if let Some(v23) = v22 {
                                        if v23 == true {
                                            let v30 = C::u64_gt(ctx, v21, 0x1_u64);
                                            if v30 == true {
                                                let v31 = C::u64_trailing_zeros(ctx, v21);
                                                let v32 = C::ty_bits(ctx, v16.0);
                                                let v33 = C::u8_into_u32(ctx, v32);
                                                let v35 = C::u32_sub(ctx, v33, 0x1_u32);
                                                let v36 = C::u32_lt(ctx, v31, v35);
                                                if v36 == true {
                                                    let v37 = C::u32_sub(ctx, v31, 0x1_u32);
                                                    let v38 = C::u32_into_u64(ctx, v37);
                                                    let v39 = constructor_iconst_u(ctx, v16.0, v38);
                                                    let v40 = constructor_sshr(ctx, v16.0, v5.0, v39);
                                                    let v41 = C::u32_sub(ctx, v33, v31);
                                                    let v42 = C::u32_into_u64(ctx, v41);
                                                    let v43 = constructor_iconst_u(ctx, v16.0, v42);
                                                    let v44 = constructor_ushr(ctx, v16.0, v40, v43);
                                                    let v45 = constructor_iadd(ctx, v16.0, v5.0, v44);
                                                    let v46 = C::u32_into_i64(ctx, v31);
                                                    let v47 = constructor_iconst_s(ctx, v16.0, v46);
                                                    let v48 = constructor_sshr(ctx, v16.0, v45, v47);
                                                    let v49 = &constructor_value_to_skeleton_inst_simplification(ctx, v48);
                                                    // Rule at src/opts/arithmetic.isle line 86.
                                                    returns.extend(Some(v49.clone()));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                    }
                                    let mut v121 = C::inst_data_value_etor_returns::default();
                                    C::inst_data_value_etor(ctx, v5.0, &mut v121);
                                    let mut v121 = v121.into_context_iter();
                                    while let Some(v122) = v121.next(ctx) {
                                        if let &InstructionData::UnaryImm {
                                            opcode: ref v125,
                                            imm: v126,
                                        } = &v122.1 {
                                            if let &Opcode::Iconst = v125 {
                                                let v127 = C::imm64_sdiv(ctx, v122.0, v126, v20);
                                                if let Some(v128) = v127 {
                                                    if v16.0 == v122.0 {
                                                        let v129 = constructor_iconst(ctx, v122.0, v128);
                                                        let v130 = &constructor_value_to_skeleton_inst_simplification(ctx, v129);
                                                        // Rule at src/opts/cprop.isle line 31.
                                                        returns.extend(Some(v130.clone()));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                    &Opcode::Urem => {
                        let v5 = C::unpack_value_array_2(ctx, v4);
                        let mut v15 = C::inst_data_value_etor_returns::default();
                        C::inst_data_value_etor(ctx, v5.1, &mut v15);
                        let mut v15 = v15.into_context_iter();
                        while let Some(v16) = v15.next(ctx) {
                            if let &InstructionData::UnaryImm {
                                opcode: ref v19,
                                imm: v20,
                            } = &v16.1 {
                                if let &Opcode::Iconst = v19 {
                                    match v16.0 {
                                        I32 => {
                                            let v21 = C::u64_from_imm64(ctx, v20);
                                            let v70 = C::u64_matches_non_zero(ctx, v21);
                                            if let Some(v71) = v70 {
                                                if v71 == true {
                                                    let v72 = C::u64_from_u32(ctx, v21);
                                                    if let Some(v73) = v72 {
                                                        let v74 = C::u32_is_power_of_two(ctx, v73);
                                                        if v74 == false {
                                                            let v112 = constructor_apply_div_const_magic_u32(ctx, &Opcode::Urem, v5.0, v73);
                                                            let v113 = &constructor_value_to_skeleton_inst_simplification(ctx, v112);
                                                            // Rule at src/opts/arithmetic.isle line 156.
                                                            returns.extend(Some(v113.clone()));
                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        I64 => {
                                            let v21 = C::u64_from_imm64(ctx, v20);
                                            let v70 = C::u64_matches_non_zero(ctx, v21);
                                            if let Some(v71) = v70 {
                                                if v71 == true {
                                                    let v78 = C::u64_is_power_of_two(ctx, v21);
                                                    if v78 == false {
                                                        let v114 = constructor_apply_div_const_magic_u64(ctx, &Opcode::Urem, v5.0, v21);
                                                        let v115 = &constructor_value_to_skeleton_inst_simplification(ctx, v114);
                                                        // Rule at src/opts/arithmetic.isle line 159.
                                                        returns.extend(Some(v115.clone()));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                        }
                                        _ => {}
                                    }
                                    let v21 = C::u64_from_imm64(ctx, v20);
                                    if v21 == 0x1_u64 {
                                        let v94 = constructor_iconst_u(ctx, v16.0, 0x0_u64);
                                        let v95 = &constructor_value_to_skeleton_inst_simplification(ctx, v94);
                                        // Rule at src/opts/arithmetic.isle line 129.
                                        returns.extend(Some(v95.clone()));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                    let v22 = C::u64_matches_power_of_two(ctx, v21);
                                    if let Some(v23) = v22 {
                                        if v23 == true {
                                            let v30 = C::u64_gt(ctx, v21, 0x1_u64);
                                            if v30 == true {
                                                let v24 = C::u64_ilog2(ctx, v21);
                                                let v98 = C::u64_shl(ctx, 0x1_u64, v24);
                                                let v99 = C::u64_sub(ctx, v98, 0x1_u64);
                                                let v100 = constructor_iconst_u(ctx, v16.0, v99);
                                                let v101 = constructor_band(ctx, v16.0, v5.0, v100);
                                                let v102 = &constructor_value_to_skeleton_inst_simplification(ctx, v101);
                                                // Rule at src/opts/arithmetic.isle line 134.
                                                returns.extend(Some(v102.clone()));
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
                                            }
                                        }
                                    }
                                    let mut v121 = C::inst_data_value_etor_returns::default();
                                    C::inst_data_value_etor(ctx, v5.0, &mut v121);
                                    let mut v121 = v121.into_context_iter();
                                    while let Some(v122) = v121.next(ctx) {
                                        if let &InstructionData::UnaryImm {
                                            opcode: ref v125,
                                            imm: v126,
                                        } = &v122.1 {
                                            if let &Opcode::Iconst = v125 {
                                                let v135 = C::u64_from_imm64(ctx, v126);
                                                let v141 = C::u64_checked_rem(ctx, v135, v21);
                                                if let Some(v142) = v141 {
                                                    if v16.0 == v122.0 {
                                                        let v143 = C::imm64_masked(ctx, v122.0, v142);
                                                        let v144 = constructor_iconst(ctx, v122.0, v143);
                                                        let v145 = &constructor_value_to_skeleton_inst_simplification(ctx, v144);
                                                        // Rule at src/opts/cprop.isle line 49.
                                                        returns.extend(Some(v145.clone()));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                    &Opcode::Srem => {
                        let v5 = C::unpack_value_array_2(ctx, v4);
                        let mut v8 = C::inst_data_value_tupled_etor_returns::default();
                        C::inst_data_value_tupled_etor(ctx, v5.1, &mut v8);
                        let mut v8 = v8.into_context_iter();
                        while let Some(v9) = v8.next(ctx) {
                            let v10 = C::iconst_sextend_etor(ctx, v9);
                            if let Some(v11) = v10 {
                                match v11.0 {
                                    I32 => {
                                        let v81 = C::i64_matches_non_zero(ctx, v11.1);
                                        if let Some(v82) = v81 {
                                            if v82 == true {
                                                let v83 = C::i64_from_i32(ctx, v11.1);
                                                if let Some(v84) = v83 {
                                                    let v85 = C::i32_into_i64(ctx, v84);
                                                    let v86 = constructor_i64_is_any_sign_power_of_two(ctx, v85);
                                                    if v86 == false {
                                                        let v117 = constructor_apply_div_const_magic_s32(ctx, &Opcode::Srem, v5.0, v84);
                                                        let v118 = &constructor_value_to_skeleton_inst_simplification(ctx, v117);
                                                        // Rule at src/opts/arithmetic.isle line 164.
                                                        returns.extend(Some(v118.clone()));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    I64 => {
                                        let v81 = C::i64_matches_non_zero(ctx, v11.1);
                                        if let Some(v82) = v81 {
                                            if v82 == true {
                                                let v90 = constructor_i64_is_any_sign_power_of_two(ctx, v11.1);
                                                if v90 == false {
                                                    let v119 = constructor_apply_div_const_magic_s64(ctx, &Opcode::Srem, v5.0, v11.1);
                                                    let v120 = &constructor_value_to_skeleton_inst_simplification(ctx, v119);
                                                    // Rule at src/opts/arithmetic.isle line 167.
                                                    returns.extend(Some(v120.clone()));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                    }
                                    _ => {}
                                }
                                if v11.1 == -1_i64 {
                                    let v96 = constructor_iconst_u(ctx, v11.0, 0x0_u64);
                                    let v97 = &constructor_value_to_skeleton_inst_simplification(ctx, v96);
                                    // Rule at src/opts/arithmetic.isle line 131.
                                    returns.extend(Some(v97.clone()));
                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                }
                                let v52 = C::i64_ne(ctx, v11.1, -1_i64);
                                if v52 == true {
                                    let v90 = constructor_i64_is_any_sign_power_of_two(ctx, v11.1);
                                    if v90 == true {
                                        let v104 = C::i64_ne(ctx, v11.1, 1_i64);
                                        if v104 == true {
                                            let v53 = C::i64_trailing_zeros(ctx, v11.1);
                                            let v54 = C::u32_sub(ctx, v53, 0x1_u32);
                                            let v55 = C::u32_into_u64(ctx, v54);
                                            let v56 = constructor_iconst_u(ctx, v11.0, v55);
                                            let v57 = constructor_sshr(ctx, v11.0, v5.0, v56);
                                            let v58 = C::ty_bits(ctx, v11.0);
                                            let v59 = C::u8_into_u32(ctx, v58);
                                            let v60 = C::u32_sub(ctx, v59, v53);
                                            let v61 = C::u32_into_u64(ctx, v60);
                                            let v62 = constructor_iconst_u(ctx, v11.0, v61);
                                            let v63 = constructor_ushr(ctx, v11.0, v57, v62);
                                            let v64 = constructor_iadd(ctx, v11.0, v5.0, v63);
                                            let v105 = C::i64_shl(ctx, 1_i64, v53);
                                            let v106 = C::i64_wrapping_neg(ctx, v105);
                                            let v107 = constructor_iconst_s(ctx, v11.0, v106);
                                            let v108 = constructor_band(ctx, v11.0, v64, v107);
                                            let v109 = constructor_isub(ctx, v11.0, v5.0, v108);
                                            let v110 = &constructor_value_to_skeleton_inst_simplification(ctx, v109);
                                            // Rule at src/opts/arithmetic.isle line 141.
                                            returns.extend(Some(v110.clone()));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                    }
                                }
                            }
                        }
                        let mut v15 = C::inst_data_value_etor_returns::default();
                        C::inst_data_value_etor(ctx, v5.1, &mut v15);
                        let mut v15 = v15.into_context_iter();
                        while let Some(v16) = v15.next(ctx) {
                            if let &InstructionData::UnaryImm {
                                opcode: ref v19,
                                imm: v20,
                            } = &v16.1 {
                                if let &Opcode::Iconst = v19 {
                                    let v21 = C::u64_from_imm64(ctx, v20);
                                    if v21 == 0x1_u64 {
                                        let v94 = constructor_iconst_u(ctx, v16.0, 0x0_u64);
                                        let v95 = &constructor_value_to_skeleton_inst_simplification(ctx, v94);
                                        // Rule at src/opts/arithmetic.isle line 130.
                                        returns.extend(Some(v95.clone()));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                    let mut v121 = C::inst_data_value_etor_returns::default();
                                    C::inst_data_value_etor(ctx, v5.0, &mut v121);
                                    let mut v121 = v121.into_context_iter();
                                    while let Some(v122) = v121.next(ctx) {
                                        if let &InstructionData::UnaryImm {
                                            opcode: ref v125,
                                            imm: v126,
                                        } = &v122.1 {
                                            if let &Opcode::Iconst = v125 {
                                                let v131 = C::imm64_srem(ctx, v122.0, v126, v20);
                                                if let Some(v132) = v131 {
                                                    if v16.0 == v122.0 {
                                                        let v133 = constructor_iconst(ctx, v122.0, v132);
                                                        let v134 = &constructor_value_to_skeleton_inst_simplification(ctx, v133);
                                                        // Rule at src/opts/cprop.isle line 37.
                                                        returns.extend(Some(v134.clone()));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                    _ => {}
                }
            }
            &InstructionData::CondTrap {
                opcode: ref v146,
                arg: v147,
                code: ref v148,
            } => {
                match v146 {
                    &Opcode::Trapz => {
                        let mut v149 = C::inst_data_value_etor_returns::default();
                        C::inst_data_value_etor(ctx, v147, &mut v149);
                        let mut v149 = v149.into_context_iter();
                        while let Some(v150) = v149.next(ctx) {
                            if let &InstructionData::UnaryImm {
                                opcode: ref v153,
                                imm: v154,
                            } = &v150.1 {
                                if let &Opcode::Iconst = v153 {
                                    let v155 = C::u64_from_imm64(ctx, v154);
                                    let v156 = C::u64_matches_non_zero(ctx, v155);
                                    if let Some(v157) = v156 {
                                        if v157 == true {
                                            let v158 = &constructor_remove_inst(ctx);
                                            // Rule at src/opts/skeleton.isle line 6.
                                            returns.extend(Some(v158.clone()));
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
                                        }
                                    }
                                }
                            }
                        }
                    }
                    &Opcode::Trapnz => {
                        let mut v149 = C::inst_data_value_etor_returns::default();
                        C::inst_data_value_etor(ctx, v147, &mut v149);
                        let mut v149 = v149.into_context_iter();
                        while let Some(v150) = v149.next(ctx) {
                            if let &InstructionData::UnaryImm {
                                opcode: ref v153,
                                imm: v154,
                            } = &v150.1 {
                                if let &Opcode::Iconst = v153 {
                                    let v155 = C::u64_from_imm64(ctx, v154);
                                    if v155 == 0x0_u64 {
                                        let v158 = &constructor_remove_inst(ctx);
                                        // Rule at src/opts/skeleton.isle line 8.
                                        returns.extend(Some(v158.clone()));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                            }
                        }
                    }
                    _ => {}
                }
            }
            &InstructionData::IntAddTrap {
                opcode: ref v159,
                args: ref v160,
                code: ref v161,
            } => {
                if let &Opcode::UaddOverflowTrap = v159 {
                    let v162 = C::unpack_value_array_2(ctx, v160);
                    let mut v165 = C::inst_data_value_etor_returns::default();
                    C::inst_data_value_etor(ctx, v162.0, &mut v165);
                    let mut v165 = v165.into_context_iter();
                    while let Some(v166) = v165.next(ctx) {
                        match &v166.1 {
                            &InstructionData::Unary {
                                opcode: ref v183,
                                arg: v184,
                            } => {
                                if let &Opcode::Uextend = v183 {
                                    let mut v172 = C::inst_data_value_etor_returns::default();
                                    C::inst_data_value_etor(ctx, v162.1, &mut v172);
                                    let mut v172 = v172.into_context_iter();
                                    while let Some(v173) = v172.next(ctx) {
                                        if let &InstructionData::Unary {
                                            opcode: ref v185,
                                            arg: v186,
                                        } = &v173.1 {
                                            if let &Opcode::Uextend = v185 {
                                                if v166.0 == v173.0 {
                                                    let v187 = constructor_iadd(ctx, v166.0, v162.0, v162.1);
                                                    let v188 = &constructor_value_to_skeleton_inst_simplification(ctx, v187);
                                                    // Rule at src/opts/skeleton.isle line 17.
                                                    returns.extend(Some(v188.clone()));
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            &InstructionData::UnaryImm {
                                opcode: ref v169,
                                imm: v170,
                            } => {
                                if let &Opcode::Iconst = v169 {
                                    let mut v172 = C::inst_data_value_etor_returns::default();
                                    C::inst_data_value_etor(ctx, v162.1, &mut v172);
                                    let mut v172 = v172.into_context_iter();
                                    while let Some(v173) = v172.next(ctx) {
                                        if let &InstructionData::UnaryImm {
                                            opcode: ref v176,
                                            imm: v177,
                                        } = &v173.1 {
                                            if let &Opcode::Iconst = v176 {
                                                let v171 = C::u64_from_imm64(ctx, v170);
                                                let v178 = C::u64_from_imm64(ctx, v177);
                                                let v179 = C::checked_add_with_type(ctx, v166.0, v171, v178);
                                                if let Some(v180) = v179 {
                                                    if v166.0 == v173.0 {
                                                        let v181 = constructor_iconst_u(ctx, v166.0, v180);
                                                        let v182 = &constructor_value_to_skeleton_inst_simplification(ctx, v181);
                                                        // Rule at src/opts/skeleton.isle line 12.
                                                        returns.extend(Some(v182.clone()));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            _ => {}
                        }
                    }
                }
            }
            _ => {}
        }
    }
}

// Generated as internal constructor for term iconst_s.
pub fn constructor_iconst_s<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: i64,
) -> Value {
    if arg0 == I128 {
        let v11 = constructor_iconst_s(ctx, I64, arg1);
        let v12 = constructor_sextend(ctx, I128, v11);
        // Rule at src/prelude_opt.isle line 143.
        return v12;
    }
    let v2 = C::i64_cast_unsigned(ctx, arg1);
    let v3 = C::ty_umax(ctx, arg0);
    let v4 = C::u64_and(ctx, v2, v3);
    let v5 = C::i64_sextend_u64(ctx, arg0, v4);
    let v6 = C::i64_eq(ctx, arg1, v5);
    if v6 == true {
        let v7 = C::imm64(ctx, v4);
        let v8 = constructor_iconst(ctx, arg0, v7);
        // Rule at src/prelude_opt.isle line 137.
        return v8;
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "iconst_s", "src/prelude_opt.isle line 135")
}

// Generated as internal constructor for term iconst_u.
pub fn constructor_iconst_u<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: u64,
) -> Value {
    if arg0 == I128 {
        let v8 = constructor_iconst_u(ctx, I64, arg1);
        let v9 = constructor_uextend(ctx, I128, v8);
        // Rule at src/prelude_opt.isle line 158.
        return v9;
    }
    let v2 = C::ty_umax(ctx, arg0);
    let v3 = C::u64_lt_eq(ctx, arg1, v2);
    if v3 == true {
        let v4 = C::imm64(ctx, arg1);
        let v5 = constructor_iconst(ctx, arg0, v4);
        // Rule at src/prelude_opt.isle line 155.
        return v5;
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "iconst_u", "src/prelude_opt.isle line 153")
}

// Generated as internal constructor for term uextend_maybe.
pub fn constructor_uextend_maybe<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
) -> Value {
    let v3 = C::value_type(ctx, arg1);
    if arg0 == v3 {
        // Rule at src/prelude_opt.isle line 178.
        return arg1;
    }
    let v2 = constructor_uextend(ctx, arg0, arg1);
    // Rule at src/prelude_opt.isle line 177.
    return v2;
}

// Generated as internal constructor for term sextend_maybe.
pub fn constructor_sextend_maybe<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
) -> Value {
    let v3 = C::value_type(ctx, arg1);
    if arg0 == v3 {
        // Rule at src/prelude_opt.isle line 184.
        return arg1;
    }
    let v2 = constructor_sextend(ctx, arg0, arg1);
    // Rule at src/prelude_opt.isle line 183.
    return v2;
}

// Generated as internal constructor for term eq.
pub fn constructor_eq<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
) -> Value {
    let v4 = constructor_icmp(ctx, arg0, &IntCC::Equal, arg1, arg2);
    // Rule at src/prelude_opt.isle line 38.
    return v4;
}

// Generated as internal constructor for term ne.
pub fn constructor_ne<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
) -> Value {
    let v4 = constructor_icmp(ctx, arg0, &IntCC::NotEqual, arg1, arg2);
    // Rule at src/prelude_opt.isle line 39.
    return v4;
}

// Generated as internal constructor for term ult.
pub fn constructor_ult<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
) -> Value {
    let v4 = constructor_icmp(ctx, arg0, &IntCC::UnsignedLessThan, arg1, arg2);
    // Rule at src/prelude_opt.isle line 40.
    return v4;
}

// Generated as internal constructor for term ule.
pub fn constructor_ule<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
) -> Value {
    let v4 = constructor_icmp(ctx, arg0, &IntCC::UnsignedLessThanOrEqual, arg1, arg2);
    // Rule at src/prelude_opt.isle line 41.
    return v4;
}

// Generated as internal constructor for term ugt.
pub fn constructor_ugt<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
) -> Value {
    let v4 = constructor_icmp(ctx, arg0, &IntCC::UnsignedGreaterThan, arg1, arg2);
    // Rule at src/prelude_opt.isle line 42.
    return v4;
}

// Generated as internal constructor for term uge.
pub fn constructor_uge<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
) -> Value {
    let v4 = constructor_icmp(ctx, arg0, &IntCC::UnsignedGreaterThanOrEqual, arg1, arg2);
    // Rule at src/prelude_opt.isle line 43.
    return v4;
}

// Generated as internal constructor for term slt.
pub fn constructor_slt<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
) -> Value {
    let v4 = constructor_icmp(ctx, arg0, &IntCC::SignedLessThan, arg1, arg2);
    // Rule at src/prelude_opt.isle line 44.
    return v4;
}

// Generated as internal constructor for term sle.
pub fn constructor_sle<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
) -> Value {
    let v4 = constructor_icmp(ctx, arg0, &IntCC::SignedLessThanOrEqual, arg1, arg2);
    // Rule at src/prelude_opt.isle line 45.
    return v4;
}

// Generated as internal constructor for term sgt.
pub fn constructor_sgt<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
) -> Value {
    let v4 = constructor_icmp(ctx, arg0, &IntCC::SignedGreaterThan, arg1, arg2);
    // Rule at src/prelude_opt.isle line 46.
    return v4;
}

// Generated as internal constructor for term sge.
pub fn constructor_sge<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
) -> Value {
    let v4 = constructor_icmp(ctx, arg0, &IntCC::SignedGreaterThanOrEqual, arg1, arg2);
    // Rule at src/prelude_opt.isle line 47.
    return v4;
}

// Generated as internal constructor for term i64_is_negative_power_of_two.
pub fn constructor_i64_is_negative_power_of_two<C: Context>(
    ctx: &mut C,
    arg0: i64,
) -> bool {
    let v1 = C::i64_wrapping_neg(ctx, arg0);
    let v2 = C::i64_cast_unsigned(ctx, v1);
    let v3 = C::u64_is_power_of_two(ctx, v2);
    // Rule at src/prelude_opt.isle line 221.
    return v3;
}

// Generated as internal constructor for term i64_is_any_sign_power_of_two.
pub fn constructor_i64_is_any_sign_power_of_two<C: Context>(
    ctx: &mut C,
    arg0: i64,
) -> bool {
    let v1 = C::i64_cast_unsigned(ctx, arg0);
    let v2 = C::u64_is_power_of_two(ctx, v1);
    if v2 == true {
        let v3 = true;
        // Rule at src/prelude_opt.isle line 225.
        return v3;
    }
    let v4 = constructor_i64_is_negative_power_of_two(ctx, arg0);
    if v4 == true {
        let v3 = true;
        // Rule at src/prelude_opt.isle line 228.
        return v3;
    }
    let v5 = false;
    // Rule at src/prelude_opt.isle line 231.
    return v5;
}

// Generated as internal constructor for term apply_div_const_magic_u32.
pub fn constructor_apply_div_const_magic_u32<C: Context>(
    ctx: &mut C,
    arg0: &Opcode,
    arg1: Value,
    arg2: u32,
) -> Value {
    let v3 = &C::div_const_magic_u32(ctx, arg2);
    let v4 = constructor_apply_div_const_magic_u32_inner(ctx, arg0, arg1, arg2, v3);
    // Rule at src/prelude_opt.isle line 260.
    return v4;
}

// Generated as internal constructor for term apply_div_const_magic_u32_inner.
pub fn constructor_apply_div_const_magic_u32_inner<C: Context>(
    ctx: &mut C,
    arg0: &Opcode,
    arg1: Value,
    arg2: u32,
    arg3: &DivConstMagicU32,
) -> Value {
    if let &DivConstMagicU32::U32 {
        mul_by: v4,
        do_add: v5,
        shift_by: v6,
    } = arg3 {
        let v8 = C::u32_into_u64(ctx, v4);
        let v9 = constructor_iconst_u(ctx, I32, v8);
        let v10 = constructor_umulhi(ctx, I32, arg1, v9);
        let v11 = constructor_apply_div_const_magic_u32_maybe_add(ctx, arg0, arg1, arg2, arg3, v10);
        // Rule at src/prelude_opt.isle line 265.
        return v11;
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "apply_div_const_magic_u32_inner", "src/prelude_opt.isle line 264")
}

// Generated as internal constructor for term apply_div_const_magic_u32_maybe_add.
pub fn constructor_apply_div_const_magic_u32_maybe_add<C: Context>(
    ctx: &mut C,
    arg0: &Opcode,
    arg1: Value,
    arg2: u32,
    arg3: &DivConstMagicU32,
    arg4: Value,
) -> Value {
    if let &DivConstMagicU32::U32 {
        mul_by: v4,
        do_add: v5,
        shift_by: v6,
    } = arg3 {
        match v5 {
            false => {
                let v15 = C::u32_into_u64(ctx, v6);
                let v16 = constructor_iconst_u(ctx, I32, v15);
                let v17 = constructor_ushr(ctx, I32, arg4, v16);
                let v18 = constructor_apply_div_const_magic_u32_finish(ctx, arg0, arg1, arg2, v17);
                // Rule at src/prelude_opt.isle line 290.
                return v18;
            }
            true => {
                let v9 = constructor_isub(ctx, I32, arg1, arg4);
                let v11 = constructor_iconst_u(ctx, I32, 0x1_u64);
                let v12 = constructor_ushr(ctx, I32, v9, v11);
                let v13 = constructor_iadd(ctx, I32, arg4, v12);
                let v14 = constructor_apply_div_const_magic_u32_maybe_shift(ctx, arg0, arg1, arg2, arg3, v13);
                // Rule at src/prelude_opt.isle line 281.
                return v14;
            }
            _ => {}
        }
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "apply_div_const_magic_u32_maybe_add", "src/prelude_opt.isle line 280")
}

// Generated as internal constructor for term apply_div_const_magic_u32_maybe_shift.
pub fn constructor_apply_div_const_magic_u32_maybe_shift<C: Context>(
    ctx: &mut C,
    arg0: &Opcode,
    arg1: Value,
    arg2: u32,
    arg3: &DivConstMagicU32,
    arg4: Value,
) -> Value {
    if let &DivConstMagicU32::U32 {
        mul_by: v4,
        do_add: v5,
        shift_by: v6,
    } = arg3 {
        if v6 == 0x0_u32 {
            let v8 = constructor_apply_div_const_magic_u32_finish(ctx, arg0, arg1, arg2, arg4);
            // Rule at src/prelude_opt.isle line 304.
            return v8;
        }
        let v9 = C::u32_matches_non_zero(ctx, v6);
        if let Some(v10) = v9 {
            if v10 == true {
                let v13 = C::u32_sub(ctx, v6, 0x1_u32);
                let v14 = C::u32_into_u64(ctx, v13);
                let v15 = constructor_iconst_u(ctx, I32, v14);
                let v16 = constructor_ushr(ctx, I32, arg4, v15);
                let v17 = constructor_apply_div_const_magic_u32_finish(ctx, arg0, arg1, arg2, v16);
                // Rule at src/prelude_opt.isle line 310.
                return v17;
            }
        }
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "apply_div_const_magic_u32_maybe_shift", "src/prelude_opt.isle line 303")
}

// Generated as internal constructor for term apply_div_const_magic_u32_finish.
pub fn constructor_apply_div_const_magic_u32_finish<C: Context>(
    ctx: &mut C,
    arg0: &Opcode,
    arg1: Value,
    arg2: u32,
    arg3: Value,
) -> Value {
    match arg0 {
        &Opcode::Udiv => {
            // Rule at src/prelude_opt.isle line 330.
            return arg3;
        }
        &Opcode::Urem => {
            let v5 = C::u32_into_u64(ctx, arg2);
            let v6 = constructor_iconst_u(ctx, I32, v5);
            let v7 = constructor_imul(ctx, I32, arg3, v6);
            let v8 = constructor_isub(ctx, I32, arg1, v7);
            // Rule at src/prelude_opt.isle line 331.
            return v8;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "apply_div_const_magic_u32_finish", "src/prelude_opt.isle line 329")
}

// Generated as internal constructor for term apply_div_const_magic_u64.
pub fn constructor_apply_div_const_magic_u64<C: Context>(
    ctx: &mut C,
    arg0: &Opcode,
    arg1: Value,
    arg2: u64,
) -> Value {
    let v3 = &C::div_const_magic_u64(ctx, arg2);
    let v4 = constructor_apply_div_const_magic_u64_inner(ctx, arg0, arg1, arg2, v3);
    // Rule at src/prelude_opt.isle line 337.
    return v4;
}

// Generated as internal constructor for term apply_div_const_magic_u64_inner.
pub fn constructor_apply_div_const_magic_u64_inner<C: Context>(
    ctx: &mut C,
    arg0: &Opcode,
    arg1: Value,
    arg2: u64,
    arg3: &DivConstMagicU64,
) -> Value {
    if let &DivConstMagicU64::U64 {
        mul_by: v4,
        do_add: v5,
        shift_by: v6,
    } = arg3 {
        let v8 = constructor_iconst_u(ctx, I64, v4);
        let v9 = constructor_umulhi(ctx, I64, arg1, v8);
        let v10 = constructor_apply_div_const_magic_u64_maybe_add(ctx, arg0, arg1, arg2, arg3, v9);
        // Rule at src/prelude_opt.isle line 342.
        return v10;
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "apply_div_const_magic_u64_inner", "src/prelude_opt.isle line 341")
}

// Generated as internal constructor for term apply_div_const_magic_u64_maybe_add.
pub fn constructor_apply_div_const_magic_u64_maybe_add<C: Context>(
    ctx: &mut C,
    arg0: &Opcode,
    arg1: Value,
    arg2: u64,
    arg3: &DivConstMagicU64,
    arg4: Value,
) -> Value {
    if let &DivConstMagicU64::U64 {
        mul_by: v4,
        do_add: v5,
        shift_by: v6,
    } = arg3 {
        match v5 {
            false => {
                let v15 = C::u32_into_u64(ctx, v6);
                let v16 = constructor_iconst_u(ctx, I64, v15);
                let v17 = constructor_ushr(ctx, I64, arg4, v16);
                let v18 = constructor_apply_div_const_magic_u64_finish(ctx, arg0, arg1, arg2, v17);
                // Rule at src/prelude_opt.isle line 367.
                return v18;
            }
            true => {
                let v9 = constructor_isub(ctx, I64, arg1, arg4);
                let v11 = constructor_iconst_u(ctx, I64, 0x1_u64);
                let v12 = constructor_ushr(ctx, I64, v9, v11);
                let v13 = constructor_iadd(ctx, I64, arg4, v12);
                let v14 = constructor_apply_div_const_magic_u64_maybe_shift(ctx, arg0, arg1, arg2, arg3, v13);
                // Rule at src/prelude_opt.isle line 358.
                return v14;
            }
            _ => {}
        }
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "apply_div_const_magic_u64_maybe_add", "src/prelude_opt.isle line 357")
}

// Generated as internal constructor for term apply_div_const_magic_u64_maybe_shift.
pub fn constructor_apply_div_const_magic_u64_maybe_shift<C: Context>(
    ctx: &mut C,
    arg0: &Opcode,
    arg1: Value,
    arg2: u64,
    arg3: &DivConstMagicU64,
    arg4: Value,
) -> Value {
    if let &DivConstMagicU64::U64 {
        mul_by: v4,
        do_add: v5,
        shift_by: v6,
    } = arg3 {
        if v6 == 0x0_u32 {
            let v8 = constructor_apply_div_const_magic_u64_finish(ctx, arg0, arg1, arg2, arg4);
            // Rule at src/prelude_opt.isle line 381.
            return v8;
        }
        let v9 = C::u32_matches_non_zero(ctx, v6);
        if let Some(v10) = v9 {
            if v10 == true {
                let v12 = C::u32_into_u64(ctx, v6);
                let v14 = C::u64_sub(ctx, v12, 0x1_u64);
                let v15 = constructor_iconst_u(ctx, I64, v14);
                let v16 = constructor_ushr(ctx, I64, arg4, v15);
                let v17 = constructor_apply_div_const_magic_u64_finish(ctx, arg0, arg1, arg2, v16);
                // Rule at src/prelude_opt.isle line 387.
                return v17;
            }
        }
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "apply_div_const_magic_u64_maybe_shift", "src/prelude_opt.isle line 380")
}

// Generated as internal constructor for term apply_div_const_magic_u64_finish.
pub fn constructor_apply_div_const_magic_u64_finish<C: Context>(
    ctx: &mut C,
    arg0: &Opcode,
    arg1: Value,
    arg2: u64,
    arg3: Value,
) -> Value {
    match arg0 {
        &Opcode::Udiv => {
            // Rule at src/prelude_opt.isle line 407.
            return arg3;
        }
        &Opcode::Urem => {
            let v5 = constructor_iconst_u(ctx, I64, arg2);
            let v6 = constructor_imul(ctx, I64, arg3, v5);
            let v7 = constructor_isub(ctx, I64, arg1, v6);
            // Rule at src/prelude_opt.isle line 408.
            return v7;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "apply_div_const_magic_u64_finish", "src/prelude_opt.isle line 406")
}

// Generated as internal constructor for term apply_div_const_magic_s32.
pub fn constructor_apply_div_const_magic_s32<C: Context>(
    ctx: &mut C,
    arg0: &Opcode,
    arg1: Value,
    arg2: i32,
) -> Value {
    let v3 = &C::div_const_magic_s32(ctx, arg2);
    let v4 = constructor_apply_div_const_magic_s32_inner(ctx, arg0, arg1, arg2, v3);
    // Rule at src/prelude_opt.isle line 415.
    return v4;
}

// Generated as internal constructor for term apply_div_const_magic_s32_inner.
pub fn constructor_apply_div_const_magic_s32_inner<C: Context>(
    ctx: &mut C,
    arg0: &Opcode,
    arg1: Value,
    arg2: i32,
    arg3: &DivConstMagicS32,
) -> Value {
    if let &DivConstMagicS32::S32 {
        mul_by: v4,
        shift_by: v5,
    } = arg3 {
        let v7 = C::i32_into_i64(ctx, v4);
        let v8 = constructor_iconst_s(ctx, I32, v7);
        let v9 = constructor_smulhi(ctx, I32, arg1, v8);
        let v10 = constructor_apply_div_const_magic_s32_add_sub(ctx, arg0, arg1, arg2, arg3, v9);
        // Rule at src/prelude_opt.isle line 421.
        return v10;
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "apply_div_const_magic_s32_inner", "src/prelude_opt.isle line 420")
}

// Generated as internal constructor for term apply_div_const_magic_s32_add_sub.
pub fn constructor_apply_div_const_magic_s32_add_sub<C: Context>(
    ctx: &mut C,
    arg0: &Opcode,
    arg1: Value,
    arg2: i32,
    arg3: &DivConstMagicS32,
    arg4: Value,
) -> Value {
    if let &DivConstMagicS32::S32 {
        mul_by: v4,
        shift_by: v5,
    } = arg3 {
        let v8 = C::i32_gt(ctx, arg2, 0_i32);
        if v8 == true {
            let v9 = C::i32_lt(ctx, v4, 0_i32);
            if v9 == true {
                let v11 = constructor_iadd(ctx, I32, arg4, arg1);
                let v12 = constructor_apply_div_const_magic_s32_shift(ctx, arg0, arg1, arg2, arg3, v11);
                // Rule at src/prelude_opt.isle line 437.
                return v12;
            }
        }
        let v13 = C::i32_lt(ctx, arg2, 0_i32);
        if v13 == true {
            let v14 = C::i32_gt(ctx, v4, 0_i32);
            if v14 == true {
                let v15 = constructor_isub(ctx, I32, arg4, arg1);
                let v16 = constructor_apply_div_const_magic_s32_shift(ctx, arg0, arg1, arg2, arg3, v15);
                // Rule at src/prelude_opt.isle line 446.
                return v16;
            }
        }
    }
    let v17 = constructor_apply_div_const_magic_s32_shift(ctx, arg0, arg1, arg2, arg3, arg4);
    // Rule at src/prelude_opt.isle line 455.
    return v17;
}

// Generated as internal constructor for term apply_div_const_magic_s32_shift.
pub fn constructor_apply_div_const_magic_s32_shift<C: Context>(
    ctx: &mut C,
    arg0: &Opcode,
    arg1: Value,
    arg2: i32,
    arg3: &DivConstMagicS32,
    arg4: Value,
) -> Value {
    if let &DivConstMagicS32::S32 {
        mul_by: v4,
        shift_by: v5,
    } = arg3 {
        let v8 = C::u32_into_i64(ctx, v5);
        let v9 = constructor_iconst_s(ctx, I32, v8);
        let v10 = constructor_sshr(ctx, I32, arg4, v9);
        let v12 = constructor_iconst_s(ctx, I32, 31_i64);
        let v13 = constructor_ushr(ctx, I32, v10, v12);
        let v14 = constructor_iadd(ctx, I32, v10, v13);
        let v15 = constructor_apply_div_const_magic_s32_finish(ctx, arg0, arg1, arg2, v14);
        // Rule at src/prelude_opt.isle line 466.
        return v15;
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "apply_div_const_magic_s32_shift", "src/prelude_opt.isle line 465")
}

// Generated as internal constructor for term apply_div_const_magic_s32_finish.
pub fn constructor_apply_div_const_magic_s32_finish<C: Context>(
    ctx: &mut C,
    arg0: &Opcode,
    arg1: Value,
    arg2: i32,
    arg3: Value,
) -> Value {
    match arg0 {
        &Opcode::Sdiv => {
            // Rule at src/prelude_opt.isle line 490.
            return arg3;
        }
        &Opcode::Srem => {
            let v5 = C::i32_into_i64(ctx, arg2);
            let v6 = constructor_iconst_s(ctx, I32, v5);
            let v7 = constructor_imul(ctx, I32, arg3, v6);
            let v8 = constructor_isub(ctx, I32, arg1, v7);
            // Rule at src/prelude_opt.isle line 487.
            return v8;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "apply_div_const_magic_s32_finish", "src/prelude_opt.isle line 486")
}

// Generated as internal constructor for term apply_div_const_magic_s64.
pub fn constructor_apply_div_const_magic_s64<C: Context>(
    ctx: &mut C,
    arg0: &Opcode,
    arg1: Value,
    arg2: i64,
) -> Value {
    let v3 = &C::div_const_magic_s64(ctx, arg2);
    let v4 = constructor_apply_div_const_magic_s64_inner(ctx, arg0, arg1, arg2, v3);
    // Rule at src/prelude_opt.isle line 496.
    return v4;
}

// Generated as internal constructor for term apply_div_const_magic_s64_inner.
pub fn constructor_apply_div_const_magic_s64_inner<C: Context>(
    ctx: &mut C,
    arg0: &Opcode,
    arg1: Value,
    arg2: i64,
    arg3: &DivConstMagicS64,
) -> Value {
    if let &DivConstMagicS64::S64 {
        mul_by: v4,
        shift_by: v5,
    } = arg3 {
        let v7 = constructor_iconst_s(ctx, I64, v4);
        let v8 = constructor_smulhi(ctx, I64, arg1, v7);
        let v9 = constructor_apply_div_const_magic_s64_add_sub(ctx, arg0, arg1, arg2, arg3, v8);
        // Rule at src/prelude_opt.isle line 502.
        return v9;
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "apply_div_const_magic_s64_inner", "src/prelude_opt.isle line 501")
}

// Generated as internal constructor for term apply_div_const_magic_s64_add_sub.
pub fn constructor_apply_div_const_magic_s64_add_sub<C: Context>(
    ctx: &mut C,
    arg0: &Opcode,
    arg1: Value,
    arg2: i64,
    arg3: &DivConstMagicS64,
    arg4: Value,
) -> Value {
    if let &DivConstMagicS64::S64 {
        mul_by: v4,
        shift_by: v5,
    } = arg3 {
        let v8 = C::i64_gt(ctx, arg2, 0_i64);
        if v8 == true {
            let v9 = C::i64_lt(ctx, v4, 0_i64);
            if v9 == true {
                let v11 = constructor_iadd(ctx, I64, arg4, arg1);
                let v12 = constructor_apply_div_const_magic_s64_shift(ctx, arg0, arg1, arg2, arg3, v11);
                // Rule at src/prelude_opt.isle line 518.
                return v12;
            }
        }
        let v13 = C::i64_lt(ctx, arg2, 0_i64);
        if v13 == true {
            let v14 = C::i64_gt(ctx, v4, 0_i64);
            if v14 == true {
                let v15 = constructor_isub(ctx, I64, arg4, arg1);
                let v16 = constructor_apply_div_const_magic_s64_shift(ctx, arg0, arg1, arg2, arg3, v15);
                // Rule at src/prelude_opt.isle line 527.
                return v16;
            }
        }
    }
    let v17 = constructor_apply_div_const_magic_s64_shift(ctx, arg0, arg1, arg2, arg3, arg4);
    // Rule at src/prelude_opt.isle line 536.
    return v17;
}

// Generated as internal constructor for term apply_div_const_magic_s64_shift.
pub fn constructor_apply_div_const_magic_s64_shift<C: Context>(
    ctx: &mut C,
    arg0: &Opcode,
    arg1: Value,
    arg2: i64,
    arg3: &DivConstMagicS64,
    arg4: Value,
) -> Value {
    if let &DivConstMagicS64::S64 {
        mul_by: v4,
        shift_by: v5,
    } = arg3 {
        let v8 = C::u32_into_i64(ctx, v5);
        let v9 = constructor_iconst_s(ctx, I64, v8);
        let v10 = constructor_sshr(ctx, I64, arg4, v9);
        let v12 = constructor_iconst_s(ctx, I64, 63_i64);
        let v13 = constructor_ushr(ctx, I64, v10, v12);
        let v14 = constructor_iadd(ctx, I64, v10, v13);
        let v15 = constructor_apply_div_const_magic_s64_finish(ctx, arg0, arg1, arg2, v14);
        // Rule at src/prelude_opt.isle line 547.
        return v15;
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "apply_div_const_magic_s64_shift", "src/prelude_opt.isle line 546")
}

// Generated as internal constructor for term apply_div_const_magic_s64_finish.
pub fn constructor_apply_div_const_magic_s64_finish<C: Context>(
    ctx: &mut C,
    arg0: &Opcode,
    arg1: Value,
    arg2: i64,
    arg3: Value,
) -> Value {
    match arg0 {
        &Opcode::Sdiv => {
            // Rule at src/prelude_opt.isle line 571.
            return arg3;
        }
        &Opcode::Srem => {
            let v5 = constructor_iconst_s(ctx, I64, arg2);
            let v6 = constructor_imul(ctx, I64, arg3, v5);
            let v7 = constructor_isub(ctx, I64, arg1, v6);
            // Rule at src/prelude_opt.isle line 568.
            return v7;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "apply_div_const_magic_s64_finish", "src/prelude_opt.isle line 567")
}

// Generated as internal constructor for term truthy.
pub fn constructor_truthy<C: Context>(
    ctx: &mut C,
    arg0: Value,
    returns: &mut (impl Extend<Value> + Length),
) -> () {
    let mut v1 = C::inst_data_value_etor_returns::default();
    C::inst_data_value_etor(ctx, arg0, &mut v1);
    let mut v1 = v1.into_context_iter();
    while let Some(v2) = v1.next(ctx) {
        match &v2.1 {
            &InstructionData::Binary {
                opcode: ref v7,
                args: ref v8,
            } => {
                match v7 {
                    &Opcode::Rotl => {
                        let v9 = C::unpack_value_array_2(ctx, v8);
                        // Rule at src/opts/bitops.isle line 103.
                        returns.extend(Some(v9.0));
                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                    }
                    &Opcode::Rotr => {
                        let v9 = C::unpack_value_array_2(ctx, v8);
                        // Rule at src/opts/bitops.isle line 104.
                        returns.extend(Some(v9.0));
                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                    }
                    _ => {}
                }
            }
            &InstructionData::IntCompare {
                opcode: ref v34,
                args: ref v35,
                cond: ref v36,
            } => {
                if let &Opcode::Icmp = v34 {
                    if let &IntCC::NotEqual = v36 {
                        let v37 = C::unpack_value_array_2(ctx, v35);
                        let mut v40 = C::inst_data_value_etor_returns::default();
                        C::inst_data_value_etor(ctx, v37.1, &mut v40);
                        let mut v40 = v40.into_context_iter();
                        while let Some(v41) = v40.next(ctx) {
                            if let &InstructionData::UnaryImm {
                                opcode: ref v44,
                                imm: v45,
                            } = &v41.1 {
                                if let &Opcode::Iconst = v44 {
                                    let v46 = C::u64_from_imm64(ctx, v45);
                                    if v46 == 0x0_u64 {
                                        // Rule at src/opts/bitops.isle line 107.
                                        returns.extend(Some(v37.0));
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                    }
                                }
                            }
                        }
                    }
                }
            }
            &InstructionData::Ternary {
                opcode: ref v12,
                args: ref v13,
            } => {
                if let &Opcode::Select = v12 {
                    let v14 = C::unpack_value_array_3(ctx, v13);
                    let mut v18 = C::inst_data_value_etor_returns::default();
                    C::inst_data_value_etor(ctx, v14.1, &mut v18);
                    let mut v18 = v18.into_context_iter();
                    while let Some(v19) = v18.next(ctx) {
                        if let &InstructionData::UnaryImm {
                            opcode: ref v22,
                            imm: v23,
                        } = &v19.1 {
                            if let &Opcode::Iconst = v22 {
                                let v24 = C::u64_from_imm64(ctx, v23);
                                let v25 = C::u64_matches_non_zero(ctx, v24);
                                if let Some(v26) = v25 {
                                    if v26 == true {
                                        let mut v27 = C::inst_data_value_etor_returns::default();
                                        C::inst_data_value_etor(ctx, v14.2, &mut v27);
                                        let mut v27 = v27.into_context_iter();
                                        while let Some(v28) = v27.next(ctx) {
                                            if let &InstructionData::UnaryImm {
                                                opcode: ref v31,
                                                imm: v32,
                                            } = &v28.1 {
                                                if let &Opcode::Iconst = v31 {
                                                    let v33 = C::u64_from_imm64(ctx, v32);
                                                    if v33 == 0x0_u64 {
                                                        // Rule at src/opts/bitops.isle line 105.
                                                        returns.extend(Some(v14.0));
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
            &InstructionData::Unary {
                opcode: ref v5,
                arg: v6,
            } => {
                match v5 {
                    &Opcode::Ineg => {
                        // Rule at src/opts/bitops.isle line 99.
                        returns.extend(Some(v6));
                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                    }
                    &Opcode::Bitrev => {
                        // Rule at src/opts/bitops.isle line 101.
                        returns.extend(Some(v6));
                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                    }
                    &Opcode::Bswap => {
                        // Rule at src/opts/bitops.isle line 100.
                        returns.extend(Some(v6));
                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                    }
                    &Opcode::Popcnt => {
                        // Rule at src/opts/bitops.isle line 102.
                        returns.extend(Some(v6));
                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                    }
                    &Opcode::Bmask => {
                        // Rule at src/opts/bitops.isle line 98.
                        returns.extend(Some(v6));
                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                    }
                    &Opcode::Uextend => {
                        // Rule at src/opts/bitops.isle line 97.
                        returns.extend(Some(v6));
                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                    }
                    &Opcode::Sextend => {
                        // Rule at src/opts/bitops.isle line 96.
                        returns.extend(Some(v6));
                        if returns.len() >= MAX_ISLE_RETURNS { return; }
                    }
                    _ => {}
                }
            }
            _ => {}
        }
    }
}

// Generated as internal constructor for term splat8.
pub fn constructor_splat8<C: Context>(
    ctx: &mut C,
    arg0: u64,
) -> Constant {
    let v2 = C::u64_shl(ctx, arg0, 0x8_u32);
    let v3 = C::u64_or(ctx, arg0, v2);
    let v4 = constructor_splat16(ctx, v3);
    // Rule at src/opts/cprop.isle line 240.
    return v4;
}

// Generated as internal constructor for term splat16.
pub fn constructor_splat16<C: Context>(
    ctx: &mut C,
    arg0: u64,
) -> Constant {
    let v2 = C::u64_shl(ctx, arg0, 0x10_u32);
    let v3 = C::u64_or(ctx, arg0, v2);
    let v4 = constructor_splat32(ctx, v3);
    // Rule at src/opts/cprop.isle line 242.
    return v4;
}

// Generated as internal constructor for term splat32.
pub fn constructor_splat32<C: Context>(
    ctx: &mut C,
    arg0: u64,
) -> Constant {
    let v2 = C::u64_shl(ctx, arg0, 0x20_u32);
    let v3 = C::u64_or(ctx, arg0, v2);
    let v4 = C::splat64(ctx, v3);
    // Rule at src/opts/cprop.isle line 244.
    return v4;
}

// Generated as internal constructor for term intcc_comparable.
pub fn constructor_intcc_comparable<C: Context>(
    ctx: &mut C,
    arg0: &IntCC,
    arg1: &IntCC,
) -> Option<bool> {
    let v2 = constructor_intcc_class(ctx, arg0);
    let v3 = constructor_intcc_class(ctx, arg1);
    let v4 = C::u64_and(ctx, v2, v3);
    let v5 = C::u64_matches_non_zero(ctx, v4);
    if let Some(v6) = v5 {
        if v6 == true {
            let v8 = C::u64_eq(ctx, 0x2_u64, v4);
            let v9 = Some(v8);
            // Rule at src/opts/icmp.isle line 211.
            return v9;
        }
    }
    None
}

// Generated as internal constructor for term decompose_intcc.
pub fn constructor_decompose_intcc<C: Context>(
    ctx: &mut C,
    arg0: &IntCC,
) -> u64 {
    match arg0 {
        &IntCC::Equal => {
            // Rule at src/opts/icmp.isle line 216.
            return 0x1_u64;
        }
        &IntCC::NotEqual => {
            // Rule at src/opts/icmp.isle line 225.
            return 0x6_u64;
        }
        &IntCC::SignedGreaterThan => {
            // Rule at src/opts/icmp.isle line 222.
            return 0x4_u64;
        }
        &IntCC::SignedGreaterThanOrEqual => {
            // Rule at src/opts/icmp.isle line 224.
            return 0x5_u64;
        }
        &IntCC::SignedLessThan => {
            // Rule at src/opts/icmp.isle line 218.
            return 0x2_u64;
        }
        &IntCC::SignedLessThanOrEqual => {
            // Rule at src/opts/icmp.isle line 220.
            return 0x3_u64;
        }
        &IntCC::UnsignedGreaterThan => {
            // Rule at src/opts/icmp.isle line 221.
            return 0x4_u64;
        }
        &IntCC::UnsignedGreaterThanOrEqual => {
            // Rule at src/opts/icmp.isle line 223.
            return 0x5_u64;
        }
        &IntCC::UnsignedLessThan => {
            // Rule at src/opts/icmp.isle line 217.
            return 0x2_u64;
        }
        &IntCC::UnsignedLessThanOrEqual => {
            // Rule at src/opts/icmp.isle line 219.
            return 0x3_u64;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "decompose_intcc", "src/opts/icmp.isle line 215")
}

// Generated as internal constructor for term compose_icmp.
pub fn constructor_compose_icmp<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: u64,
    arg2: bool,
    arg3: Value,
    arg4: Value,
) -> Value {
    match arg1 {
        0x0_u64 => {
            let v6 = constructor_iconst_u(ctx, arg0, 0x0_u64);
            let v7 = C::subsume(ctx, v6);
            // Rule at src/opts/icmp.isle line 228.
            return v7;
        }
        0x1_u64 => {
            let v9 = constructor_icmp(ctx, arg0, &IntCC::Equal, arg3, arg4);
            // Rule at src/opts/icmp.isle line 229.
            return v9;
        }
        0x2_u64 => {
            match arg2 {
                false => {
                    let v11 = constructor_icmp(ctx, arg0, &IntCC::UnsignedLessThan, arg3, arg4);
                    // Rule at src/opts/icmp.isle line 230.
                    return v11;
                }
                true => {
                    let v13 = constructor_icmp(ctx, arg0, &IntCC::SignedLessThan, arg3, arg4);
                    // Rule at src/opts/icmp.isle line 231.
                    return v13;
                }
                _ => {}
            }
        }
        0x3_u64 => {
            match arg2 {
                false => {
                    let v15 = constructor_icmp(ctx, arg0, &IntCC::UnsignedLessThanOrEqual, arg3, arg4);
                    // Rule at src/opts/icmp.isle line 232.
                    return v15;
                }
                true => {
                    let v17 = constructor_icmp(ctx, arg0, &IntCC::SignedLessThanOrEqual, arg3, arg4);
                    // Rule at src/opts/icmp.isle line 233.
                    return v17;
                }
                _ => {}
            }
        }
        0x4_u64 => {
            match arg2 {
                false => {
                    let v19 = constructor_icmp(ctx, arg0, &IntCC::UnsignedGreaterThan, arg3, arg4);
                    // Rule at src/opts/icmp.isle line 234.
                    return v19;
                }
                true => {
                    let v21 = constructor_icmp(ctx, arg0, &IntCC::SignedGreaterThan, arg3, arg4);
                    // Rule at src/opts/icmp.isle line 235.
                    return v21;
                }
                _ => {}
            }
        }
        0x5_u64 => {
            match arg2 {
                false => {
                    let v23 = constructor_icmp(ctx, arg0, &IntCC::UnsignedGreaterThanOrEqual, arg3, arg4);
                    // Rule at src/opts/icmp.isle line 236.
                    return v23;
                }
                true => {
                    let v25 = constructor_icmp(ctx, arg0, &IntCC::SignedGreaterThanOrEqual, arg3, arg4);
                    // Rule at src/opts/icmp.isle line 237.
                    return v25;
                }
                _ => {}
            }
        }
        0x6_u64 => {
            let v27 = constructor_icmp(ctx, arg0, &IntCC::NotEqual, arg3, arg4);
            // Rule at src/opts/icmp.isle line 238.
            return v27;
        }
        0x7_u64 => {
            let v29 = constructor_iconst_u(ctx, arg0, 0x1_u64);
            let v30 = C::subsume(ctx, v29);
            // Rule at src/opts/icmp.isle line 239.
            return v30;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "compose_icmp", "src/opts/icmp.isle line 227")
}

// Generated as internal constructor for term intcc_class.
pub fn constructor_intcc_class<C: Context>(
    ctx: &mut C,
    arg0: &IntCC,
) -> u64 {
    match arg0 {
        &IntCC::Equal => {
            // Rule at src/opts/icmp.isle line 250.
            return 0x3_u64;
        }
        &IntCC::NotEqual => {
            // Rule at src/opts/icmp.isle line 251.
            return 0x3_u64;
        }
        &IntCC::SignedGreaterThan => {
            // Rule at src/opts/icmp.isle line 248.
            return 0x2_u64;
        }
        &IntCC::SignedGreaterThanOrEqual => {
            // Rule at src/opts/icmp.isle line 249.
            return 0x2_u64;
        }
        &IntCC::SignedLessThan => {
            // Rule at src/opts/icmp.isle line 246.
            return 0x2_u64;
        }
        &IntCC::SignedLessThanOrEqual => {
            // Rule at src/opts/icmp.isle line 247.
            return 0x2_u64;
        }
        &IntCC::UnsignedGreaterThan => {
            // Rule at src/opts/icmp.isle line 244.
            return 0x1_u64;
        }
        &IntCC::UnsignedGreaterThanOrEqual => {
            // Rule at src/opts/icmp.isle line 245.
            return 0x1_u64;
        }
        &IntCC::UnsignedLessThan => {
            // Rule at src/opts/icmp.isle line 242.
            return 0x1_u64;
        }
        &IntCC::UnsignedLessThanOrEqual => {
            // Rule at src/opts/icmp.isle line 243.
            return 0x1_u64;
        }
        _ => {}
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "intcc_class", "src/opts/icmp.isle line 241")
}

// Generated as internal constructor for term shift_amt_to_type.
pub fn constructor_shift_amt_to_type<C: Context>(
    ctx: &mut C,
    arg0: u64,
) -> Option<Type> {
    match arg0 {
        0x8_u64 => {
            let v2 = Some(I8);
            // Rule at src/opts/shifts.isle line 93.
            return v2;
        }
        0x10_u64 => {
            let v4 = Some(I16);
            // Rule at src/opts/shifts.isle line 94.
            return v4;
        }
        0x20_u64 => {
            let v6 = Some(I32);
            // Rule at src/opts/shifts.isle line 95.
            return v6;
        }
        _ => {}
    }
    None
}

// Generated as internal constructor for term iadd_uextend.
pub fn constructor_iadd_uextend<C: Context>(
    ctx: &mut C,
    arg0: Value,
    arg1: Value,
) -> Value {
    let v3 = C::value_type(ctx, arg1);
    let v6 = C::ty_bits_u64(ctx, v3);
    let v1 = C::value_type(ctx, arg0);
    let v5 = C::ty_bits_u64(ctx, v1);
    let v10 = C::u64_lt(ctx, v6, v5);
    if v10 == true {
        let v11 = constructor_uextend(ctx, v1, arg1);
        let v12 = constructor_iadd(ctx, v1, arg0, v11);
        // Rule at src/opts/shifts.isle line 214.
        return v12;
    }
    let v7 = C::u64_lt(ctx, v5, v6);
    if v7 == true {
        let v8 = constructor_uextend(ctx, v3, arg0);
        let v9 = constructor_iadd(ctx, v3, v8, arg1);
        // Rule at src/opts/shifts.isle line 211.
        return v9;
    }
    if v1 == v3 {
        let v4 = constructor_iadd(ctx, v1, arg0, arg1);
        // Rule at src/opts/shifts.isle line 209.
        return v4;
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "iadd_uextend", "src/opts/shifts.isle line 208")
}

// Generated as internal constructor for term isub_uextend.
pub fn constructor_isub_uextend<C: Context>(
    ctx: &mut C,
    arg0: Value,
    arg1: Value,
) -> Value {
    let v3 = C::value_type(ctx, arg1);
    let v6 = C::ty_bits_u64(ctx, v3);
    let v1 = C::value_type(ctx, arg0);
    let v5 = C::ty_bits_u64(ctx, v1);
    let v10 = C::u64_lt(ctx, v6, v5);
    if v10 == true {
        let v11 = constructor_uextend(ctx, v1, arg1);
        let v12 = constructor_isub(ctx, v1, arg0, v11);
        // Rule at src/opts/shifts.isle line 226.
        return v12;
    }
    let v7 = C::u64_lt(ctx, v5, v6);
    if v7 == true {
        let v8 = constructor_uextend(ctx, v3, arg0);
        let v9 = constructor_isub(ctx, v3, v8, arg1);
        // Rule at src/opts/shifts.isle line 223.
        return v9;
    }
    if v1 == v3 {
        let v4 = constructor_isub(ctx, v1, arg0, arg1);
        // Rule at src/opts/shifts.isle line 221.
        return v4;
    }
    unreachable!("no rule matched for term {} at {}; should it be partial?", "isub_uextend", "src/opts/shifts.isle line 220")
}

// Generated as internal constructor for term jump.
pub fn constructor_jump<C: Context>(
    ctx: &mut C,
    arg0: BlockCall,
) -> Inst {
    let v2 = InstructionData::Jump {
        opcode: Opcode::Jump,
        destination: arg0,
    };
    let v3 = C::make_skeleton_inst_ctor(ctx, &v2);
    // Rule at <OUT_DIR>/clif_opt.isle line 368.
    return v3;
}

// Generated as internal constructor for term brif.
pub fn constructor_brif<C: Context>(
    ctx: &mut C,
    arg0: Value,
    arg1: BlockCall,
    arg2: BlockCall,
) -> Inst {
    let v4 = &C::pack_block_array_2(ctx, arg1, arg2);
    let v5 = InstructionData::Brif {
        opcode: Opcode::Brif,
        arg: arg0,
        blocks: v4.clone(),
    };
    let v6 = C::make_skeleton_inst_ctor(ctx, &v5);
    // Rule at <OUT_DIR>/clif_opt.isle line 377.
    return v6;
}

// Generated as internal constructor for term br_table.
pub fn constructor_br_table<C: Context>(
    ctx: &mut C,
    arg0: Value,
    arg1: JumpTable,
) -> Inst {
    let v3 = InstructionData::BranchTable {
        opcode: Opcode::BrTable,
        arg: arg0,
        table: arg1,
    };
    let v4 = C::make_skeleton_inst_ctor(ctx, &v3);
    // Rule at <OUT_DIR>/clif_opt.isle line 386.
    return v4;
}

// Generated as internal constructor for term debugtrap.
pub fn constructor_debugtrap<C: Context>(
    ctx: &mut C,
) -> Inst {
    let v1 = InstructionData::NullAry {
        opcode: Opcode::Debugtrap,
    };
    let v2 = C::make_skeleton_inst_ctor(ctx, &v1);
    // Rule at <OUT_DIR>/clif_opt.isle line 395.
    return v2;
}

// Generated as internal constructor for term trap.
pub fn constructor_trap<C: Context>(
    ctx: &mut C,
    arg0: &TrapCode,
) -> Inst {
    let v2 = InstructionData::Trap {
        opcode: Opcode::Trap,
        code: arg0.clone(),
    };
    let v3 = C::make_skeleton_inst_ctor(ctx, &v2);
    // Rule at <OUT_DIR>/clif_opt.isle line 404.
    return v3;
}

// Generated as internal constructor for term trapz.
pub fn constructor_trapz<C: Context>(
    ctx: &mut C,
    arg0: Value,
    arg1: &TrapCode,
) -> Inst {
    let v3 = InstructionData::CondTrap {
        opcode: Opcode::Trapz,
        arg: arg0,
        code: arg1.clone(),
    };
    let v4 = C::make_skeleton_inst_ctor(ctx, &v3);
    // Rule at <OUT_DIR>/clif_opt.isle line 413.
    return v4;
}

// Generated as internal constructor for term trapnz.
pub fn constructor_trapnz<C: Context>(
    ctx: &mut C,
    arg0: Value,
    arg1: &TrapCode,
) -> Inst {
    let v3 = InstructionData::CondTrap {
        opcode: Opcode::Trapnz,
        arg: arg0,
        code: arg1.clone(),
    };
    let v4 = C::make_skeleton_inst_ctor(ctx, &v3);
    // Rule at <OUT_DIR>/clif_opt.isle line 422.
    return v4;
}

// Generated as internal constructor for term func_addr.
pub fn constructor_func_addr<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: FuncRef,
) -> Value {
    let v3 = InstructionData::FuncAddr {
        opcode: Opcode::FuncAddr,
        func_ref: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at <OUT_DIR>/clif_opt.isle line 431.
    return v4;
}

// Generated as internal constructor for term splat.
pub fn constructor_splat<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
) -> Value {
    let v3 = InstructionData::Unary {
        opcode: Opcode::Splat,
        arg: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at <OUT_DIR>/clif_opt.isle line 440.
    return v4;
}

// Generated as internal constructor for term swizzle.
pub fn constructor_swizzle<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
) -> Value {
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v5 = InstructionData::Binary {
        opcode: Opcode::Swizzle,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at <OUT_DIR>/clif_opt.isle line 449.
    return v6;
}

// Generated as internal constructor for term x86_pshufb.
pub fn constructor_x86_pshufb<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
) -> Value {
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v5 = InstructionData::Binary {
        opcode: Opcode::X86Pshufb,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at <OUT_DIR>/clif_opt.isle line 458.
    return v6;
}

// Generated as internal constructor for term insertlane.
pub fn constructor_insertlane<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
    arg3: Uimm8,
) -> Value {
    let v5 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v6 = InstructionData::TernaryImm8 {
        opcode: Opcode::Insertlane,
        args: v5.clone(),
        imm: arg3,
    };
    let v7 = C::make_inst_ctor(ctx, arg0, &v6);
    // Rule at <OUT_DIR>/clif_opt.isle line 467.
    return v7;
}

// Generated as internal constructor for term extractlane.
pub fn constructor_extractlane<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Uimm8,
) -> Value {
    let v4 = InstructionData::BinaryImm8 {
        opcode: Opcode::Extractlane,
        arg: arg1,
        imm: arg2,
    };
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);
    // Rule at <OUT_DIR>/clif_opt.isle line 476.
    return v5;
}

// Generated as internal constructor for term smin.
pub fn constructor_smin<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
) -> Value {
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v5 = InstructionData::Binary {
        opcode: Opcode::Smin,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at <OUT_DIR>/clif_opt.isle line 485.
    return v6;
}

// Generated as internal constructor for term umin.
pub fn constructor_umin<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
) -> Value {
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v5 = InstructionData::Binary {
        opcode: Opcode::Umin,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at <OUT_DIR>/clif_opt.isle line 494.
    return v6;
}

// Generated as internal constructor for term smax.
pub fn constructor_smax<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
) -> Value {
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v5 = InstructionData::Binary {
        opcode: Opcode::Smax,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at <OUT_DIR>/clif_opt.isle line 503.
    return v6;
}

// Generated as internal constructor for term umax.
pub fn constructor_umax<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
) -> Value {
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v5 = InstructionData::Binary {
        opcode: Opcode::Umax,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at <OUT_DIR>/clif_opt.isle line 512.
    return v6;
}

// Generated as internal constructor for term avg_round.
pub fn constructor_avg_round<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
) -> Value {
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v5 = InstructionData::Binary {
        opcode: Opcode::AvgRound,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at <OUT_DIR>/clif_opt.isle line 521.
    return v6;
}

// Generated as internal constructor for term uadd_sat.
pub fn constructor_uadd_sat<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
) -> Value {
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v5 = InstructionData::Binary {
        opcode: Opcode::UaddSat,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at <OUT_DIR>/clif_opt.isle line 530.
    return v6;
}

// Generated as internal constructor for term sadd_sat.
pub fn constructor_sadd_sat<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
) -> Value {
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v5 = InstructionData::Binary {
        opcode: Opcode::SaddSat,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at <OUT_DIR>/clif_opt.isle line 539.
    return v6;
}

// Generated as internal constructor for term usub_sat.
pub fn constructor_usub_sat<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
) -> Value {
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v5 = InstructionData::Binary {
        opcode: Opcode::UsubSat,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at <OUT_DIR>/clif_opt.isle line 548.
    return v6;
}

// Generated as internal constructor for term ssub_sat.
pub fn constructor_ssub_sat<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
) -> Value {
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v5 = InstructionData::Binary {
        opcode: Opcode::SsubSat,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at <OUT_DIR>/clif_opt.isle line 557.
    return v6;
}

// Generated as internal constructor for term load.
pub fn constructor_load<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: MemFlags,
    arg2: Value,
    arg3: Offset32,
) -> Value {
    let v5 = InstructionData::Load {
        opcode: Opcode::Load,
        arg: arg2,
        flags: arg1,
        offset: arg3,
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at <OUT_DIR>/clif_opt.isle line 566.
    return v6;
}

// Generated as internal constructor for term store.
pub fn constructor_store<C: Context>(
    ctx: &mut C,
    arg0: MemFlags,
    arg1: Value,
    arg2: Value,
    arg3: Offset32,
) -> Inst {
    let v5 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v6 = InstructionData::Store {
        opcode: Opcode::Store,
        args: v5.clone(),
        flags: arg0,
        offset: arg3,
    };
    let v7 = C::make_skeleton_inst_ctor(ctx, &v6);
    // Rule at <OUT_DIR>/clif_opt.isle line 575.
    return v7;
}

// Generated as internal constructor for term uload8.
pub fn constructor_uload8<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: MemFlags,
    arg2: Value,
    arg3: Offset32,
) -> Value {
    let v5 = InstructionData::Load {
        opcode: Opcode::Uload8,
        arg: arg2,
        flags: arg1,
        offset: arg3,
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at <OUT_DIR>/clif_opt.isle line 584.
    return v6;
}

// Generated as internal constructor for term sload8.
pub fn constructor_sload8<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: MemFlags,
    arg2: Value,
    arg3: Offset32,
) -> Value {
    let v5 = InstructionData::Load {
        opcode: Opcode::Sload8,
        arg: arg2,
        flags: arg1,
        offset: arg3,
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at <OUT_DIR>/clif_opt.isle line 593.
    return v6;
}

// Generated as internal constructor for term istore8.
pub fn constructor_istore8<C: Context>(
    ctx: &mut C,
    arg0: MemFlags,
    arg1: Value,
    arg2: Value,
    arg3: Offset32,
) -> Inst {
    let v5 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v6 = InstructionData::Store {
        opcode: Opcode::Istore8,
        args: v5.clone(),
        flags: arg0,
        offset: arg3,
    };
    let v7 = C::make_skeleton_inst_ctor(ctx, &v6);
    // Rule at <OUT_DIR>/clif_opt.isle line 602.
    return v7;
}

// Generated as internal constructor for term uload16.
pub fn constructor_uload16<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: MemFlags,
    arg2: Value,
    arg3: Offset32,
) -> Value {
    let v5 = InstructionData::Load {
        opcode: Opcode::Uload16,
        arg: arg2,
        flags: arg1,
        offset: arg3,
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at <OUT_DIR>/clif_opt.isle line 611.
    return v6;
}

// Generated as internal constructor for term sload16.
pub fn constructor_sload16<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: MemFlags,
    arg2: Value,
    arg3: Offset32,
) -> Value {
    let v5 = InstructionData::Load {
        opcode: Opcode::Sload16,
        arg: arg2,
        flags: arg1,
        offset: arg3,
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at <OUT_DIR>/clif_opt.isle line 620.
    return v6;
}

// Generated as internal constructor for term istore16.
pub fn constructor_istore16<C: Context>(
    ctx: &mut C,
    arg0: MemFlags,
    arg1: Value,
    arg2: Value,
    arg3: Offset32,
) -> Inst {
    let v5 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v6 = InstructionData::Store {
        opcode: Opcode::Istore16,
        args: v5.clone(),
        flags: arg0,
        offset: arg3,
    };
    let v7 = C::make_skeleton_inst_ctor(ctx, &v6);
    // Rule at <OUT_DIR>/clif_opt.isle line 629.
    return v7;
}

// Generated as internal constructor for term uload32.
pub fn constructor_uload32<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: MemFlags,
    arg2: Value,
    arg3: Offset32,
) -> Value {
    let v5 = InstructionData::Load {
        opcode: Opcode::Uload32,
        arg: arg2,
        flags: arg1,
        offset: arg3,
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at <OUT_DIR>/clif_opt.isle line 638.
    return v6;
}

// Generated as internal constructor for term sload32.
pub fn constructor_sload32<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: MemFlags,
    arg2: Value,
    arg3: Offset32,
) -> Value {
    let v5 = InstructionData::Load {
        opcode: Opcode::Sload32,
        arg: arg2,
        flags: arg1,
        offset: arg3,
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at <OUT_DIR>/clif_opt.isle line 647.
    return v6;
}

// Generated as internal constructor for term istore32.
pub fn constructor_istore32<C: Context>(
    ctx: &mut C,
    arg0: MemFlags,
    arg1: Value,
    arg2: Value,
    arg3: Offset32,
) -> Inst {
    let v5 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v6 = InstructionData::Store {
        opcode: Opcode::Istore32,
        args: v5.clone(),
        flags: arg0,
        offset: arg3,
    };
    let v7 = C::make_skeleton_inst_ctor(ctx, &v6);
    // Rule at <OUT_DIR>/clif_opt.isle line 656.
    return v7;
}

// Generated as internal constructor for term stack_switch.
pub fn constructor_stack_switch<C: Context>(
    ctx: &mut C,
    arg0: Value,
    arg1: Value,
    arg2: Value,
) -> Inst {
    let v4 = &C::value_array_3_ctor(ctx, arg0, arg1, arg2);
    let v5 = InstructionData::Ternary {
        opcode: Opcode::StackSwitch,
        args: v4.clone(),
    };
    let v6 = C::make_skeleton_inst_ctor(ctx, &v5);
    // Rule at <OUT_DIR>/clif_opt.isle line 665.
    return v6;
}

// Generated as internal constructor for term uload8x8.
pub fn constructor_uload8x8<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: MemFlags,
    arg2: Value,
    arg3: Offset32,
) -> Value {
    let v5 = InstructionData::Load {
        opcode: Opcode::Uload8x8,
        arg: arg2,
        flags: arg1,
        offset: arg3,
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at <OUT_DIR>/clif_opt.isle line 674.
    return v6;
}

// Generated as internal constructor for term sload8x8.
pub fn constructor_sload8x8<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: MemFlags,
    arg2: Value,
    arg3: Offset32,
) -> Value {
    let v5 = InstructionData::Load {
        opcode: Opcode::Sload8x8,
        arg: arg2,
        flags: arg1,
        offset: arg3,
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at <OUT_DIR>/clif_opt.isle line 683.
    return v6;
}

// Generated as internal constructor for term uload16x4.
pub fn constructor_uload16x4<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: MemFlags,
    arg2: Value,
    arg3: Offset32,
) -> Value {
    let v5 = InstructionData::Load {
        opcode: Opcode::Uload16x4,
        arg: arg2,
        flags: arg1,
        offset: arg3,
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at <OUT_DIR>/clif_opt.isle line 692.
    return v6;
}

// Generated as internal constructor for term sload16x4.
pub fn constructor_sload16x4<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: MemFlags,
    arg2: Value,
    arg3: Offset32,
) -> Value {
    let v5 = InstructionData::Load {
        opcode: Opcode::Sload16x4,
        arg: arg2,
        flags: arg1,
        offset: arg3,
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at <OUT_DIR>/clif_opt.isle line 701.
    return v6;
}

// Generated as internal constructor for term uload32x2.
pub fn constructor_uload32x2<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: MemFlags,
    arg2: Value,
    arg3: Offset32,
) -> Value {
    let v5 = InstructionData::Load {
        opcode: Opcode::Uload32x2,
        arg: arg2,
        flags: arg1,
        offset: arg3,
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at <OUT_DIR>/clif_opt.isle line 710.
    return v6;
}

// Generated as internal constructor for term sload32x2.
pub fn constructor_sload32x2<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: MemFlags,
    arg2: Value,
    arg3: Offset32,
) -> Value {
    let v5 = InstructionData::Load {
        opcode: Opcode::Sload32x2,
        arg: arg2,
        flags: arg1,
        offset: arg3,
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at <OUT_DIR>/clif_opt.isle line 719.
    return v6;
}

// Generated as internal constructor for term stack_load.
pub fn constructor_stack_load<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: StackSlot,
    arg2: Offset32,
) -> Value {
    let v4 = InstructionData::StackLoad {
        opcode: Opcode::StackLoad,
        stack_slot: arg1,
        offset: arg2,
    };
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);
    // Rule at <OUT_DIR>/clif_opt.isle line 728.
    return v5;
}

// Generated as internal constructor for term stack_store.
pub fn constructor_stack_store<C: Context>(
    ctx: &mut C,
    arg0: Value,
    arg1: StackSlot,
    arg2: Offset32,
) -> Inst {
    let v4 = InstructionData::StackStore {
        opcode: Opcode::StackStore,
        arg: arg0,
        stack_slot: arg1,
        offset: arg2,
    };
    let v5 = C::make_skeleton_inst_ctor(ctx, &v4);
    // Rule at <OUT_DIR>/clif_opt.isle line 737.
    return v5;
}

// Generated as internal constructor for term stack_addr.
pub fn constructor_stack_addr<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: StackSlot,
    arg2: Offset32,
) -> Value {
    let v4 = InstructionData::StackLoad {
        opcode: Opcode::StackAddr,
        stack_slot: arg1,
        offset: arg2,
    };
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);
    // Rule at <OUT_DIR>/clif_opt.isle line 746.
    return v5;
}

// Generated as internal constructor for term dynamic_stack_load.
pub fn constructor_dynamic_stack_load<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: DynamicStackSlot,
) -> Value {
    let v3 = InstructionData::DynamicStackLoad {
        opcode: Opcode::DynamicStackLoad,
        dynamic_stack_slot: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at <OUT_DIR>/clif_opt.isle line 755.
    return v4;
}

// Generated as internal constructor for term dynamic_stack_store.
pub fn constructor_dynamic_stack_store<C: Context>(
    ctx: &mut C,
    arg0: Value,
    arg1: DynamicStackSlot,
) -> Inst {
    let v3 = InstructionData::DynamicStackStore {
        opcode: Opcode::DynamicStackStore,
        arg: arg0,
        dynamic_stack_slot: arg1,
    };
    let v4 = C::make_skeleton_inst_ctor(ctx, &v3);
    // Rule at <OUT_DIR>/clif_opt.isle line 764.
    return v4;
}

// Generated as internal constructor for term dynamic_stack_addr.
pub fn constructor_dynamic_stack_addr<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: DynamicStackSlot,
) -> Value {
    let v3 = InstructionData::DynamicStackLoad {
        opcode: Opcode::DynamicStackAddr,
        dynamic_stack_slot: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at <OUT_DIR>/clif_opt.isle line 773.
    return v4;
}

// Generated as internal constructor for term global_value.
pub fn constructor_global_value<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: GlobalValue,
) -> Value {
    let v3 = InstructionData::UnaryGlobalValue {
        opcode: Opcode::GlobalValue,
        global_value: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at <OUT_DIR>/clif_opt.isle line 782.
    return v4;
}

// Generated as internal constructor for term symbol_value.
pub fn constructor_symbol_value<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: GlobalValue,
) -> Value {
    let v3 = InstructionData::UnaryGlobalValue {
        opcode: Opcode::SymbolValue,
        global_value: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at <OUT_DIR>/clif_opt.isle line 791.
    return v4;
}

// Generated as internal constructor for term tls_value.
pub fn constructor_tls_value<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: GlobalValue,
) -> Value {
    let v3 = InstructionData::UnaryGlobalValue {
        opcode: Opcode::TlsValue,
        global_value: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at <OUT_DIR>/clif_opt.isle line 800.
    return v4;
}

// Generated as internal constructor for term get_pinned_reg.
pub fn constructor_get_pinned_reg<C: Context>(
    ctx: &mut C,
) -> Inst {
    let v1 = InstructionData::NullAry {
        opcode: Opcode::GetPinnedReg,
    };
    let v2 = C::make_skeleton_inst_ctor(ctx, &v1);
    // Rule at <OUT_DIR>/clif_opt.isle line 809.
    return v2;
}

// Generated as internal constructor for term set_pinned_reg.
pub fn constructor_set_pinned_reg<C: Context>(
    ctx: &mut C,
    arg0: Value,
) -> Inst {
    let v2 = InstructionData::Unary {
        opcode: Opcode::SetPinnedReg,
        arg: arg0,
    };
    let v3 = C::make_skeleton_inst_ctor(ctx, &v2);
    // Rule at <OUT_DIR>/clif_opt.isle line 818.
    return v3;
}

// Generated as internal constructor for term get_frame_pointer.
pub fn constructor_get_frame_pointer<C: Context>(
    ctx: &mut C,
    arg0: Type,
) -> Value {
    let v2 = InstructionData::NullAry {
        opcode: Opcode::GetFramePointer,
    };
    let v3 = C::make_inst_ctor(ctx, arg0, &v2);
    // Rule at <OUT_DIR>/clif_opt.isle line 827.
    return v3;
}

// Generated as internal constructor for term get_stack_pointer.
pub fn constructor_get_stack_pointer<C: Context>(
    ctx: &mut C,
    arg0: Type,
) -> Value {
    let v2 = InstructionData::NullAry {
        opcode: Opcode::GetStackPointer,
    };
    let v3 = C::make_inst_ctor(ctx, arg0, &v2);
    // Rule at <OUT_DIR>/clif_opt.isle line 836.
    return v3;
}

// Generated as internal constructor for term get_return_address.
pub fn constructor_get_return_address<C: Context>(
    ctx: &mut C,
    arg0: Type,
) -> Value {
    let v2 = InstructionData::NullAry {
        opcode: Opcode::GetReturnAddress,
    };
    let v3 = C::make_inst_ctor(ctx, arg0, &v2);
    // Rule at <OUT_DIR>/clif_opt.isle line 845.
    return v3;
}

// Generated as internal constructor for term get_exception_handler_address.
pub fn constructor_get_exception_handler_address<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: &Block,
    arg2: Imm64,
) -> Value {
    let v4 = InstructionData::ExceptionHandlerAddress {
        opcode: Opcode::GetExceptionHandlerAddress,
        block: arg1.clone(),
        imm: arg2,
    };
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);
    // Rule at <OUT_DIR>/clif_opt.isle line 854.
    return v5;
}

// Generated as internal constructor for term iconst.
pub fn constructor_iconst<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Imm64,
) -> Value {
    let v3 = InstructionData::UnaryImm {
        opcode: Opcode::Iconst,
        imm: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at <OUT_DIR>/clif_opt.isle line 863.
    return v4;
}

// Generated as internal constructor for term f16const.
pub fn constructor_f16const<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Ieee16,
) -> Value {
    let v3 = InstructionData::UnaryIeee16 {
        opcode: Opcode::F16const,
        imm: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at <OUT_DIR>/clif_opt.isle line 872.
    return v4;
}

// Generated as internal constructor for term f32const.
pub fn constructor_f32const<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Ieee32,
) -> Value {
    let v3 = InstructionData::UnaryIeee32 {
        opcode: Opcode::F32const,
        imm: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at <OUT_DIR>/clif_opt.isle line 881.
    return v4;
}

// Generated as internal constructor for term f64const.
pub fn constructor_f64const<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Ieee64,
) -> Value {
    let v3 = InstructionData::UnaryIeee64 {
        opcode: Opcode::F64const,
        imm: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at <OUT_DIR>/clif_opt.isle line 890.
    return v4;
}

// Generated as internal constructor for term f128const.
pub fn constructor_f128const<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Constant,
) -> Value {
    let v3 = InstructionData::UnaryConst {
        opcode: Opcode::F128const,
        constant_handle: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at <OUT_DIR>/clif_opt.isle line 899.
    return v4;
}

// Generated as internal constructor for term vconst.
pub fn constructor_vconst<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Constant,
) -> Value {
    let v3 = InstructionData::UnaryConst {
        opcode: Opcode::Vconst,
        constant_handle: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at <OUT_DIR>/clif_opt.isle line 908.
    return v4;
}

// Generated as internal constructor for term shuffle.
pub fn constructor_shuffle<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
    arg3: Immediate,
) -> Value {
    let v5 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v6 = InstructionData::Shuffle {
        opcode: Opcode::Shuffle,
        args: v5.clone(),
        imm: arg3,
    };
    let v7 = C::make_inst_ctor(ctx, arg0, &v6);
    // Rule at <OUT_DIR>/clif_opt.isle line 917.
    return v7;
}

// Generated as internal constructor for term nop.
pub fn constructor_nop<C: Context>(
    ctx: &mut C,
) -> Inst {
    let v1 = InstructionData::NullAry {
        opcode: Opcode::Nop,
    };
    let v2 = C::make_skeleton_inst_ctor(ctx, &v1);
    // Rule at <OUT_DIR>/clif_opt.isle line 926.
    return v2;
}

// Generated as internal constructor for term select.
pub fn constructor_select<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
    arg3: Value,
) -> Value {
    let v5 = &C::value_array_3_ctor(ctx, arg1, arg2, arg3);
    let v6 = InstructionData::Ternary {
        opcode: Opcode::Select,
        args: v5.clone(),
    };
    let v7 = C::make_inst_ctor(ctx, arg0, &v6);
    // Rule at <OUT_DIR>/clif_opt.isle line 935.
    return v7;
}

// Generated as internal constructor for term select_spectre_guard.
pub fn constructor_select_spectre_guard<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
    arg3: Value,
) -> Value {
    let v5 = &C::value_array_3_ctor(ctx, arg1, arg2, arg3);
    let v6 = InstructionData::Ternary {
        opcode: Opcode::SelectSpectreGuard,
        args: v5.clone(),
    };
    let v7 = C::make_inst_ctor(ctx, arg0, &v6);
    // Rule at <OUT_DIR>/clif_opt.isle line 944.
    return v7;
}

// Generated as internal constructor for term bitselect.
pub fn constructor_bitselect<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
    arg3: Value,
) -> Value {
    let v5 = &C::value_array_3_ctor(ctx, arg1, arg2, arg3);
    let v6 = InstructionData::Ternary {
        opcode: Opcode::Bitselect,
        args: v5.clone(),
    };
    let v7 = C::make_inst_ctor(ctx, arg0, &v6);
    // Rule at <OUT_DIR>/clif_opt.isle line 953.
    return v7;
}

// Generated as internal constructor for term blendv.
pub fn constructor_blendv<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
    arg3: Value,
) -> Value {
    let v5 = &C::value_array_3_ctor(ctx, arg1, arg2, arg3);
    let v6 = InstructionData::Ternary {
        opcode: Opcode::Blendv,
        args: v5.clone(),
    };
    let v7 = C::make_inst_ctor(ctx, arg0, &v6);
    // Rule at <OUT_DIR>/clif_opt.isle line 962.
    return v7;
}

// Generated as internal constructor for term vany_true.
pub fn constructor_vany_true<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
) -> Value {
    let v3 = InstructionData::Unary {
        opcode: Opcode::VanyTrue,
        arg: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at <OUT_DIR>/clif_opt.isle line 971.
    return v4;
}

// Generated as internal constructor for term vall_true.
pub fn constructor_vall_true<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
) -> Value {
    let v3 = InstructionData::Unary {
        opcode: Opcode::VallTrue,
        arg: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at <OUT_DIR>/clif_opt.isle line 980.
    return v4;
}

// Generated as internal constructor for term vhigh_bits.
pub fn constructor_vhigh_bits<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
) -> Value {
    let v3 = InstructionData::Unary {
        opcode: Opcode::VhighBits,
        arg: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at <OUT_DIR>/clif_opt.isle line 989.
    return v4;
}

// Generated as internal constructor for term icmp.
pub fn constructor_icmp<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: &IntCC,
    arg2: Value,
    arg3: Value,
) -> Value {
    let v5 = &C::value_array_2_ctor(ctx, arg2, arg3);
    let v6 = InstructionData::IntCompare {
        opcode: Opcode::Icmp,
        args: v5.clone(),
        cond: arg1.clone(),
    };
    let v7 = C::make_inst_ctor(ctx, arg0, &v6);
    // Rule at <OUT_DIR>/clif_opt.isle line 998.
    return v7;
}

// Generated as internal constructor for term icmp_imm.
pub fn constructor_icmp_imm<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: &IntCC,
    arg2: Value,
    arg3: Imm64,
) -> Value {
    let v5 = InstructionData::IntCompareImm {
        opcode: Opcode::IcmpImm,
        arg: arg2,
        cond: arg1.clone(),
        imm: arg3,
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at <OUT_DIR>/clif_opt.isle line 1007.
    return v6;
}

// Generated as internal constructor for term iadd.
pub fn constructor_iadd<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
) -> Value {
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v5 = InstructionData::Binary {
        opcode: Opcode::Iadd,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at <OUT_DIR>/clif_opt.isle line 1016.
    return v6;
}

// Generated as internal constructor for term isub.
pub fn constructor_isub<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
) -> Value {
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v5 = InstructionData::Binary {
        opcode: Opcode::Isub,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at <OUT_DIR>/clif_opt.isle line 1025.
    return v6;
}

// Generated as internal constructor for term ineg.
pub fn constructor_ineg<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
) -> Value {
    let v3 = InstructionData::Unary {
        opcode: Opcode::Ineg,
        arg: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at <OUT_DIR>/clif_opt.isle line 1034.
    return v4;
}

// Generated as internal constructor for term iabs.
pub fn constructor_iabs<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
) -> Value {
    let v3 = InstructionData::Unary {
        opcode: Opcode::Iabs,
        arg: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at <OUT_DIR>/clif_opt.isle line 1043.
    return v4;
}

// Generated as internal constructor for term imul.
pub fn constructor_imul<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
) -> Value {
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v5 = InstructionData::Binary {
        opcode: Opcode::Imul,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at <OUT_DIR>/clif_opt.isle line 1052.
    return v6;
}

// Generated as internal constructor for term umulhi.
pub fn constructor_umulhi<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
) -> Value {
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v5 = InstructionData::Binary {
        opcode: Opcode::Umulhi,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at <OUT_DIR>/clif_opt.isle line 1061.
    return v6;
}

// Generated as internal constructor for term smulhi.
pub fn constructor_smulhi<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
) -> Value {
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v5 = InstructionData::Binary {
        opcode: Opcode::Smulhi,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at <OUT_DIR>/clif_opt.isle line 1070.
    return v6;
}

// Generated as internal constructor for term sqmul_round_sat.
pub fn constructor_sqmul_round_sat<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
) -> Value {
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v5 = InstructionData::Binary {
        opcode: Opcode::SqmulRoundSat,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at <OUT_DIR>/clif_opt.isle line 1079.
    return v6;
}

// Generated as internal constructor for term x86_pmulhrsw.
pub fn constructor_x86_pmulhrsw<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
) -> Value {
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v5 = InstructionData::Binary {
        opcode: Opcode::X86Pmulhrsw,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at <OUT_DIR>/clif_opt.isle line 1088.
    return v6;
}

// Generated as internal constructor for term udiv.
pub fn constructor_udiv<C: Context>(
    ctx: &mut C,
    arg0: Value,
    arg1: Value,
) -> Inst {
    let v3 = &C::value_array_2_ctor(ctx, arg0, arg1);
    let v4 = InstructionData::Binary {
        opcode: Opcode::Udiv,
        args: v3.clone(),
    };
    let v5 = C::make_skeleton_inst_ctor(ctx, &v4);
    // Rule at <OUT_DIR>/clif_opt.isle line 1097.
    return v5;
}

// Generated as internal constructor for term sdiv.
pub fn constructor_sdiv<C: Context>(
    ctx: &mut C,
    arg0: Value,
    arg1: Value,
) -> Inst {
    let v3 = &C::value_array_2_ctor(ctx, arg0, arg1);
    let v4 = InstructionData::Binary {
        opcode: Opcode::Sdiv,
        args: v3.clone(),
    };
    let v5 = C::make_skeleton_inst_ctor(ctx, &v4);
    // Rule at <OUT_DIR>/clif_opt.isle line 1106.
    return v5;
}

// Generated as internal constructor for term urem.
pub fn constructor_urem<C: Context>(
    ctx: &mut C,
    arg0: Value,
    arg1: Value,
) -> Inst {
    let v3 = &C::value_array_2_ctor(ctx, arg0, arg1);
    let v4 = InstructionData::Binary {
        opcode: Opcode::Urem,
        args: v3.clone(),
    };
    let v5 = C::make_skeleton_inst_ctor(ctx, &v4);
    // Rule at <OUT_DIR>/clif_opt.isle line 1115.
    return v5;
}

// Generated as internal constructor for term srem.
pub fn constructor_srem<C: Context>(
    ctx: &mut C,
    arg0: Value,
    arg1: Value,
) -> Inst {
    let v3 = &C::value_array_2_ctor(ctx, arg0, arg1);
    let v4 = InstructionData::Binary {
        opcode: Opcode::Srem,
        args: v3.clone(),
    };
    let v5 = C::make_skeleton_inst_ctor(ctx, &v4);
    // Rule at <OUT_DIR>/clif_opt.isle line 1124.
    return v5;
}

// Generated as internal constructor for term iadd_imm.
pub fn constructor_iadd_imm<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Imm64,
) -> Value {
    let v4 = InstructionData::BinaryImm64 {
        opcode: Opcode::IaddImm,
        arg: arg1,
        imm: arg2,
    };
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);
    // Rule at <OUT_DIR>/clif_opt.isle line 1133.
    return v5;
}

// Generated as internal constructor for term imul_imm.
pub fn constructor_imul_imm<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Imm64,
) -> Value {
    let v4 = InstructionData::BinaryImm64 {
        opcode: Opcode::ImulImm,
        arg: arg1,
        imm: arg2,
    };
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);
    // Rule at <OUT_DIR>/clif_opt.isle line 1142.
    return v5;
}

// Generated as internal constructor for term udiv_imm.
pub fn constructor_udiv_imm<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Imm64,
) -> Value {
    let v4 = InstructionData::BinaryImm64 {
        opcode: Opcode::UdivImm,
        arg: arg1,
        imm: arg2,
    };
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);
    // Rule at <OUT_DIR>/clif_opt.isle line 1151.
    return v5;
}

// Generated as internal constructor for term sdiv_imm.
pub fn constructor_sdiv_imm<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Imm64,
) -> Value {
    let v4 = InstructionData::BinaryImm64 {
        opcode: Opcode::SdivImm,
        arg: arg1,
        imm: arg2,
    };
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);
    // Rule at <OUT_DIR>/clif_opt.isle line 1160.
    return v5;
}

// Generated as internal constructor for term urem_imm.
pub fn constructor_urem_imm<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Imm64,
) -> Value {
    let v4 = InstructionData::BinaryImm64 {
        opcode: Opcode::UremImm,
        arg: arg1,
        imm: arg2,
    };
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);
    // Rule at <OUT_DIR>/clif_opt.isle line 1169.
    return v5;
}

// Generated as internal constructor for term srem_imm.
pub fn constructor_srem_imm<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Imm64,
) -> Value {
    let v4 = InstructionData::BinaryImm64 {
        opcode: Opcode::SremImm,
        arg: arg1,
        imm: arg2,
    };
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);
    // Rule at <OUT_DIR>/clif_opt.isle line 1178.
    return v5;
}

// Generated as internal constructor for term irsub_imm.
pub fn constructor_irsub_imm<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Imm64,
) -> Value {
    let v4 = InstructionData::BinaryImm64 {
        opcode: Opcode::IrsubImm,
        arg: arg1,
        imm: arg2,
    };
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);
    // Rule at <OUT_DIR>/clif_opt.isle line 1187.
    return v5;
}

// Generated as internal constructor for term sadd_overflow_cin.
pub fn constructor_sadd_overflow_cin<C: Context>(
    ctx: &mut C,
    arg0: Value,
    arg1: Value,
    arg2: Value,
) -> Inst {
    let v4 = &C::value_array_3_ctor(ctx, arg0, arg1, arg2);
    let v5 = InstructionData::Ternary {
        opcode: Opcode::SaddOverflowCin,
        args: v4.clone(),
    };
    let v6 = C::make_skeleton_inst_ctor(ctx, &v5);
    // Rule at <OUT_DIR>/clif_opt.isle line 1196.
    return v6;
}

// Generated as internal constructor for term uadd_overflow_cin.
pub fn constructor_uadd_overflow_cin<C: Context>(
    ctx: &mut C,
    arg0: Value,
    arg1: Value,
    arg2: Value,
) -> Inst {
    let v4 = &C::value_array_3_ctor(ctx, arg0, arg1, arg2);
    let v5 = InstructionData::Ternary {
        opcode: Opcode::UaddOverflowCin,
        args: v4.clone(),
    };
    let v6 = C::make_skeleton_inst_ctor(ctx, &v5);
    // Rule at <OUT_DIR>/clif_opt.isle line 1205.
    return v6;
}

// Generated as internal constructor for term uadd_overflow.
pub fn constructor_uadd_overflow<C: Context>(
    ctx: &mut C,
    arg0: Value,
    arg1: Value,
) -> Inst {
    let v3 = &C::value_array_2_ctor(ctx, arg0, arg1);
    let v4 = InstructionData::Binary {
        opcode: Opcode::UaddOverflow,
        args: v3.clone(),
    };
    let v5 = C::make_skeleton_inst_ctor(ctx, &v4);
    // Rule at <OUT_DIR>/clif_opt.isle line 1214.
    return v5;
}

// Generated as internal constructor for term sadd_overflow.
pub fn constructor_sadd_overflow<C: Context>(
    ctx: &mut C,
    arg0: Value,
    arg1: Value,
) -> Inst {
    let v3 = &C::value_array_2_ctor(ctx, arg0, arg1);
    let v4 = InstructionData::Binary {
        opcode: Opcode::SaddOverflow,
        args: v3.clone(),
    };
    let v5 = C::make_skeleton_inst_ctor(ctx, &v4);
    // Rule at <OUT_DIR>/clif_opt.isle line 1223.
    return v5;
}

// Generated as internal constructor for term usub_overflow.
pub fn constructor_usub_overflow<C: Context>(
    ctx: &mut C,
    arg0: Value,
    arg1: Value,
) -> Inst {
    let v3 = &C::value_array_2_ctor(ctx, arg0, arg1);
    let v4 = InstructionData::Binary {
        opcode: Opcode::UsubOverflow,
        args: v3.clone(),
    };
    let v5 = C::make_skeleton_inst_ctor(ctx, &v4);
    // Rule at <OUT_DIR>/clif_opt.isle line 1232.
    return v5;
}

// Generated as internal constructor for term ssub_overflow.
pub fn constructor_ssub_overflow<C: Context>(
    ctx: &mut C,
    arg0: Value,
    arg1: Value,
) -> Inst {
    let v3 = &C::value_array_2_ctor(ctx, arg0, arg1);
    let v4 = InstructionData::Binary {
        opcode: Opcode::SsubOverflow,
        args: v3.clone(),
    };
    let v5 = C::make_skeleton_inst_ctor(ctx, &v4);
    // Rule at <OUT_DIR>/clif_opt.isle line 1241.
    return v5;
}

// Generated as internal constructor for term umul_overflow.
pub fn constructor_umul_overflow<C: Context>(
    ctx: &mut C,
    arg0: Value,
    arg1: Value,
) -> Inst {
    let v3 = &C::value_array_2_ctor(ctx, arg0, arg1);
    let v4 = InstructionData::Binary {
        opcode: Opcode::UmulOverflow,
        args: v3.clone(),
    };
    let v5 = C::make_skeleton_inst_ctor(ctx, &v4);
    // Rule at <OUT_DIR>/clif_opt.isle line 1250.
    return v5;
}

// Generated as internal constructor for term smul_overflow.
pub fn constructor_smul_overflow<C: Context>(
    ctx: &mut C,
    arg0: Value,
    arg1: Value,
) -> Inst {
    let v3 = &C::value_array_2_ctor(ctx, arg0, arg1);
    let v4 = InstructionData::Binary {
        opcode: Opcode::SmulOverflow,
        args: v3.clone(),
    };
    let v5 = C::make_skeleton_inst_ctor(ctx, &v4);
    // Rule at <OUT_DIR>/clif_opt.isle line 1259.
    return v5;
}

// Generated as internal constructor for term uadd_overflow_trap.
pub fn constructor_uadd_overflow_trap<C: Context>(
    ctx: &mut C,
    arg0: Value,
    arg1: Value,
    arg2: &TrapCode,
) -> Inst {
    let v4 = &C::value_array_2_ctor(ctx, arg0, arg1);
    let v5 = InstructionData::IntAddTrap {
        opcode: Opcode::UaddOverflowTrap,
        args: v4.clone(),
        code: arg2.clone(),
    };
    let v6 = C::make_skeleton_inst_ctor(ctx, &v5);
    // Rule at <OUT_DIR>/clif_opt.isle line 1268.
    return v6;
}

// Generated as internal constructor for term ssub_overflow_bin.
pub fn constructor_ssub_overflow_bin<C: Context>(
    ctx: &mut C,
    arg0: Value,
    arg1: Value,
    arg2: Value,
) -> Inst {
    let v4 = &C::value_array_3_ctor(ctx, arg0, arg1, arg2);
    let v5 = InstructionData::Ternary {
        opcode: Opcode::SsubOverflowBin,
        args: v4.clone(),
    };
    let v6 = C::make_skeleton_inst_ctor(ctx, &v5);
    // Rule at <OUT_DIR>/clif_opt.isle line 1277.
    return v6;
}

// Generated as internal constructor for term usub_overflow_bin.
pub fn constructor_usub_overflow_bin<C: Context>(
    ctx: &mut C,
    arg0: Value,
    arg1: Value,
    arg2: Value,
) -> Inst {
    let v4 = &C::value_array_3_ctor(ctx, arg0, arg1, arg2);
    let v5 = InstructionData::Ternary {
        opcode: Opcode::UsubOverflowBin,
        args: v4.clone(),
    };
    let v6 = C::make_skeleton_inst_ctor(ctx, &v5);
    // Rule at <OUT_DIR>/clif_opt.isle line 1286.
    return v6;
}

// Generated as internal constructor for term band.
pub fn constructor_band<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
) -> Value {
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v5 = InstructionData::Binary {
        opcode: Opcode::Band,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at <OUT_DIR>/clif_opt.isle line 1295.
    return v6;
}

// Generated as internal constructor for term bor.
pub fn constructor_bor<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
) -> Value {
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v5 = InstructionData::Binary {
        opcode: Opcode::Bor,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at <OUT_DIR>/clif_opt.isle line 1304.
    return v6;
}

// Generated as internal constructor for term bxor.
pub fn constructor_bxor<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
) -> Value {
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v5 = InstructionData::Binary {
        opcode: Opcode::Bxor,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at <OUT_DIR>/clif_opt.isle line 1313.
    return v6;
}

// Generated as internal constructor for term bnot.
pub fn constructor_bnot<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
) -> Value {
    let v3 = InstructionData::Unary {
        opcode: Opcode::Bnot,
        arg: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at <OUT_DIR>/clif_opt.isle line 1322.
    return v4;
}

// Generated as internal constructor for term band_not.
pub fn constructor_band_not<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
) -> Value {
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v5 = InstructionData::Binary {
        opcode: Opcode::BandNot,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at <OUT_DIR>/clif_opt.isle line 1331.
    return v6;
}

// Generated as internal constructor for term bor_not.
pub fn constructor_bor_not<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
) -> Value {
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v5 = InstructionData::Binary {
        opcode: Opcode::BorNot,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at <OUT_DIR>/clif_opt.isle line 1340.
    return v6;
}

// Generated as internal constructor for term bxor_not.
pub fn constructor_bxor_not<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
) -> Value {
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v5 = InstructionData::Binary {
        opcode: Opcode::BxorNot,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at <OUT_DIR>/clif_opt.isle line 1349.
    return v6;
}

// Generated as internal constructor for term band_imm.
pub fn constructor_band_imm<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Imm64,
) -> Value {
    let v4 = InstructionData::BinaryImm64 {
        opcode: Opcode::BandImm,
        arg: arg1,
        imm: arg2,
    };
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);
    // Rule at <OUT_DIR>/clif_opt.isle line 1358.
    return v5;
}

// Generated as internal constructor for term bor_imm.
pub fn constructor_bor_imm<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Imm64,
) -> Value {
    let v4 = InstructionData::BinaryImm64 {
        opcode: Opcode::BorImm,
        arg: arg1,
        imm: arg2,
    };
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);
    // Rule at <OUT_DIR>/clif_opt.isle line 1367.
    return v5;
}

// Generated as internal constructor for term bxor_imm.
pub fn constructor_bxor_imm<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Imm64,
) -> Value {
    let v4 = InstructionData::BinaryImm64 {
        opcode: Opcode::BxorImm,
        arg: arg1,
        imm: arg2,
    };
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);
    // Rule at <OUT_DIR>/clif_opt.isle line 1376.
    return v5;
}

// Generated as internal constructor for term rotl.
pub fn constructor_rotl<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
) -> Value {
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v5 = InstructionData::Binary {
        opcode: Opcode::Rotl,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at <OUT_DIR>/clif_opt.isle line 1385.
    return v6;
}

// Generated as internal constructor for term rotr.
pub fn constructor_rotr<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
) -> Value {
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v5 = InstructionData::Binary {
        opcode: Opcode::Rotr,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at <OUT_DIR>/clif_opt.isle line 1394.
    return v6;
}

// Generated as internal constructor for term rotl_imm.
pub fn constructor_rotl_imm<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Imm64,
) -> Value {
    let v4 = InstructionData::BinaryImm64 {
        opcode: Opcode::RotlImm,
        arg: arg1,
        imm: arg2,
    };
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);
    // Rule at <OUT_DIR>/clif_opt.isle line 1403.
    return v5;
}

// Generated as internal constructor for term rotr_imm.
pub fn constructor_rotr_imm<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Imm64,
) -> Value {
    let v4 = InstructionData::BinaryImm64 {
        opcode: Opcode::RotrImm,
        arg: arg1,
        imm: arg2,
    };
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);
    // Rule at <OUT_DIR>/clif_opt.isle line 1412.
    return v5;
}

// Generated as internal constructor for term ishl.
pub fn constructor_ishl<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
) -> Value {
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v5 = InstructionData::Binary {
        opcode: Opcode::Ishl,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at <OUT_DIR>/clif_opt.isle line 1421.
    return v6;
}

// Generated as internal constructor for term ushr.
pub fn constructor_ushr<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
) -> Value {
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v5 = InstructionData::Binary {
        opcode: Opcode::Ushr,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at <OUT_DIR>/clif_opt.isle line 1430.
    return v6;
}

// Generated as internal constructor for term sshr.
pub fn constructor_sshr<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
) -> Value {
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v5 = InstructionData::Binary {
        opcode: Opcode::Sshr,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at <OUT_DIR>/clif_opt.isle line 1439.
    return v6;
}

// Generated as internal constructor for term ishl_imm.
pub fn constructor_ishl_imm<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Imm64,
) -> Value {
    let v4 = InstructionData::BinaryImm64 {
        opcode: Opcode::IshlImm,
        arg: arg1,
        imm: arg2,
    };
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);
    // Rule at <OUT_DIR>/clif_opt.isle line 1448.
    return v5;
}

// Generated as internal constructor for term ushr_imm.
pub fn constructor_ushr_imm<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Imm64,
) -> Value {
    let v4 = InstructionData::BinaryImm64 {
        opcode: Opcode::UshrImm,
        arg: arg1,
        imm: arg2,
    };
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);
    // Rule at <OUT_DIR>/clif_opt.isle line 1457.
    return v5;
}

// Generated as internal constructor for term sshr_imm.
pub fn constructor_sshr_imm<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Imm64,
) -> Value {
    let v4 = InstructionData::BinaryImm64 {
        opcode: Opcode::SshrImm,
        arg: arg1,
        imm: arg2,
    };
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);
    // Rule at <OUT_DIR>/clif_opt.isle line 1466.
    return v5;
}

// Generated as internal constructor for term bitrev.
pub fn constructor_bitrev<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
) -> Value {
    let v3 = InstructionData::Unary {
        opcode: Opcode::Bitrev,
        arg: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at <OUT_DIR>/clif_opt.isle line 1475.
    return v4;
}

// Generated as internal constructor for term clz.
pub fn constructor_clz<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
) -> Value {
    let v3 = InstructionData::Unary {
        opcode: Opcode::Clz,
        arg: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at <OUT_DIR>/clif_opt.isle line 1484.
    return v4;
}

// Generated as internal constructor for term cls.
pub fn constructor_cls<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
) -> Value {
    let v3 = InstructionData::Unary {
        opcode: Opcode::Cls,
        arg: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at <OUT_DIR>/clif_opt.isle line 1493.
    return v4;
}

// Generated as internal constructor for term ctz.
pub fn constructor_ctz<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
) -> Value {
    let v3 = InstructionData::Unary {
        opcode: Opcode::Ctz,
        arg: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at <OUT_DIR>/clif_opt.isle line 1502.
    return v4;
}

// Generated as internal constructor for term bswap.
pub fn constructor_bswap<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
) -> Value {
    let v3 = InstructionData::Unary {
        opcode: Opcode::Bswap,
        arg: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at <OUT_DIR>/clif_opt.isle line 1511.
    return v4;
}

// Generated as internal constructor for term popcnt.
pub fn constructor_popcnt<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
) -> Value {
    let v3 = InstructionData::Unary {
        opcode: Opcode::Popcnt,
        arg: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at <OUT_DIR>/clif_opt.isle line 1520.
    return v4;
}

// Generated as internal constructor for term fcmp.
pub fn constructor_fcmp<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: &FloatCC,
    arg2: Value,
    arg3: Value,
) -> Value {
    let v5 = &C::value_array_2_ctor(ctx, arg2, arg3);
    let v6 = InstructionData::FloatCompare {
        opcode: Opcode::Fcmp,
        args: v5.clone(),
        cond: arg1.clone(),
    };
    let v7 = C::make_inst_ctor(ctx, arg0, &v6);
    // Rule at <OUT_DIR>/clif_opt.isle line 1529.
    return v7;
}

// Generated as internal constructor for term fadd.
pub fn constructor_fadd<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
) -> Value {
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v5 = InstructionData::Binary {
        opcode: Opcode::Fadd,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at <OUT_DIR>/clif_opt.isle line 1538.
    return v6;
}

// Generated as internal constructor for term fsub.
pub fn constructor_fsub<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
) -> Value {
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v5 = InstructionData::Binary {
        opcode: Opcode::Fsub,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at <OUT_DIR>/clif_opt.isle line 1547.
    return v6;
}

// Generated as internal constructor for term fmul.
pub fn constructor_fmul<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
) -> Value {
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v5 = InstructionData::Binary {
        opcode: Opcode::Fmul,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at <OUT_DIR>/clif_opt.isle line 1556.
    return v6;
}

// Generated as internal constructor for term fdiv.
pub fn constructor_fdiv<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
) -> Value {
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v5 = InstructionData::Binary {
        opcode: Opcode::Fdiv,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at <OUT_DIR>/clif_opt.isle line 1565.
    return v6;
}

// Generated as internal constructor for term sqrt.
pub fn constructor_sqrt<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
) -> Value {
    let v3 = InstructionData::Unary {
        opcode: Opcode::Sqrt,
        arg: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at <OUT_DIR>/clif_opt.isle line 1574.
    return v4;
}

// Generated as internal constructor for term fma.
pub fn constructor_fma<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
    arg3: Value,
) -> Value {
    let v5 = &C::value_array_3_ctor(ctx, arg1, arg2, arg3);
    let v6 = InstructionData::Ternary {
        opcode: Opcode::Fma,
        args: v5.clone(),
    };
    let v7 = C::make_inst_ctor(ctx, arg0, &v6);
    // Rule at <OUT_DIR>/clif_opt.isle line 1583.
    return v7;
}

// Generated as internal constructor for term fneg.
pub fn constructor_fneg<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
) -> Value {
    let v3 = InstructionData::Unary {
        opcode: Opcode::Fneg,
        arg: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at <OUT_DIR>/clif_opt.isle line 1592.
    return v4;
}

// Generated as internal constructor for term fabs.
pub fn constructor_fabs<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
) -> Value {
    let v3 = InstructionData::Unary {
        opcode: Opcode::Fabs,
        arg: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at <OUT_DIR>/clif_opt.isle line 1601.
    return v4;
}

// Generated as internal constructor for term fcopysign.
pub fn constructor_fcopysign<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
) -> Value {
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v5 = InstructionData::Binary {
        opcode: Opcode::Fcopysign,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at <OUT_DIR>/clif_opt.isle line 1610.
    return v6;
}

// Generated as internal constructor for term fmin.
pub fn constructor_fmin<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
) -> Value {
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v5 = InstructionData::Binary {
        opcode: Opcode::Fmin,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at <OUT_DIR>/clif_opt.isle line 1619.
    return v6;
}

// Generated as internal constructor for term fmax.
pub fn constructor_fmax<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
) -> Value {
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v5 = InstructionData::Binary {
        opcode: Opcode::Fmax,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at <OUT_DIR>/clif_opt.isle line 1628.
    return v6;
}

// Generated as internal constructor for term ceil.
pub fn constructor_ceil<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
) -> Value {
    let v3 = InstructionData::Unary {
        opcode: Opcode::Ceil,
        arg: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at <OUT_DIR>/clif_opt.isle line 1637.
    return v4;
}

// Generated as internal constructor for term floor.
pub fn constructor_floor<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
) -> Value {
    let v3 = InstructionData::Unary {
        opcode: Opcode::Floor,
        arg: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at <OUT_DIR>/clif_opt.isle line 1646.
    return v4;
}

// Generated as internal constructor for term trunc.
pub fn constructor_trunc<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
) -> Value {
    let v3 = InstructionData::Unary {
        opcode: Opcode::Trunc,
        arg: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at <OUT_DIR>/clif_opt.isle line 1655.
    return v4;
}

// Generated as internal constructor for term nearest.
pub fn constructor_nearest<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
) -> Value {
    let v3 = InstructionData::Unary {
        opcode: Opcode::Nearest,
        arg: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at <OUT_DIR>/clif_opt.isle line 1664.
    return v4;
}

// Generated as internal constructor for term bitcast.
pub fn constructor_bitcast<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: MemFlags,
    arg2: Value,
) -> Value {
    let v4 = InstructionData::LoadNoOffset {
        opcode: Opcode::Bitcast,
        arg: arg2,
        flags: arg1,
    };
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);
    // Rule at <OUT_DIR>/clif_opt.isle line 1673.
    return v5;
}

// Generated as internal constructor for term scalar_to_vector.
pub fn constructor_scalar_to_vector<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
) -> Value {
    let v3 = InstructionData::Unary {
        opcode: Opcode::ScalarToVector,
        arg: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at <OUT_DIR>/clif_opt.isle line 1682.
    return v4;
}

// Generated as internal constructor for term bmask.
pub fn constructor_bmask<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
) -> Value {
    let v3 = InstructionData::Unary {
        opcode: Opcode::Bmask,
        arg: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at <OUT_DIR>/clif_opt.isle line 1691.
    return v4;
}

// Generated as internal constructor for term ireduce.
pub fn constructor_ireduce<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
) -> Value {
    let v3 = InstructionData::Unary {
        opcode: Opcode::Ireduce,
        arg: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at <OUT_DIR>/clif_opt.isle line 1700.
    return v4;
}

// Generated as internal constructor for term snarrow.
pub fn constructor_snarrow<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
) -> Value {
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v5 = InstructionData::Binary {
        opcode: Opcode::Snarrow,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at <OUT_DIR>/clif_opt.isle line 1709.
    return v6;
}

// Generated as internal constructor for term unarrow.
pub fn constructor_unarrow<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
) -> Value {
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v5 = InstructionData::Binary {
        opcode: Opcode::Unarrow,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at <OUT_DIR>/clif_opt.isle line 1718.
    return v6;
}

// Generated as internal constructor for term uunarrow.
pub fn constructor_uunarrow<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
) -> Value {
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v5 = InstructionData::Binary {
        opcode: Opcode::Uunarrow,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at <OUT_DIR>/clif_opt.isle line 1727.
    return v6;
}

// Generated as internal constructor for term swiden_low.
pub fn constructor_swiden_low<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
) -> Value {
    let v3 = InstructionData::Unary {
        opcode: Opcode::SwidenLow,
        arg: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at <OUT_DIR>/clif_opt.isle line 1736.
    return v4;
}

// Generated as internal constructor for term swiden_high.
pub fn constructor_swiden_high<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
) -> Value {
    let v3 = InstructionData::Unary {
        opcode: Opcode::SwidenHigh,
        arg: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at <OUT_DIR>/clif_opt.isle line 1745.
    return v4;
}

// Generated as internal constructor for term uwiden_low.
pub fn constructor_uwiden_low<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
) -> Value {
    let v3 = InstructionData::Unary {
        opcode: Opcode::UwidenLow,
        arg: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at <OUT_DIR>/clif_opt.isle line 1754.
    return v4;
}

// Generated as internal constructor for term uwiden_high.
pub fn constructor_uwiden_high<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
) -> Value {
    let v3 = InstructionData::Unary {
        opcode: Opcode::UwidenHigh,
        arg: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at <OUT_DIR>/clif_opt.isle line 1763.
    return v4;
}

// Generated as internal constructor for term iadd_pairwise.
pub fn constructor_iadd_pairwise<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
) -> Value {
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v5 = InstructionData::Binary {
        opcode: Opcode::IaddPairwise,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at <OUT_DIR>/clif_opt.isle line 1772.
    return v6;
}

// Generated as internal constructor for term x86_pmaddubsw.
pub fn constructor_x86_pmaddubsw<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
) -> Value {
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v5 = InstructionData::Binary {
        opcode: Opcode::X86Pmaddubsw,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at <OUT_DIR>/clif_opt.isle line 1781.
    return v6;
}

// Generated as internal constructor for term uextend.
pub fn constructor_uextend<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
) -> Value {
    let v3 = InstructionData::Unary {
        opcode: Opcode::Uextend,
        arg: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at <OUT_DIR>/clif_opt.isle line 1790.
    return v4;
}

// Generated as internal constructor for term sextend.
pub fn constructor_sextend<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
) -> Value {
    let v3 = InstructionData::Unary {
        opcode: Opcode::Sextend,
        arg: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at <OUT_DIR>/clif_opt.isle line 1799.
    return v4;
}

// Generated as internal constructor for term fpromote.
pub fn constructor_fpromote<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
) -> Value {
    let v3 = InstructionData::Unary {
        opcode: Opcode::Fpromote,
        arg: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at <OUT_DIR>/clif_opt.isle line 1808.
    return v4;
}

// Generated as internal constructor for term fdemote.
pub fn constructor_fdemote<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
) -> Value {
    let v3 = InstructionData::Unary {
        opcode: Opcode::Fdemote,
        arg: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at <OUT_DIR>/clif_opt.isle line 1817.
    return v4;
}

// Generated as internal constructor for term fvdemote.
pub fn constructor_fvdemote<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
) -> Value {
    let v3 = InstructionData::Unary {
        opcode: Opcode::Fvdemote,
        arg: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at <OUT_DIR>/clif_opt.isle line 1826.
    return v4;
}

// Generated as internal constructor for term fvpromote_low.
pub fn constructor_fvpromote_low<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
) -> Value {
    let v3 = InstructionData::Unary {
        opcode: Opcode::FvpromoteLow,
        arg: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at <OUT_DIR>/clif_opt.isle line 1835.
    return v4;
}

// Generated as internal constructor for term fcvt_to_uint.
pub fn constructor_fcvt_to_uint<C: Context>(
    ctx: &mut C,
    arg0: Value,
) -> Inst {
    let v2 = InstructionData::Unary {
        opcode: Opcode::FcvtToUint,
        arg: arg0,
    };
    let v3 = C::make_skeleton_inst_ctor(ctx, &v2);
    // Rule at <OUT_DIR>/clif_opt.isle line 1844.
    return v3;
}

// Generated as internal constructor for term fcvt_to_sint.
pub fn constructor_fcvt_to_sint<C: Context>(
    ctx: &mut C,
    arg0: Value,
) -> Inst {
    let v2 = InstructionData::Unary {
        opcode: Opcode::FcvtToSint,
        arg: arg0,
    };
    let v3 = C::make_skeleton_inst_ctor(ctx, &v2);
    // Rule at <OUT_DIR>/clif_opt.isle line 1853.
    return v3;
}

// Generated as internal constructor for term fcvt_to_uint_sat.
pub fn constructor_fcvt_to_uint_sat<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
) -> Value {
    let v3 = InstructionData::Unary {
        opcode: Opcode::FcvtToUintSat,
        arg: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at <OUT_DIR>/clif_opt.isle line 1862.
    return v4;
}

// Generated as internal constructor for term fcvt_to_sint_sat.
pub fn constructor_fcvt_to_sint_sat<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
) -> Value {
    let v3 = InstructionData::Unary {
        opcode: Opcode::FcvtToSintSat,
        arg: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at <OUT_DIR>/clif_opt.isle line 1871.
    return v4;
}

// Generated as internal constructor for term x86_cvtt2dq.
pub fn constructor_x86_cvtt2dq<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
) -> Value {
    let v3 = InstructionData::Unary {
        opcode: Opcode::X86Cvtt2dq,
        arg: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at <OUT_DIR>/clif_opt.isle line 1880.
    return v4;
}

// Generated as internal constructor for term fcvt_from_uint.
pub fn constructor_fcvt_from_uint<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
) -> Value {
    let v3 = InstructionData::Unary {
        opcode: Opcode::FcvtFromUint,
        arg: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at <OUT_DIR>/clif_opt.isle line 1889.
    return v4;
}

// Generated as internal constructor for term fcvt_from_sint.
pub fn constructor_fcvt_from_sint<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
) -> Value {
    let v3 = InstructionData::Unary {
        opcode: Opcode::FcvtFromSint,
        arg: arg1,
    };
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
    // Rule at <OUT_DIR>/clif_opt.isle line 1898.
    return v4;
}

// Generated as internal constructor for term isplit.
pub fn constructor_isplit<C: Context>(
    ctx: &mut C,
    arg0: Value,
) -> Inst {
    let v2 = InstructionData::Unary {
        opcode: Opcode::Isplit,
        arg: arg0,
    };
    let v3 = C::make_skeleton_inst_ctor(ctx, &v2);
    // Rule at <OUT_DIR>/clif_opt.isle line 1907.
    return v3;
}

// Generated as internal constructor for term iconcat.
pub fn constructor_iconcat<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
) -> Value {
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v5 = InstructionData::Binary {
        opcode: Opcode::Iconcat,
        args: v4.clone(),
    };
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
    // Rule at <OUT_DIR>/clif_opt.isle line 1916.
    return v6;
}

// Generated as internal constructor for term atomic_rmw.
pub fn constructor_atomic_rmw<C: Context>(
    ctx: &mut C,
    arg0: MemFlags,
    arg1: &AtomicRmwOp,
    arg2: Value,
    arg3: Value,
) -> Inst {
    let v5 = &C::value_array_2_ctor(ctx, arg2, arg3);
    let v6 = InstructionData::AtomicRmw {
        opcode: Opcode::AtomicRmw,
        args: v5.clone(),
        flags: arg0,
        op: arg1.clone(),
    };
    let v7 = C::make_skeleton_inst_ctor(ctx, &v6);
    // Rule at <OUT_DIR>/clif_opt.isle line 1925.
    return v7;
}

// Generated as internal constructor for term atomic_cas.
pub fn constructor_atomic_cas<C: Context>(
    ctx: &mut C,
    arg0: MemFlags,
    arg1: Value,
    arg2: Value,
    arg3: Value,
) -> Inst {
    let v5 = &C::value_array_3_ctor(ctx, arg1, arg2, arg3);
    let v6 = InstructionData::AtomicCas {
        opcode: Opcode::AtomicCas,
        args: v5.clone(),
        flags: arg0,
    };
    let v7 = C::make_skeleton_inst_ctor(ctx, &v6);
    // Rule at <OUT_DIR>/clif_opt.isle line 1934.
    return v7;
}

// Generated as internal constructor for term atomic_load.
pub fn constructor_atomic_load<C: Context>(
    ctx: &mut C,
    arg0: MemFlags,
    arg1: Value,
) -> Inst {
    let v3 = InstructionData::LoadNoOffset {
        opcode: Opcode::AtomicLoad,
        arg: arg1,
        flags: arg0,
    };
    let v4 = C::make_skeleton_inst_ctor(ctx, &v3);
    // Rule at <OUT_DIR>/clif_opt.isle line 1943.
    return v4;
}

// Generated as internal constructor for term atomic_store.
pub fn constructor_atomic_store<C: Context>(
    ctx: &mut C,
    arg0: MemFlags,
    arg1: Value,
    arg2: Value,
) -> Inst {
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
    let v5 = InstructionData::StoreNoOffset {
        opcode: Opcode::AtomicStore,
        args: v4.clone(),
        flags: arg0,
    };
    let v6 = C::make_skeleton_inst_ctor(ctx, &v5);
    // Rule at <OUT_DIR>/clif_opt.isle line 1952.
    return v6;
}

// Generated as internal constructor for term fence.
pub fn constructor_fence<C: Context>(
    ctx: &mut C,
) -> Inst {
    let v1 = InstructionData::NullAry {
        opcode: Opcode::Fence,
    };
    let v2 = C::make_skeleton_inst_ctor(ctx, &v1);
    // Rule at <OUT_DIR>/clif_opt.isle line 1961.
    return v2;
}

// Generated as internal constructor for term extract_vector.
pub fn constructor_extract_vector<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Uimm8,
) -> Value {
    let v4 = InstructionData::BinaryImm8 {
        opcode: Opcode::ExtractVector,
        arg: arg1,
        imm: arg2,
    };
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);
    // Rule at <OUT_DIR>/clif_opt.isle line 1970.
    return v5;
}

// Generated as internal constructor for term sequence_point.
pub fn constructor_sequence_point<C: Context>(
    ctx: &mut C,
) -> Inst {
    let v1 = InstructionData::NullAry {
        opcode: Opcode::SequencePoint,
    };
    let v2 = C::make_skeleton_inst_ctor(ctx, &v1);
    // Rule at <OUT_DIR>/clif_opt.isle line 1979.
    return v2;
}
